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

1. Hinweis

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

Das Local Home SDK optimiert die Smart-Home-Integration. Es fügt einen lokalen Pfad hinzu, über den Smart-Home-Intents direkt an ein Google Home-Gerät weitergeleitet werden können. Das erhöht die Zuverlässigkeit und verringert die Latenz bei der Verarbeitung von Nutzerbefehlen. Sie können damit eine lokale App für die Auftragsausführung in TypeScript oder JavaScript schreiben und bereitstellen, die Geräte identifiziert und Befehle auf allen intelligenten Lautsprechern oder Smart Displays von Google Home oder Google Nest ausführt. Ihre App kommuniziert dann über das Local Area Network direkt mit den vorhandenen Smart-Home-Geräten der Nutzer und verwendet dazu vorhandene Standardprotokolle zur Ausführung von Befehlen.

72ffb320986092c.png

Voraussetzungen

Inhalt

In diesem Codelab stellen Sie eine zuvor erstellte Smart-Home-Integration mit Firebase bereit, wenden dann 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.

Lerninhalte

  • Hier erfahren Sie, wie Sie die lokale Auftragsausführung in der Actions Console aktivieren und konfigurieren.
  • Das Local Home SDK zum Schreiben einer App für die lokale Auftragsausführung verwenden
  • Hier erfahren Sie, wie Sie Fehler in der App für die lokale Auftragsausführung beheben, die auf den Google Home-Lautsprecher oder das Google Nest-Smart Display geladen ist.

Voraussetzungen

2. Erste Schritte

Aktivitätseinstellungen aktivieren

Damit Sie Google Assistant nutzen können, 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 ist jedoch nicht spezifisch für das SDK. Wenn Sie diese Daten freigeben möchten, erstellen Sie ein Google-Konto, falls Sie noch keines haben. Dabei kann es sich um ein beliebiges Google-Konto handeln. Dabei muss es sich nicht um ein Entwicklerkonto handeln.

Öffnen Sie die Seite Aktivitätseinstellungen des Google-Kontos, das Sie mit Assistant verwenden möchten.

Die folgenden Schieberegler müssen aktiviert sein:

  • Web- & App-Aktivitäten: Sie müssen das Kästchen Auch den Chrome-Verlauf sowie Aktivitäten auf Websites, in Apps und auf Geräten berücksichtigen, die Google-Dienste nutzen anklicken.
  • Geräteinformationen
  • Sprach- & 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.

AWXw5E1m9zVgvVeyeL3uxwCX6DtWOCK6LRSLmOATFzjMbmE5cSWBdSVhJZDFpEFH2azZTK2eMs6OYYdMJYiGb5bKqFEzxaLyRUYuwVGBlSjXvTy

Die Smart-Home App auswählen

Wählen Sie in der Actions Console auf dem Übersichtsbildschirm die Option Smart Home aus.

36RsBUWBgbgsa5xZ7MJVMm1sIg07nXbfjv0mWCxXViaC5SlbL2gMigw9hgXsZQhNMHLLFOfiKdZsSTNXONFB1i47gksw3SBNpkVYl492WeryOlgxK

Wähle die Karte Smart Home aus. Du wirst dann zur Projektkonsole weitergeleitet.

pzgHPsmc2LvLoeUvJfkjKQqD_BvO4v8JOPlcrxsmyptFkkjL4PP6LqrM9r5tNvEIfT9HmK-UKw3GWFPXTjqo4nUrhD2o5shUKHBE31OT8iIA69JZCev7_0_nh-lnL2oJHoxGfqqZ4w

Firebase CLI installieren

Mit der Firebase-Befehlszeile können Sie Ihre Webanwendungen 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

Prüfen Sie mit dem folgenden Befehl, 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 das Speichern und Abfragen von Geräten und deren Status in Home Graph eines Nutzers. Wenn Sie diese API verwenden möchten, müssen Sie zuerst die Google Cloud Console öffnen und die HomeGraph API aktivieren.

Wählen Sie in der Google Cloud Console das Projekt aus, das mit Ihren Aktionen übereinstimmt. <project-id>.. Klicken Sie dann im Bildschirm „API-Bibliothek“ für die HomeGraph API auf Aktivieren.

5SVCzM8IZLi_9DV8M0nEklv16NXkpvM0bIzQK2hSyKyvnFHBxPOz90rbr72ayxzmxd5aNROOqC_Cp4outbdlwJdObDs0DIE_8vYzw6dovoVrP9IZWlWsZxDS7UHOi1jiRbDMG8MqUA

3. Starte-App ausführen

Nachdem Sie die 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:

...oder Sie können das GitHub-Repository über die Befehlszeile klonen:

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

Über das Projekt

