Lokale Auftragsausführung für Cloud-zu-Cloud-Integrationen aktivieren

1. Hinweis

Mit Smart-Home-Integrationen kann Google Assistant verbundene Geräte in den Haushalten der Nutzer steuern. Wenn Sie eine Cloud-zu-Cloud-Integration erstellen möchten, müssen Sie einen Cloud-Webhook-Endpunkt angeben, der Smart-Home-Intents verarbeiten kann. Wenn ein Nutzer beispielsweise „Hey Google, schalte die Lampen ein“ sagt, sendet Assistant den Befehl an Ihre Cloud-Ausführung, um den Gerätestatus zu aktualisieren.

Das Local Home SDK verbessert Ihre Smart-Home-Integration, indem ein lokaler Pfad hinzugefügt wird, über den Smart-Home-Intents direkt an ein Google Home-Gerät weitergeleitet werden. Dadurch wird die Zuverlässigkeit erhöht und die Latenz bei der Verarbeitung von Nutzerbefehlen verringert. Sie können damit eine lokale App zur Auftragsausführung in TypeScript oder JavaScript schreiben und bereitstellen, die Geräte erkennt und Befehle auf jedem Google Home- oder Google Nest-Smart-Display ausführt. Ihre App kommuniziert dann direkt über das lokale Netzwerk mit den vorhandenen Smart-Home-Geräten der Nutzer und verwendet vorhandene Standardprotokolle, um Befehle auszuführen.

Vorbereitung

• Entwicklerleitfaden zum Erstellen einer Cloud-zu-Cloud-Integration
• Codelab Smart Home Washer
• Entwicklerleitfaden für die lokale Abwicklung

Umfang

In diesem Codelab stellen Sie eine zuvor erstellte Smart-Home-Integration mit Firebase bereit, wenden dann eine Scankonfiguration in der Developer Console an und erstellen mit TypeScript eine lokale App, um in Node.js geschriebene Befehle an ein virtuelles Waschmaschinengerät zu senden.

Aufgaben in diesem Lab

• So aktivieren und konfigurieren Sie die lokale Auftragsausführung in der Entwicklerkonsole.
• So erstellen Sie mit dem Local Home SDK eine App für die lokale Ausführung.
• Informationen zum Beheben von Fehlern bei der lokalen Ausführungs-App, die auf dem Google Home-Lautsprecher oder dem Google Nest-Smart Display geladen ist.

Voraussetzungen

• Die neueste Version von Google Chrome
• Ein iOS- oder Android-Gerät mit der Google Home App
• Einen intelligenten Lautsprecher von Google Home oder ein intelligentes 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 ordnungsgemäß zu funktionieren. Die Datenweitergabe 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. Sie können jedes 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-Schaltflächen müssen aktiviert sein:

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

Cloud-zu-Cloud-Integrationsprojekt erstellen

1. Rufen Sie die Developer Console auf.
2. Klicken Sie auf Projekt erstellen, geben Sie einen Namen für das Projekt ein und klicken Sie auf Projekt erstellen.

Cloud-zu-Cloud-Integration auswählen

Wählen Sie auf der Projektstartseite in der Developer Console unter Cloud-zu-Cloud die Option Cloud-zu-Cloud-Integration hinzufügen aus.

Firebase CLI installieren

Mit der Firebase-Befehlszeile (Firebase Command Line Interface, CLI) können Sie Ihre Webanwendungen lokal bereitstellen und in Firebase Hosting bereitstellen.

Führen Sie zum Installieren der Befehlszeile den folgenden npm-Befehl im Terminal aus:

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:

firebase login

HomeGraph API aktivieren

Mit der HomeGraph API können Geräte und ihre Status im Home Graph eines Nutzers gespeichert und abgefragt werden. 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 Ihrer Integration entspricht. <project-id>. Klicken Sie 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 Starterprojekt 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

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

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

Informationen zum 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 Cloud-zu-Cloud-Integration implementieren
• local – Skelettprojekt für eine App zur lokalen Auftragsausführung mit Stubs für Intent-Handler index.ts

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

• fakeauth: Autorisierungsendpunkt für die Kontoverknüpfung
• faketoken: Token-Endpunkt für die Kontoverknüpfung
• smarthome – Endpunkt für die Smart-Home-Intent-Ausführung
• reportstate – ruft die HomeGraph API bei Änderungen des Gerätestatus auf
• updateDevice: Endpunkt, der vom virtuellen Gerät verwendet wird, um den Berichtsstatus auszulösen

Mit Firebase verbinden

Rufen Sie das Verzeichnis app-start auf und richten Sie die Firebase CLI mit Ihrem Cloud-zu-Cloud-Integrationsprojekt ein:

cd app-start
firebase use <project-id>

