Lokale Auftragsausführung für Smart-Home-Aktionen aktivieren

1. Hinweis

Mit Smart-Home-Integrationen kann Google Assistant verbundene Geräte in den Haushalte. Zum Erstellen einer Smart-Home-Aktion müssen Sie einen Cloud-Webhook-Endpunkt bereitstellen, der Smart-Home-Intents verarbeiten kann. Sagt ein Nutzer beispielsweise „Hey Google, schalte das Licht an“. sendet Assistant den Befehl an Ihre Cloud-Ausführung, um den Gerätestatus zu aktualisieren.

Das Local Home SDK verbessert die Smart-Home-Integration, indem es einen lokalen Pfad hinzugefügt wird, um Smart-Home-Intents direkt an ein Google Home-Gerät weiterzuleiten. Dies verbessert die Zuverlässigkeit und verringert die Latenz bei der Verarbeitung der . Damit können Sie eine lokale App für die Auftragsausführung in TypeScript oder JavaScript schreiben und bereitstellen, die Geräte identifiziert und Befehle auf allen intelligenten Google Home-Lautsprechern oder Google Nest-Smart-Displays ausführt. Ihre App kommuniziert dann direkt mit der vorhandene Smart-Home-Geräte über das Local Area Network, indem vorhandene Standardprotokolle zur Ausführung von Befehlen verwendet werden.

Vorbereitung

• Entwicklerleitfaden Smart-Home-Aktion erstellen
• Codelab zu Smart-Home-Waschmaschinen
• Entwicklerleitfaden für die lokale Auftragsausführung

Inhalt

In diesem Codelab stellen Sie eine zuvor erstellte Smart-Home-Integration mit Firebase bereit, wenden eine Scankonfiguration in der Actions Console an und erstellen eine lokale App mit TypeScript, um in Node.js geschriebene Befehle an eine virtuelle Waschmaschine zu senden.

Aufgaben in diesem Lab

• Hier erfahren Sie, wie Sie die lokale Auftragsausführung in der Actions Console aktivieren und konfigurieren.
• Mit dem Local Home SDK eine App für die lokale Auftragsausführung entwickeln
• Fehlerbehebung in der App für die lokale Ausführung, die auf dem Google Home-Lautsprecher oder dem Google Nest-Smart Display geladen ist

Voraussetzungen

• Die aktuelle Version von Google Chrome
• Ein iOS- oder Android-Gerät mit der Google Home App
• Einen intelligenten Lautsprecher von Google Home oder ein Smart Display von Google Nest
• Node.js Version 10.16 oder höher
• Ein Google-Konto
• Ein Google Cloud-Rechnungskonto

2. Erste Schritte

Aktivitätseinstellungen aktivieren

Wenn Sie Google Assistant verwenden möchten, müssen Sie bestimmte Aktivitätsdaten mit Google teilen. Google Assistant benötigt diese Daten, um richtig zu funktionieren. Die Anforderung zum Teilen von Daten gilt jedoch nicht speziell für das SDK. Wenn Sie diese Daten teilen möchten, erstellen Sie ein Google-Konto, falls Sie noch keines haben. Sie können ein beliebiges Google-Konto verwenden. Es muss nicht Ihr Entwicklerkonto sein.

Öffnen Sie die Seite Aktivitätseinstellungen für das Google-Konto, das Sie mit Assistant verwenden möchten.

Die folgenden Ein-/Aus-Schalter müssen aktiviert sein:

• Web- und App-Aktivitäten: Klicken Sie außerdem das Kästchen Auch den Chrome-Verlauf sowie Aktivitäten auf Websites, in Apps und auf Geräten berücksichtigen, die Google-Dienste nutzen an.
• Geräteinformationen
• Sprach- und Audioaktivitäten

Actions-Projekt erstellen

1. Rufen Sie die Actions on Google Developer Console auf.
2. Klicken Sie auf Neues Projekt, geben Sie einen Namen für das Projekt ein und klicken Sie auf PROJEKT ERSTELLEN.

Wähle die Smart Home App aus.

Wählen Sie in der Actions Console auf dem Bildschirm „Übersicht“ die Option Smart Home aus.

Wählen Sie die Karte Smart Home aus. Sie werden dann zu Ihrer Projektkonsole weitergeleitet.

Firebase CLI installieren