Das Startprojekt enthält die folgenden Unterverzeichnisse:

  • public: Frontend-Web-UI zum Steuern und Überwachen der intelligenten Waschmaschine
  • functions: Cloud Functions zur Implementierung der Cloud-Auftragsausführung für die Smart-Home-Aktion
  • local: Skeleton-Projekt zur lokalen Auftragsausführung mit Intent-Handlern in index.ts

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-Auftragsausführung
  • reportstate: Ruft die HomeGraph API bei Änderungen des Gerätestatus auf
  • 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 Befehlszeilen-Funktionen Echtzeitdatenbank, Funktionen und Hosting aus, die Firebase Hosting enthalten.

? 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 für Ihr Projekt erforderlichen APIs und Funktionen 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 Code des Startprojekts verwenden, wählen Sie die Standarddatei für die Sicherheitsregeln aus und achten Sie darauf, dass Sie die vorhandene Datei mit den Datenbankregeln 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

Wenn 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

Bei der Konfiguration von Functions sollten Sie die Standarddateien verwenden und 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 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 und die vorhandene Datei index.html verwendet werden. Wählen Sie 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 Benutzeroberfläche zum Ordner ../functions unter dem Projekt, wählen Sie die ausgeblendete Datei .eslintrc.js aus und löschen Sie sie. Verwechseln Sie ihn nicht mit .eslintrc.json, der ähnlich heißt.
  2. Über die Befehlszeile:
    cd functions
    rm .eslintrc.js
    

Damit Sie eine korrekte und vollständige Firebase-Konfiguration haben, kopieren Sie die Datei firebase.json aus dem Verzeichnis washer-done in das Verzeichnis washer-start und überschreiben Sie dabei die Datei im Verzeichnis washer-start.

Führen Sie im Verzeichnis washer-start folgende Schritte aus:

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

In Firebase bereitstellen

Nachdem Sie nun die Abhängigkeiten installiert und Ihr 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 werden eine Webanwendung sowie mehrere Cloud Functions for Firebase-Funktionen bereitgestellt.

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

L60eA7MOnPmbBMl2XMipT9MdnP-RaVjyjf0Y93Y1b7mEyIsqZrrwczE7D3RQISRs-iusL1g4XbNmGhuA6-5sLcWefnczwNJEPfNLtwBsO4Tb9YvcAZBI6_rX19z8rxbik9Vq8F2fwg

Diese Web-UI stellt eine Drittanbieterplattform dar, mit der Gerätestatus angezeigt oder geändert werden können. Klicken Sie auf AKTUALISIEREN, um Geräteinformationen in Ihre Datenbank zu übertragen. Sie werden zwar keine Änderungen auf der Seite sehen, der aktuelle Status der Waschmaschine wird jedoch in der Datenbank gespeichert.

Als Nächstes verbinden Sie den von Ihnen bereitgestellten Cloud-Dienst über die Actions Console mit Google Assistant.

Actions Console-Projekt konfigurieren

Wählen Sie unter Übersicht > Aktion erstellen die Option Aktion(en) hinzufügen aus. Geben Sie die URL für die Cloud Functions-Funktion ein, die die Auftragsausführung für die Smart-Home-Intents bereitstellt. Klicken Sie dann auf Speichern.

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

Uso-o00XQXBHvOR9vQq9tmpYDYQJKsFEstsgRFnxPAJf7zJ2FxwhISiodo3dB1Tz49Okd6ivi66fjpo7rarS_GZelglGWCT1r9FzDGUl1r67ddIcIbQrxqN8jG9F9GAKOpk0Ckc-eA

Fügen Sie auf dem Tab Develop > Invocation einen Anzeigenamen für Ihre Aktion hinzu und klicken Sie auf Save (Speichern). Dieser Name wird in der Google Home App angezeigt.

gvC-TvmKDy-D-xjwkeCjNt__9ErA7DL8hZWa1oH1yPJ9SpYOepDYjxx6WnJ56IG-t37fJ65kmHISQdh72Ot2G-0tu6Flxf4gom5kvx_3hlvFeMqYuFgXr_85pfWWn7VLFHtS55p1zw

s4yc1kOW4XtKUQN1EYegiDLU5oTqmxQ2PNbeaujm26OQmYKKpjug7j5FYmutLSAZ1zBd-ZkcZlL7zyTZqw4bge3_oOeWvJTsqJ-A08vfZwImYQrKiquLskLuTpmMqXEZD1xchhCWGQ

Wählen Sie im linken Navigationsbereich die Option Entwickeln > Kontoverknüpfung aus, um die Kontoverknüpfung zu aktivieren. Verwenden Sie diese Einstellungen zur Kontoverknüpfung:

Client-ID

ABC123

Clientschlüssel

DEF456

Autorisierungs-URL

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

Token-URL

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