Firebase-Projekt konfigurieren

Initialisieren Sie ein Firebase-Projekt.

firebase init

Wählen Sie die CLI-Features Realtime Database, Functions und die Hosting-Funktion aus, die Firebase Hosting umfasst.

? 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 die Echtzeitdatenbank, 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 Starterprojekts verwenden, wählen Sie die Standarddatei für die Sicherheitsregeln aus und achten Sie darauf, die vorhandene Datenbankregelndatei nicht zu ü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

Verwenden Sie beim Konfigurieren Ihrer Funktionen die Standarddateien und achten Sie darauf, die vorhandenen Dateien index.js und package.json im Projektbeispiel nicht zu ü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 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 das Verzeichnis public im Projektcode verwendet wird, und verwenden Sie die vorhandene Datei index.html. 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. Rufen Sie über die Benutzeroberfläche den Ordner ../functions im Projekt auf, wählen Sie die ausgeblendete Datei .eslintrc.js aus und löschen Sie sie. Nicht mit dem ähnlich benannten .eslintrc.json verwechseln.
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 die Datei in washer-start.

Im Verzeichnis washer-start:

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

In Firebase bereitstellen

Nachdem Sie die Abhängigkeiten installiert und Ihr Projekt konfiguriert haben, können Sie die App 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 und mehrere Cloud Functions for Firebase bereitgestellt.

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

Diese Web-UI ist eine Drittanbieterplattform, mit der sich Gerätestatus ansehen oder ändern lassen. Klicken Sie auf AKTUALISIEREN, um Ihre Datenbank mit Geräteinformationen zu füllen. Auf der Seite werden keine Änderungen angezeigt, aber der aktuelle Status Ihrer Waschmaschine wird in der Datenbank gespeichert.

Jetzt ist es an der Zeit, den von Ihnen bereitgestellten Cloud-Dienst über die Developer Console mit Google Assistant zu verbinden.

Developer Console-Projekt konfigurieren

Geben Sie auf dem Tab Entwickeln einen Anzeigenamen für die Interaktion ein. Dieser Name wird in der Google Home App angezeigt.

Laden Sie unter App-Branding eine png-Datei für das App-Symbol mit einer Größe von 144 × 144 Pixeln und dem Namen .png hoch.

So aktivieren Sie die Kontoverknüpfung:

Geben Sie unter Cloud-Ausführungs-URL die URL Ihrer Cloud-Funktion ein, die die Smart-Home-Intents ausführt.

https://us-central1--cloudfunctions.net/smarthome

Klicken Sie auf Speichern, um die Projektkonfiguration zu speichern, und dann auf Weiter: Test, um Tests für Ihr Projekt zu aktivieren.

Jetzt können Sie mit der Implementierung der Webhooks beginnen, die erforderlich sind, um den Gerätestatus mit Assistant zu verknüpfen.

Verknüpfung mit Google Assistant

Wenn Sie Ihre Cloud-zu-Cloud-Integration testen möchten, müssen Sie Ihr Projekt mit einem Google-Konto verknüpfen. So können Sie über Google Assistant-Oberflächen und die Google Home App testen, die im selben Konto angemeldet sind.

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

Öffnen Sie die Google Home App und prüfen Sie, ob Ihre Waschmaschine angezeigt wird.

Prüfen Sie, ob Sie die Waschmaschine in der Google Home App per Sprachbefehl steuern können. Außerdem sollte sich der Gerätestatus in der Web-Benutzeroberfläche der Cloud-Ausführung ändern.

Jetzt können Sie Ihrer Integration die lokale Abwicklung hinzufügen.

4. Cloud-Ausführung aktualisieren

Zur Unterstützung der lokalen Auftragsausführung müssen Sie der Cloud-Antwort SYNC ein neues gerätespezifisches Feld namens otherDeviceIds hinzufügen, das eine eindeutige lokale Kennung für das Gerät enthält. In diesem Feld wird auch angegeben, ob das Gerät lokal gesteuert werden kann.

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

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-Benutzeroberfläche auf und klicken Sie in der Symbolleiste auf die Schaltfläche Aktualisieren . Dadurch wird ein Vorgang zum Synchronisieren angefordert, damit Assistant die aktualisierten SYNC-Antwortdaten erhält.

5. Lokale Auftragsausführung konfigurieren

In diesem Abschnitt fügen Sie Ihrer Cloud-zu-Cloud-Integration die erforderlichen Konfigurationsoptionen für die lokale Auftragsausführung hinzu. Während der Entwicklung veröffentlichen Sie die App zur lokalen Auftragsausführung bei Firebase Hosting, wo das Google Home-Gerät darauf zugreifen und sie herunterladen kann.