Mit der Firebase-Befehlszeile (Command Line Interface, CLI) können Sie Ihre Web-Apps lokal bereitstellen und Ihre Web-App für Firebase Hosting bereitstellen.

Führen Sie den folgenden npm-Befehl über das Terminal aus, um die Befehlszeile zu installieren:

npm install -g firebase-tools

Führen Sie folgenden Befehl aus, um zu prüfen, ob die Befehlszeile korrekt installiert wurde:

firebase --version

Autorisieren Sie die Firebase CLI mit Ihrem Google-Konto, indem Sie folgenden Befehl ausführen:

firebase login

HomeGraph API aktivieren

Die HomeGraph API ermöglicht die Speicherung und Abfrage von Geräten und deren Status im Home Graph eines Nutzers. Wenn du diese API verwenden möchtest, musst du zuerst die Google Cloud Console öffnen und die HomeGraph API aktivieren.

Wähle in der Google Cloud Console das Projekt aus, das deinen Aktionen entspricht <project-id>.. Klicke dann auf dem Bildschirm „API-Bibliothek“ für die HomeGraph API auf Aktivieren.

3. Start-App ausführen

Nachdem Sie Ihre Entwicklungsumgebung eingerichtet haben, können Sie das Startprojekt bereitstellen, um zu prüfen, ob alles richtig konfiguriert ist.

Quellcode abrufen

Klicken Sie auf den folgenden Link, um das Beispiel für dieses Codelab auf Ihren Entwicklungscomputer herunterzuladen:

file_downloadQuellcode herunterladen

Oder Sie klonen das GitHub-Repository über die Befehlszeile:

git clone https://github.com/google-home/smarthome-local.git

Über das Projekt

Das Startprojekt enthält die folgenden Unterverzeichnisse:

• public: Frontend-Web-UI zur Steuerung und Überwachung der intelligenten Waschmaschine
• functions: Cloud Functions, die die Cloud-Ausführung für die Smart-Home-Aktion implementiert
• local: Skeleton-Projekt der lokalen Auftragsausführung mit in index.ts vorgefertigten Intent-Handlern

Die bereitgestellte Cloud Auftragsausführung umfasst die folgenden Funktionen in index.js:

• fakeauth: Autorisierungsendpunkt für die Kontoverknüpfung
• faketoken: Tokenendpunkt für die Kontoverknüpfung
• smarthome: Endpunkt für die Smart-Home-Intent-Ausführung
• reportstate: Bei Änderungen des Gerätestatus wird die HomeGraph API aufgerufen.
• updateDevice: Endpunkt, der vom virtuellen Gerät zum Auslösen des Berichtsstatus verwendet wird

Mit Firebase verbinden

Rufen Sie das Verzeichnis app-start auf und richten Sie die Firebase CLI mit Ihrem Actions-Projekt ein:

cd app-start
firebase use <project-id>

Firebase-Projekt konfigurieren

Initialisieren Sie ein Firebase-Projekt.

firebase init

Wählen Sie die CLI-Funktionen, Realtime Database, Functions und das Hosting-Feature aus, das Firebase Hosting enthält.

? Which Firebase CLI features do you want to set up for this directory? Press Space to select features, then
 Enter to confirm your choices.
❯◉ Realtime Database: Configure a security rules file for Realtime Database and (optionally) provision default instance
 ◯ Firestore: Configure security rules and indexes files for Firestore
 ◉ Functions: Configure a Cloud Functions directory and its files
 ◉ Hosting: Configure files for Firebase Hosting and (optionally) set up GitHub Action deploys
 ◯ Hosting: Set up GitHub Action deploys
 ◯ Storage: Configure a security rules file for Cloud Storage
 ◯ Emulators: Set up local emulators for Firebase products
 ◯ Remote Config: Configure a template file for Remote Config
 ◯ Extensions: Set up an empty Extensions manifest

Dadurch werden die erforderlichen APIs und Funktionen für Ihr Projekt initialisiert.

Initialisieren Sie Realtime Database, wenn Sie dazu aufgefordert werden. Sie können den Standardspeicherort für die Datenbankinstanz verwenden.

? It seems like you haven't initialized Realtime Database in your project yet. Do you want to set it up?
Yes

? Please choose the location for your default Realtime Database instance:
us-central1

Da Sie den Startcode des Projekts verwenden, wählen Sie die Standarddatei für die Sicherheitsregeln aus und achten Sie darauf, dass Sie die vorhandene Datenbankregeldatei nicht überschreiben.