rRyZTiBSTuPk3YtJtXjDK1pPftUxsaEhs9jzpvFtbHTD6bEwYxM8jV4MWxiljKA1bKVZrIRoO9O3jtBefLKf_OyMpukPjwIj8zGvyU3UwASzMrnRskl-hVAfAmQVi4sC_zAwgYwRXw

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.

OgUvpQfXioygkRwPcaJpzjyNQDZy6enidUC8YMPaCOrZi0YeWCFsCJV9Gqg-_UfsqTnn4KEg--uE3Ymr0QuamDonF4RyYHtRKcULXABDuaEnj2hq8i20LYj1SrGP_1lQ_UsUB90pGw

Sie werden zum Simulator weitergeleitet. Prüfen Sie, ob die Tests für Ihr Projekt aktiviert wurden. Bewegen Sie dazu den Mauszeiger auf das Symbol „Auf dem Gerät testen“ (soCeBB1CkSIEqsBmDc8Cth6EjgcXUnrOHeOpLNlvMiiXM73Rmh8iBK1ZFLFd47kycYqIMq3Fm49ryAGUt79BXVPDyEB1IU3W0fgiL49iqTAVrxRzqr2mm).

2zbfeYpG-wEd2SFP07Wc4mJzHakLX7YvrNw3IV0_0Kd-TonfsKIvvjKWlwvrmTm5jLj3XPWqCtcDd5J2z6gwn9fnchpYVraw1j_mE4M0LVppAl5WY5cK7g0uZyhZ3VFFS25yPmyksg

Damit du deine Smart-Home-Aktion testen kannst, musst du dein Projekt mit einem Google-Konto verknüpfen. Dies ermöglicht Tests über Google Assistant-Oberflächen und die Google Home App, 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. Gehen Sie zu Google Assistant > Einstellungen > Smart-Home-Steuerung (unter „Assistant“).
  3. Klicken Sie rechts oben auf das Suchsymbol.
  4. Sie können mithilfe des Präfixes [test] nach Ihrer Test-App suchen.
  5. Wählen Sie das Element aus. Google Assistant authentifiziert sich dann bei deinem Dienst und sendet eine SYNC-Anfrage, in der dein Dienst dem Nutzer eine Liste der Geräte zur Verfügung stellt.

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

XcWmBVamBZtPfOFqtsr5I38stPWTqDcMfQwbBjetBgxt0FCjEs285pa9K3QXSASptw0KYN2G8yfkT0-xg664V4PjqMreDDs-HPegHjOc4EVtReYPu-WKZyygq9Xmkf8X8z9177nBjQ

Prüfen Sie, ob Sie die Waschmaschine mit Sprachbefehlen in der Google Home App steuern können. Außerdem sollten Sie die Änderung des Gerätestatus in der Frontend-Web-UI Ihrer Cloud-Auftragsausführung sehen können.

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

4. Cloud-Auftragsausführung aktualisieren

Zur Unterstützung der lokalen Auftragsausführung müssen Sie der Cloud-SYNC-Antwort ein neues Feld namens otherDeviceIds pro Gerät hinzufügen. Dieses Feld enthält eine eindeutige lokale Kennung für das Gerät. Dieses Feld gibt auch an, dass das Gerät lokal gesteuert werden kann.

Fügen Sie der Antwort SYNC das Feld otherDeviceIds 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 ae8d3b25777a5e30.png. Dadurch wird eine Synchronisierungsanfrage ausgelöst, damit Assistant die aktualisierten SYNC-Antwortdaten erhält.

bf4f6a866160a982.png

5. Lokale Auftragsausfü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 App für die lokale 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 Entwickeln > Aktionen aus und gehen Sie zum Abschnitt Lokales Home SDK konfigurieren. Geben Sie die folgende URL in das Feld für die Test-URL ein, fügen Sie Ihre Projekt-ID ein und klicken Sie auf Speichern:

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

7d59b31f8d2a988.png

Als Nächstes legen wir fest, wie das Google Home die lokalen Smart-Home-Geräte erkennen soll. Die Local Home-Plattform unterstützt mehrere Protokolle für die Geräteerkennung, darunter mDNS, UPnP und UDP-Broadcast. Sie verwenden UDP-Broadcast, um die intelligente Waschmaschine zu erkennen.

Klicken Sie unter Konfiguration des Gerätescans auf Neue Scankonfiguration, um eine neue Scankonfiguration hinzuzufügen. Wählen Sie UDP als Protokoll aus und geben Sie die folgenden Attribute ein:

Feld

Beschreibung

Vorgeschlagener Wert

Nachricht an alle

UDP-Broadcast-Adresse

255.255.255.255

Broadcast-Port

Port, an den Google Home die UDP-Nachricht sendet

3311

Listener-Port

Port, an dem Google Home auf eine Antwort wartet

3312

Discovery-Paket

UDP-Broadcast-Datennutzlast

48656c6c6f4c6f63616c486f6d6553444b