Klicken Sie in der Google Home Developer Console links auf dem Bildschirm auf Projekt > Cloud-zu-Cloud und wählen Sie dann für die Integration die Option Bearbeiten aus. Scrollen Sie auf der Seite Einrichtung und Konfiguration zu Lokale Auftragsausführung und aktivieren Sie die Einstellung. Geben Sie die folgende URL in jedes 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

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, darunter mDNS, UPnP und UDP-Broadcast. Sie verwenden UDP-Broadcast, um die intelligente Waschmaschine zu finden.

Klicken Sie unter Gerätesuche auf + Scankonfiguration hinzufügen, 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 unten 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 mit dem Typings-Paket des Local Home SDK. Sehen Sie sich das im Startprojekt bereitgestellte Skelett 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 Abwicklung ist die smarthome.App-Klasse. Das Starterprojekt fügt Handler für die Intents IDENTIFY und EXECUTE hinzu 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 Ihren IDENTIFY-Handler aus, wenn das Google Home-Gerät auf Grundlage der in der Developer Console angegebenen Scankonfiguration nicht bestätigte Geräte im lokalen Netzwerk findet.

In der Zwischenzeit ruft die Plattform den identifyHandler mit den resultierenden Scandaten auf, wenn Google ein übereinstimmendes Gerät findet. In Ihrer App erfolgt das Scannen über einen UDP-Broadcast. Die dem IDENTIFY-Handler bereitgestellten Scandaten 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 identifyHandler-Methode den folgenden Code hinzu, um die UDP-Antwort vom lokalen Gerät 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);
}

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

EXECUTE-Handler hinzufügen

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

Die App 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 Ihrer executeHandler-Methode 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

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 index.ts-Quelldatei (TypeScript) kompiliert und der folgende Inhalt wird in das Verzeichnis public/local-home/ kopiert:

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

Testprojekt bereitstellen

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

firebase deploy --only hosting

7. Smarte Waschmaschine starten

Jetzt ist es an der Zeit, die Kommunikation zwischen Ihrer lokalen App zur Auftragsausführung und der intelligenten Waschmaschine zu testen. Das Codelab-Startprojekt enthält eine virtuelle intelligente Waschmaschine, die in Node.js geschrieben wurde 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 Entwicklerkonsole auf die Scankonfiguration für die Gerätesuche angewendet haben. Außerdem müssen Sie dem virtuellen Gerät mitteilen, welche lokale Geräte-ID es melden soll, und die Projekt-ID der Cloud-zu-Cloud-Integration, die für Status melden-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 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ätescript mit den erwarteten Parametern ausgeführt wird:

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

8. TypeScript-Anwendung debuggen

Im folgenden Abschnitt prüfen Sie, ob das Google Home-Gerät die virtuelle intelligente Waschmaschine über das lokale Netzwerk richtig scannen, identifizieren und anweisen kann. Mit den Google Chrome-Entwicklertools können Sie eine Verbindung zum Google Home-Gerät herstellen, die Konsolenprotokolle aufrufen und die TypeScript-App debuggen.

Chrome-Entwicklertools verbinden

So stellen Sie eine Verbindung zwischen dem Debugger und Ihrer lokalen Fulfillment-App her:

1. Achten Sie darauf, dass Sie Ihr Google Home-Gerät mit einem Nutzer verknüpft haben, der berechtigt ist, auf das Developer Console-Projekt zuzugreifen.
2. Starten Sie Ihr Google Home-Gerät neu. Dadurch kann es die URL Ihrer HTML-Datei sowie die Scankonfiguration abrufen, die Sie in der Developer 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 sollte eine Liste der Geräte angezeigt werden. Ihre App-URL sollte unter dem Namen Ihres Google Home-Geräts zu sehen sein.

Inspektor starten

Klicken Sie unter der App-URL auf Prüfen, um die Chrome-Entwicklertools zu öffnen. Wählen Sie den Tab Console aus und prüfen Sie, ob Sie den Inhalt der IDENTIFY-Intent-Nachricht sehen, die von Ihrer TypeScript-App ausgegeben wurde.

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 an das Google Home-Gerät Befehle an Ihr Gerät senden, z. B.:

„Hey Google, schalte meine Waschmaschine ein.“

„Hey Google, starte meine Waschmaschine.“

„Hey Google, schalte meine Waschmaschine aus.“

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

Prüfen Sie, ob Sie bei jedem Befehl den Status der lokalen intelligenten Waschmaschine sehen können.

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

9. Glückwunsch

Glückwunsch! Sie haben das Local Home SDK verwendet, um die lokale Auftragsausführung in eine Cloud-zu-Cloud-Integration einzubinden.

Weitere Informationen

Du kannst Folgendes ausprobieren:

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