? File database.rules.json already exists. Do you want to overwrite it with the Realtime Database Security Rules for <project-ID>-default-rtdb from the Firebase Console?
No

Falls Sie Ihr Projekt neu initialisieren, wählen Sie Überschreiben aus, wenn Sie gefragt werden, ob Sie eine Codebasis initialisieren oder überschreiben möchten.

? Would you like to initialize a new codebase, or overwrite an existing one?
Overwrite

Verwenden Sie beim Konfigurieren der Funktionen die Standarddateien und achten Sie darauf, dass Sie die vorhandenen Dateien index.js und package.json im Projektbeispiel nicht überschreiben.

? What language would you like to use to write Cloud Functions?
JavaScript

? Do you want to use ESLint to catch probable bugs and enforce style?
No

? File functions/package.json already exists. Overwrite?
No

? File functions/index.js already exists. Overwrite?
No

Wenn Sie Ihr Projekt neu initialisieren, wählen Sie No (Nein) aus, wenn Sie gefragt werden, ob Sie „functions/.gitignore“ initialisieren oder überschreiben möchten.

? File functions/.gitignore already exists. Overwrite?
No

? Do you want to install dependencies with npm now?
Yes

Konfigurieren Sie abschließend Ihre Hosting-Einrichtung so, dass im Projektcode das Verzeichnis public verwendet wird, und verwenden Sie die vorhandene Datei index.html. Wählen Sie No (Nein) aus, wenn Sie gefragt werden, ob Sie ESLint verwenden möchten.

? What do you want to use as your public directory?
public

? Configure as a single-page app (rewrite all urls to /index.html)?
Yes

? Set up automatic builds and deploys with GitHub?
No

? File public/index.html already exists. Overwrite?
 No

Wenn ESLint versehentlich aktiviert wurde, gibt es zwei Möglichkeiten, es zu deaktivieren:

1. Gehen Sie über die grafische Benutzeroberfläche zum Ordner ../functions unter dem Projekt, wählen Sie die versteckte Datei .eslintrc.js aus und löschen Sie sie. Verwechseln Sie ihn nicht mit dem ähnlich benannten .eslintrc.json.
2. Über die Befehlszeile:

   cd functions
   rm .eslintrc.js
   

Damit Ihre Firebase-Konfiguration korrekt und vollständig ist, kopieren Sie die Datei firebase.json aus dem Verzeichnis washer-done in das Verzeichnis washer-start und überschreiben Sie dabei die Datei in washer-start.

Im Verzeichnis washer-start:

cp -vp ../washer-done/firebase.json .

In Firebase bereitstellen

Nachdem Sie nun die Abhängigkeiten installiert und das Projekt konfiguriert haben, können Sie die Anwendung zum ersten Mal ausführen.

firebase deploy

Die Ausgabe der Konsole sollte so aussehen:

...

✔ Deploy complete!

Project Console: https://console.firebase.google.com/project/<project-id>/overview
Hosting URL: https://<project-id>.web.app

Mit diesem Befehl wird eine Webanwendung zusammen mit mehreren Cloud Functions for Firebase bereitgestellt.