4777bf63c53b6858.png

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

6. Lokale Ausführung implementieren

Sie entwickeln Ihre App für die lokale Auftragsausführung in TypeScript mithilfe des Typisierungspakets des Local Home SDK. Sehen Sie sich das im Startprojekt bereitgestellte Raster 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 den IDENTIFY-Handler aus, wenn das Google Home-Gerät anhand der in der Actions Console angegebenen Scankonfiguration nicht bestätigte Geräte im lokalen Netzwerk findet.

Wenn Google ein übereinstimmendes Gerät findet, ruft die Plattform identifyHandler mit den resultierenden Scandaten auf. In deiner App erfolgt das Scannen über einen UDP-Broadcast. Die Scandaten, die an den Handler IDENTIFY gesendet werden, enthalten die vom lokalen Gerät gesendete Antwortnutzlast.

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

lokal/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);
}

Das Feld verificationId muss mit einem der otherDeviceIds-Werte in deiner SYNC-Antwort übereinstimmen. Dadurch wird das Gerät in Home Graph des Nutzers als für die lokale Auftragsausführung verfügbar gekennzeichnet. Wenn Google eine Übereinstimmung gefunden hat, gilt dieses Gerät als bestätigt und für die lokale Auftragsausführung bereit.

EXECUTE-Handler hinzufügen

Das Local Home SDK löst deinen 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 Intent EXECUTE, der an Ihre Cloud-Auftragsausführung gesendet wird. Die Logik für die lokale Verarbeitung des Intents entspricht also der Vorgehensweise 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);
    });
}

Die App TypeScript kompilieren

Wechseln Sie zum Verzeichnis local/ 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 Quelle index.ts (TypeScript) kompiliert und der folgende Inhalt wird im Verzeichnis public/local-home/ platziert:

  • bundle.js: Kompilierte JavaScript-Ausgabe mit der lokalen App und den Abhängigkeiten
  • index.html: Lokale Hostingseite, auf der die App für On-Device-Tests bereitgestellt wird.

Testprojekt bereitstellen

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

firebase deploy --only hosting

7. Intelligente Waschmaschine starten

Jetzt ist es an der Zeit, die Kommunikation zwischen Ihrer lokalen Fulfillment-App und der intelligenten Waschmaschine zu testen! Das Codelab-Startprojekt enthält eine in Node.js geschriebene v Waschmaschine, die 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 Scankonfiguration für die Geräteerkennung in der Actions Console 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 Ereignisse vom Typ Berichtsstatus verwendet werden soll, wenn sich der Gerätestatus ändert.

Parameter

Vorgeschlagener Wert

deviceId

deviceid123

discoveryPortOut

3311

discoveryPacket

HelloLocalHomeSDK

projectId

ID deines Actions-Projekts

Gerät starten

Wechseln Sie zum Verzeichnis virtual-device/, führen Sie das Geräteskript aus und übergeben Sie 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 überprüfen Sie, ob das Google Home-Gerät die virtuellen Waschmaschinen richtig scannen, identifizieren und über das lokale Netzwerk Befehle an die virtuelle Waschmaschine senden kann. Mit den Google Chrome-Entwicklertools können Sie eine Verbindung zum Google Home-Gerät herstellen, die Konsolenprotokolle ansehen und Fehler in der TypeScript App beheben.

Chrome-Entwicklertools verbinden

So verbinden Sie den Debugger mit Ihrer lokalen Auftragsausführungs-App:

  1. Sie müssen Ihr Google Home-Gerät mit einem Nutzer verknüpft haben, der über die Berechtigung für den Zugriff auf das Projekt Actions Console verfügt.
  2. Starten Sie Ihr Google Home-Gerät neu. Dadurch kann es die URL Ihres HTML-Codes und die Scan-Konfiguration abrufen, 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 den Inspector zu starten.

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

567f97789a7d8846.png

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 überprüfen Sie, ob Sie den Inhalt des Intents IDENTIFY sehen können, der von Ihrer TypeScript-App gedruckt wurde.

6b67ded470a4c8be.png

Diese Ausgabe bedeutet, dass Ihre lokale App zur Auftragsausführung das virtuelle Gerät gefunden und identifiziert hat.

Lokale Ausführung testen

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

„Hey Google, schalte meine Waschmaschine ein.“

„Hey Google, starte meine Waschmaschine.“

„Hey Google, halte die Waschmaschine an.“

Dadurch sollte die Plattform ausgelöst werden, einen EXECUTE-Intent an Ihre TypeScript-App zu senden.

bc030517dacc3ac9.png

Prüfen Sie, ob sich der Status der lokalen intelligenten Waschmaschine mit jedem Befehl ändert.

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

9. Glückwunsch

764dbc83b95782a.png

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

Weitere Informationen

Außerdem können Sie Folgendes ausprobieren:

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