Öffnen Sie die Hosting-URL in Ihrem Browser (https://<project-id>.web.app), um die Web-App aufzurufen. Sie sehen die folgende Benutzeroberfläche:

Diese Web-UI stellt eine Drittanbieterplattform zum Ansehen oder Ändern des Gerätestatus dar. Klicken Sie auf AKTUALISIEREN, um die Datenbank mit Geräteinformationen zu füllen. Auf der Seite sind keine Änderungen zu sehen, aber der aktuelle Status der Waschmaschine wird in der Datenbank gespeichert.

Verbinden Sie nun den von Ihnen bereitgestellten Cloud-Dienst über die Actions Console mit Google Assistant.

Actions Console-Projekt konfigurieren

Gehen Sie unter Übersicht > Erstellen Sie eine Aktion und wählen Sie Aktion(en) hinzufügen aus. Geben Sie die URL der Cloud Functions-Funktion ein, die die Ausführung für die Smart-Home-Intents ermöglicht, und klicken Sie auf Save (Speichern).

https://us-central1-<project-id>.cloudfunctions.net/smarthome

Klicken Sie auf der Seite Entwickeln > Aufruf, fügen Sie einen Anzeigenamen für Ihre Aktion hinzu und klicken Sie auf Speichern. Dieser Name wird in der Google Home App angezeigt.

Um die Kontoverknüpfung zu aktivieren, wählen Sie die Option Entwickeln > Kontoverknüpfung. Folgende Einstellungen für die Kontoverknüpfung verwenden:

Klicken Sie auf Speichern, um die Konfiguration der Kontoverknüpfung zu speichern. Klicken Sie dann auf Testen, um Tests für Ihr Projekt zu aktivieren.

Du wirst zum Simulator weitergeleitet. Prüfen Sie, ob das Testen für Ihr Projekt aktiviert wurde. Bewegen Sie dazu den Mauszeiger auf das Symbol „Testen auf dem Gerät“ ().

Mit Google Assistant verknüpfen

Damit du deine Smart-Home-Aktion testen kannst, musst du dein Projekt mit einem Google-Konto verknüpfen. So können Tests über Google Assistant-Oberflächen und die Google Home App durchgeführt werden, die im selben Konto angemeldet sind.

1. Öffnen Sie auf Ihrem Smartphone die Google Assistant-Einstellungen. Sie sollten mit demselben Konto angemeldet sein wie in der Konsole.
2. Rufen Sie Google Assistant > Einstellungen > Smart-Home-Steuerung (unter „Assistant“).
3. Klicken Sie oben rechts auf das Suchsymbol.
4. Verwenden Sie das Präfix [test], um nach Ihrer Test-App zu suchen.
5. Wählen Sie das Element aus. Google Assistant authentifiziert sich dann bei deinem Dienst und sendet eine SYNC-Anfrage, in der der Dienst aufgefordert wird, eine Liste der Geräte für den Nutzer bereitzustellen.

Öffnen Sie die Google Home App und prüfen Sie, ob Sie die Waschmaschine sehen können.

Prüfen Sie, ob Sie die Waschmaschine per Sprachbefehl in der Google Home App steuern können. Die Änderung des Gerätestatus sollte auch in der Front-End-Web-UI Ihrer Cloud-Auftragsausführung angezeigt werden.

Jetzt kannst du deiner Aktion die lokale Auftragsausführung hinzufügen.

4. Cloud-Ausführung aktualisieren

Zur Unterstützung der lokalen Auftragsausführung müssen Sie der Cloud-SYNC-Antwort ein neues gerätespezifisches Feld namens otherDeviceIds hinzufügen, das eine eindeutige lokale Kennung für das Gerät enthält. Dieses Feld gibt auch die Möglichkeit an, das Gerät lokal zu steuern.

Fügen Sie das Feld otherDeviceIds der SYNC-Antwort hinzu, wie im folgenden Code-Snippet gezeigt:

functions/index.js

app.onSync((body) => {
  return {
    requestId: body.requestId,
    payload: {
      agentUserId: '123',
      devices: [{
        id: 'washer',
        type: 'action.devices.types.WASHER',
        traits: [ ... ],
        name: { ... },
        deviceInfo: { ... },
        willReportState: true,
        attributes: {
          pausable: true,
        },
        otherDeviceIds: [{
          deviceId: 'deviceid123',
        }],
      }],
    },
  };
});

Stellen Sie das aktualisierte Projekt in Firebase bereit:

firebase deploy --only functions

Rufen Sie nach Abschluss der Bereitstellung die Web-UI auf und klicken Sie in der Symbolleiste auf die Schaltfläche Aktualisieren . Dadurch wird ein Synchronisierungsvorgang angefordert, damit Assistant die aktualisierten SYNC-Antwortdaten erhält.

5. Lokale Ausführung konfigurieren

In diesem Abschnitt fügst du deiner Smart-Home-Aktion die erforderlichen Konfigurationsoptionen für die lokale Ausführung hinzu. Während der Entwicklung veröffentlichen Sie die lokale App für die Auftragsausführung in Firebase Hosting. Dort kann das Google Home-Gerät darauf zugreifen und sie herunterladen.

Wählen Sie in der Actions Console die Option Develop > aus. Aktionen und suchen Sie den Abschnitt Local Home SDK konfigurieren. Geben Sie die folgende URL in das Feld „Test-URL“ ein, fügen Sie Ihre Projekt-ID ein und klicken Sie auf Speichern:

https://<project-id>.web.app/local-home/index.html

Als Nächstes müssen wir festlegen, wie das Google Home-Gerät die lokalen Smart-Home-Geräte erkennen soll. Die Local Home-Plattform unterstützt mehrere Protokolle für die Geräteerkennung, einschließlich mDNS, UPnP und UDP-Broadcast. Sie verwenden eine UDP-Übertragung, um die intelligente Waschmaschine zu finden.

Klicken Sie unter Scankonfiguration für Geräte auf Neue Scankonfiguration, um eine neue Scankonfiguration hinzuzufügen. Wählen Sie UDP als Protokoll aus und füllen Sie die folgenden Attribute aus:

Klicken Sie abschließend oben im Fenster auf Speichern, um Ihre Änderungen zu veröffentlichen.

6. Lokale Ausführung implementieren

Sie entwickeln Ihre lokale App für die Auftragsabwicklung in TypeScript mit dem Typings-Paket des Local Home SDK. Sehen Sie sich das Raster aus dem Startprojekt an:

local/index.ts

/// <reference types="@google/local-home-sdk" />

import App = smarthome.App;
import Constants = smarthome.Constants;
import DataFlow = smarthome.DataFlow;
import Execute = smarthome.Execute;
import Intents = smarthome.Intents;
import IntentFlow = smarthome.IntentFlow;

...

class LocalExecutionApp {

  constructor(private readonly app: App) { }

  identifyHandler(request: IntentFlow.IdentifyRequest):
      Promise<IntentFlow.IdentifyResponse> {
    // TODO: Implement device identification
  }

  executeHandler(request: IntentFlow.ExecuteRequest):
      Promise<IntentFlow.ExecuteResponse> {
    // TODO: Implement local fulfillment
  }

  ...
}

const localHomeSdk = new App('1.0.0');
const localApp = new LocalExecutionApp(localHomeSdk);
localHomeSdk
  .onIdentify(localApp.identifyHandler.bind(localApp))
  .onExecute(localApp.executeHandler.bind(localApp))
  .listen()
  .then(() => console.log('Ready'))
  .catch((e: Error) => console.error(e));

Die Kernkomponente der lokalen Auftragsausführung ist die Klasse smarthome.App. Das Startprojekt hängt Handler für die Intents IDENTIFY und EXECUTE an und ruft dann die Methode listen() auf, um das Local Home SDK darüber zu informieren, dass die App bereit ist.

IDENTIFY-Handler hinzufügen

Das Local Home SDK löst deinen IDENTIFY-Handler aus, wenn das Google Home-Gerät gemäß der Scankonfiguration in der Actions Console nicht bestätigte Geräte im lokalen Netzwerk erkennt.

In der Zwischenzeit ruft die Plattform die identifyHandler mit den resultierenden Scandaten auf, wenn Google ein passendes Gerät findet. In Ihrer App erfolgt das Scannen mithilfe eines UDP-Broadcasts und die Scandaten, die dem IDENTIFY-Handler zur Verfügung gestellt werden, enthalten die vom lokalen Gerät gesendete Antwortnutzlast.

Der Handler gibt eine IdentifyResponse-Instanz mit einer eindeutigen Kennung für das lokale Gerät zurück. Fügen Sie der Methode identifyHandler den folgenden Code hinzu, um die UDP-Antwort des lokalen Geräts zu verarbeiten und die entsprechende lokale Geräte-ID zu ermitteln:

local/index .ts

identifyHandler(request: IntentFlow.IdentifyRequest):
    Promise<IntentFlow.IdentifyResponse> {
  console.log("IDENTIFY intent: " + JSON.stringify(request, null, 2));

  const scanData = request.inputs[0].payload.device.udpScanData;
  if (!scanData) {
    const err = new IntentFlow.HandlerError(request.requestId,
        'invalid_request', 'Invalid scan data');
    return Promise.reject(err);
  }

  // In this codelab, the scan data contains only local device id.
  const localDeviceId = Buffer.from(scanData.data, 'hex');

  const response: IntentFlow.IdentifyResponse = {
    intent: Intents.IDENTIFY,
    requestId: request.requestId,
    payload: {
      device: {
        id: 'washer',
        verificationId: localDeviceId.toString(),
      }
    }
  };
  console.log("IDENTIFY response: " + JSON.stringify(response, null, 2));

  return Promise.resolve(response);
}

Beachten Sie, dass das Feld verificationId mit einem der otherDeviceIds-Werte in Ihrer SYNC-Antwort übereinstimmen muss. Dadurch wird das Gerät im Home Graph des Nutzers als verfügbar für die lokale Ausführung gekennzeichnet. Sobald Google eine Übereinstimmung gefunden hat, gilt das Gerät als bestätigt und für die lokale Ausführung bereit.

EXECUTE-Handler hinzufügen

Das Local Home SDK löst den EXECUTE-Handler aus, wenn ein Gerät, das die lokale Auftragsausführung unterstützt, einen Befehl empfängt. Der Inhalt des lokalen Intents entspricht dem EXECUTE-Intent, der an die Cloud-Auftragsausführung gesendet wurde. Die Logik für die lokale Verarbeitung des Intents ähnelt also Ihrer Verarbeitung in der Cloud.

Die Anwendung kann TCP/UDP-Sockets oder HTTP(S)-Anfragen verwenden, um mit lokalen Geräten zu kommunizieren. In diesem Codelab dient HTTP als Protokoll zur Steuerung des virtuellen Geräts. Die Portnummer ist in index.ts als Variable SERVER_PORT definiert.

Fügen Sie der Methode executeHandler den folgenden Code hinzu, um eingehende Befehle zu verarbeiten und über HTTP an das lokale Gerät zu senden:

local/index.ts

executeHandler(request: IntentFlow.ExecuteRequest):
    Promise<IntentFlow.ExecuteResponse> {
  console.log("EXECUTE intent: " + JSON.stringify(request, null, 2));

  const command = request.inputs[0].payload.commands[0];
  const execution = command.execution[0];
  const response = new Execute.Response.Builder()
    .setRequestId(request.requestId);

  const promises: Array<Promise<void>> = command.devices.map((device) => {
    console.log("Handling EXECUTE intent for device: " + JSON.stringify(device));

    // Convert execution params to a string for the local device
    const params = execution.params as IWasherParams;
    const payload = this.getDataForCommand(execution.command, params);

    // Create a command to send over the local network
    const radioCommand = new DataFlow.HttpRequestData();
    radioCommand.requestId = request.requestId;
    radioCommand.deviceId = device.id;
    radioCommand.data = JSON.stringify(payload);
    radioCommand.dataType = 'application/json';
    radioCommand.port = SERVER_PORT;
    radioCommand.method = Constants.HttpOperation.POST;
    radioCommand.isSecure = false;

    console.log("Sending request to the smart home device:", payload);

    return this.app.getDeviceManager()
      .send(radioCommand)
      .then(() => {
        const state = {online: true};
        response.setSuccessState(device.id, Object.assign(state, params));
        console.log(`Command successfully sent to ${device.id}`);
      })
      .catch((e: IntentFlow.HandlerError) => {
        e.errorCode = e.errorCode || 'invalid_request';
        response.setErrorState(device.id, e.errorCode);
        console.error('An error occurred sending the command', e.errorCode);
      });
  });

  return Promise.all(promises)
    .then(() => {
      return response.build();
    })
    .catch((e) => {
      const err = new IntentFlow.HandlerError(request.requestId,
          'invalid_request', e.message);
      return Promise.reject(err);
    });
}

TypeScript-App kompilieren

Rufen Sie das Verzeichnis local/ auf und führen Sie die folgenden Befehle aus, um den TypeScript-Compiler herunterzuladen und die App zu kompilieren:

cd local
npm install
npm run build

Dadurch wird die index.ts (TypeScript)-Quelle kompiliert und der folgende Inhalt im Verzeichnis public/local-home/ abgelegt:

• bundle.js: Kompilierte JavaScript-Ausgabe mit der lokalen App und den Abhängigkeiten.
• index.html: Lokale Hostseite, über die die App zum Testen auf dem Gerät bereitgestellt wird

Testprojekt bereitstellen

Stellen Sie die aktualisierten Projektdateien in Firebase Hosting bereit, damit Sie über Google Home darauf zugreifen können.

firebase deploy --only hosting

7. Intelligente Waschmaschine starten

Jetzt ist es an der Zeit, die Kommunikation zwischen Ihrer lokalen App für die Auftragsausführung und der intelligenten Waschmaschine zu testen. Das Codelab-Startprojekt enthält eine virtual intelligente Waschmaschine, die in Node.js geschrieben ist und eine intelligente Waschmaschine simuliert, die Nutzer lokal steuern können.

Gerät konfigurieren

Sie müssen das virtuelle Gerät so konfigurieren, dass es dieselben UDP-Parameter verwendet, die Sie in der Actions Console auf die Scankonfiguration für die Geräteerkennung angewendet haben. Außerdem müssen Sie dem virtuellen Gerät mitteilen, welche lokale Geräte-ID gemeldet werden soll und welche Actions-Projekt-ID für Report State-Ereignisse verwendet werden soll, wenn sich der Gerätestatus ändert.

Gerät starten

Rufen Sie das Verzeichnis virtual-device/ auf und führen Sie das Geräteskript aus. Übergeben Sie dabei die Konfigurationsparameter als Argumente:

cd virtual-device
npm install
npm start -- \
  --deviceId=deviceid123 --projectId=<project-id> \
  --discoveryPortOut=3311 --discoveryPacket=HelloLocalHomeSDK

Prüfen Sie, ob das Geräteskript mit den erwarteten Parametern ausgeführt wird:

(...): UDP Server listening on 3311
(...): Device listening on port 3388
(...): Report State successful

8. Fehler in der TypeScript-App beheben

Im folgenden Abschnitt prüfen Sie, ob das Google Home-Gerät die virtuelle intelligente Waschmaschine ordnungsgemäß scannen, identifizieren und Befehle über das lokale Netzwerk senden kann. Mit den Google Chrome-Entwicklertools können Sie eine Verbindung mit dem Google Home-Gerät herstellen, die Konsolenprotokolle aufrufen und Fehler in der TypeScript-App beheben.

Chrome-Entwicklertools verbinden

So verbinden Sie den Debugger mit Ihrer lokalen App für die Auftragsausführung:

1. Prüfen Sie, ob Sie Ihr Google Home-Gerät mit einem Nutzer verknüpft haben, der auf das Actions Console-Projekt zugreifen darf.
2. Starten Sie Ihr Google Home-Gerät neu, um die URL Ihres HTML-Codes sowie die Scankonfiguration abzurufen, die Sie in der Actions Console festgelegt haben.
3. Starten Sie Chrome auf Ihrem Entwicklungscomputer.
4. Öffnen Sie einen neuen Chrome-Tab und geben Sie chrome://inspect in das Adressfeld ein, um das Prüftool zu starten.

Auf der Seite sollten Sie eine Liste mit Geräten sehen und die App-URL sollte unter dem Namen Ihres Google Home-Geräts angezeigt werden.

Inspector starten

Klicken Sie unter der App-URL auf Prüfen, um die Chrome-Entwicklertools zu starten. Wählen Sie den Tab Console aus und prüfen Sie, ob Sie den Inhalt des Intents IDENTIFY sehen können, der von Ihrer TypeScript-App ausgegeben wird.

Diese Ausgabe bedeutet, dass Ihre lokale App für die Auftragsausführung das virtuelle Gerät erfolgreich erkannt und identifiziert hat.

Lokale Ausführung testen

Sie können Befehle an Ihr Gerät über die Touchbedienung in der Google Home App oder per Sprachbefehl an das Google Home-Gerät senden, z. B.:

„Hey Google, schalte meine Waschmaschine ein.“

„Hey Google, starte meine Waschmaschine.“

„Hey Google, stopp die Waschmaschine.“

Dadurch sollte die Plattform den Intent EXECUTE an Ihre TypeScript-App senden.

Prüfen Sie, ob Sie bei jedem Befehl die Änderung des Status der lokalen intelligenten Waschmaschine sehen können.

...
***** The washer is RUNNING *****
...
***** The washer is STOPPED *****

9. Glückwunsch

Glückwunsch! Du hast das Local Home SDK verwendet, um die lokale Auftragsausführung in eine Smart-Home-Aktion einzubinden.

Weitere Informationen

Außerdem können Sie Folgendes ausprobieren:

• Ändern Sie die Scankonfiguration und sorgen Sie dafür, dass sie funktioniert. Versuchen Sie beispielsweise, einen anderen UDP-Port oder ein anderes Discovery-Paket zu verwenden.
• Ändern Sie die Codebasis des virtuellen Smart-Home-Geräts so, dass sie auf einem eingebetteten Gerät wie einem Raspberry Pi ausgeführt wird. Verwenden Sie LEDs oder ein Display, um den aktuellen Status zu visualisieren.