1. Hinweis
Durch Smart-Home-Integrationen kann Google Assistant verbundene Geräte im Zuhause von Nutzern steuern. Wenn Sie eine Cloud-zu-Cloud-Integration erstellen möchten, müssen Sie einen Cloud-Webhook-Endpunkt bereitstellen, der Smart-Home-Intents verarbeiten kann. Wenn ein Nutzer beispielsweise „Hey Google, schalte das Licht ein“ sagt, sendet Assistant den Befehl an deine Cloud-Auftragsausführung, um den Status des Geräts zu aktualisieren.
Das Local Home SDK optimiert deine Smart-Home-Integration, indem es einen lokalen Pfad hinzufügt, über den Smart-Home-Intents direkt an ein Google Home-Gerät weitergeleitet werden. Das erhöht die Zuverlässigkeit und verringert die Latenz bei der Verarbeitung von Nutzerbefehlen. Damit kannst du eine lokale Ausführungs-App in TypeScript oder JavaScript schreiben und bereitstellen, die Geräte identifiziert und Befehle auf jedem Google Home-Smart-Speaker oder Google Nest-Smart-Display ausführt. Deine App kommuniziert dann direkt über das Local Area Network mit den vorhandenen Smart-Home-Geräten der Nutzer und verwendet vorhandene Standardprotokolle, um Befehle auszuführen.

Vorbereitung
- Cloud-zu-Cloud-Integration erstellen Entwicklerleitfaden
- Codelab Smart-Home-Waschmaschine
- Entwicklerhandbuch für die lokale Ausführung
Aufgaben
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 eine lokale App mit TypeScript, um in Node.js geschriebene Befehle an eine virtuelle Waschmaschine zu senden.
Lerninhalte
- Lokale Ausführung in der Entwicklerkonsole aktivieren und konfigurieren
- Anleitung zum Schreiben einer lokalen Ausführungs-App mit dem Local Home SDK
- Informationen zum Debuggen 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
- iOS- oder Android-Gerät mit der Google Home App
- Einen Google Home-Smart Speaker oder ein Google Nest-Smart Display
- Node.js-Version 24 oder höher
- Ein Google-Konto
- Ein Google Cloud-Rechnungskonto
- Blaze-Tarif (Pay as you go) für Firebase.
2. Erste Schritte
Aktivitätseinstellungen aktivieren
Damit du Google Assistant verwenden kannst, musst du bestimmte Aktivitätsdaten mit Google teilen. Google Assistant benötigt diese Daten, um richtig zu funktionieren. Die Anforderung, Daten weiterzugeben, ist jedoch nicht spezifisch für das SDK. Wenn du diese Daten teilen möchtest, erstelle ein Google-Konto, falls du noch keines hast. 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 Schalter müssen aktiviert sein:
- Web- & App-Aktivitäten: Setzen Sie außerdem ein Häkchen im 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- & Audioaktivitäten
Cloud-zu-Cloud-Integrationsprojekt erstellen
- Rufen Sie die Entwicklerkonsole auf.
- 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ähle in der Developer Console auf der Projektstartseite unter Cloud-to-Cloud die Option Cloud-to-Cloud-Integration hinzufügen aus.

Firebase CLI installieren
Mit der Firebase-Befehlszeile (CLI) können Sie Ihre Webanwendungen lokal bereitstellen und in Firebase Hosting bereitstellen.
Führen Sie den folgenden npm-Befehl im Terminal aus, um die Befehlszeile zu installieren:
npm install -g firebase-tools
Führen Sie den 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 Folgendes ausführen:
firebase login
HomeGraph API aktivieren
Die HomeGraph API ermöglicht das Speichern und Abfragen 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ählen Sie in der Google Cloud Console das Projekt aus, das der <project-id>. Ihrer Integration entspricht. Klicken Sie dann auf dem Bildschirm „API-Bibliothek“ für die HomeGraph API auf Aktivieren.

3. Starter-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:
…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 Starterprojekt enthält die folgenden Unterverzeichnisse:
public: Frontend-Web-UI zum Steuern und Überwachen der intelligenten Waschmaschinefunctions: Cloud Functions-Funktionen, die die Cloud-Ausführung für die Cloud-zu-Cloud-Integration implementierenlocal– Skeleton-Projekt für eine lokale Auftragsausführungs-App mit Intent-Handlern, die inindex.tseingefügt sind
Die bereitgestellte Cloud-Auftragsausführung enthält die folgenden Funktionen in index.js:
fakeauth: Autorisierungsendpunkt für die Kontoverknüpfungfaketoken: Token-Endpunkt für die Kontoverknüpfungsmarthome: Endpunkt für die Ausführung von Smart-Home-Intentsreportstate: Ruft die HomeGraph API auf, wenn sich der Gerätestatus ändert.updateDevice: Endpunkt, der vom virtuellen Gerät verwendet wird, um den Statusbericht auszulösen
Mit Firebase verknüpfen
Rufen Sie das Verzeichnis app-start auf und richten Sie die Firebase CLI mit Ihrem Cloud-to-Cloud-Integrationsprojekt ein:
cd app-start firebase use <project-id>
Firebase-Projekt konfigurieren
Firebase-Projekt initialisieren
firebase init
Wählen Sie die CLI-Features Realtime Database und Functions aus.
? Which Firebase features do you want to set up for this directory? Press Space to select features, then Enter to confirm your choices. (Press <space> to select, <a> to toggle all, <i> to invert selection, and <enter> to proceed) >( ) Data Connect: Set up a Firebase Data Connect service ( ) Firestore: Configure security rules and indexes files for Firestore ( ) Genkit: Setup a new Genkit project with Firebase (*) Functions: Configure a Cloud Functions directory and its files ( ) App Hosting: Configure an apphosting.yaml file for App Hosting ( ) Hosting: Configure files for Firebase Hosting and (optionally) 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 (*) Realtime Database: Configure a security rules file for Realtime Database and (optionally) provision default instance ( ) Data Connect: Set up a Firebase Data Connect service ( ) Firestore: Configure security rules and indexes files for Firestore
Dadurch werden die erforderlichen APIs und Funktionen für Ihr Projekt initialisiert.
Initialisieren Sie die 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 Starterprojekts 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
Verwenden Sie beim Konfigurieren Ihrer 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 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
Wenn ESLint versehentlich aktiviert wurde, gibt es zwei Möglichkeiten, es zu deaktivieren:
- Rufen Sie in der GUI den Ordner
../functionsim Projekt auf, wählen Sie die versteckte Datei.eslintrc.jsaus und löschen Sie sie. Verwechseln Sie es nicht mit dem ähnlich benannten.eslintrc.json. - Ü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 Web-App aufzurufen. Sie sehen die folgende Oberfläche:

Diese Web-UI stellt eine Drittanbieterplattform dar, auf der Gerätestatus angezeigt oder geändert werden können. Klicken Sie auf AKTUALISIEREN, um die Datenbank mit Geräteinformationen zu füllen. Auf der Seite werden keine Änderungen angezeigt, aber der aktuelle Status der 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
Fügen Sie auf dem Tab Entwickeln einen Anzeigenamen für Ihre Interaktion hinzu. 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 Pixel und dem Namen hoch.

Verwenden Sie die folgenden Einstellungen für die Kontoverknüpfung, um sie zu aktivieren:
Client-ID |
|
Client-Secret |
|
Autorisierungs-URL |
|
Token-URL |
|

Geben Sie unter Cloud-Ausführungs-URL die URL für Ihre Cloud Functions-Funktion ein, die die Ausführung für die Smart-Home-Intents bereitstellt.
https://us-central1-<project-id>.cloudfunctions.net/smarthome

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

Jetzt kannst du die Webhooks implementieren, die erforderlich sind, um den Gerätestatus mit Assistant zu verbinden.
Mit Google Assistant verknüpfen
Wenn du deine Cloud-to-Cloud-Integration testen möchtest, musst du dein Projekt mit einem Google-Konto verknüpfen. So können Sie Tests über Google Assistant-Oberflächen und die Google Home App durchführen, die im selben Konto angemeldet sind.
- Öffnen Sie auf Ihrem Smartphone die Google Assistant-Einstellungen. Sie müssen mit demselben Konto angemeldet sein wie in der Console.
- Gehe zu Google Assistant > Einstellungen > Smart-Home-Steuerung (unter „Assistant“).
- Klicken Sie oben rechts auf das Suchsymbol.
- Suchen Sie nach Ihrer Test-App, indem Sie das Präfix [test] verwenden.
- Wählen Sie das Element aus. Google Assistant authentifiziert sich dann bei deinem Dienst und sendet eine
SYNC-Anfrage, in der dein Dienst aufgefordert wird, eine Liste der Geräte für den Nutzer bereitzustellen.
Öffne die Google Home App und prüfe, ob deine Waschmaschine angezeigt wird.

Prüfe, ob du die Waschmaschine in der Google Home App per Sprachbefehl steuern kannst. Du solltest auch sehen, dass sich der Gerätestatus in der Frontend-Web-UI deiner Cloud-Auftragsausführung ändert.
Jetzt kannst du mit dem Hinzufügen der lokalen Ausführung zu deiner Integration beginnen.
4. Cloud-Ausführung aktualisieren
Damit die lokale Ausführung unterstützt wird, musst du 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 an, ob das Gerät lokal gesteuert werden kann.
Fügen Sie das Feld otherDeviceIds der Antwort SYNC 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 den Button Aktualisieren
. Dadurch wird ein Request Sync-Vorgang ausgelöst, damit Assistant die aktualisierten SYNC-Antwortdaten erhält.

5. Lokale Ausführung konfigurieren
In diesem Abschnitt fügen Sie Ihrer Cloud-zu-Cloud-Integration die erforderlichen Konfigurationsoptionen für die lokale Ausführung hinzu. Während der Entwicklung veröffentlichst du die lokale Ausführungs-App in Firebase Hosting, wo das Google Home-Gerät darauf zugreifen und sie herunterladen kann.
Rufe in der Google Home Developer Console links auf dem Bildschirm Projekt > Cloud-to-Cloud auf und wähle dann für die Integration Bearbeiten aus. Scrolle auf der Seite Einrichtung und Konfiguration zu Lokale Ausführung und aktiviere die Einstellung. Geben Sie die folgende URL in jedes Test-URL-Feld 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. Du verwendest UDP-Broadcast, um die intelligente Waschmaschine zu finden.
Klicken Sie unter Geräteerkennung auf + Scankonfiguration hinzufügen, um eine neue Scankonfiguration hinzuzufügen. Wählen Sie UDP als Protokoll aus und geben Sie die folgenden Attribute an:
Feld | Beschreibung | Vorgeschlagener Wert |
Adresse zur Geräteerkennung | UDP-Adresse zur Geräteerkennung |
|
Übertragender Port | Port, an den Google Home den UDP-Broadcast sendet |
|
Lauschport | Port, an dem Google Home auf eine Antwort wartet |
|
Paket zur Geräteerkennung | UDP-Broadcast-Datennutzlast |
|

Klicken Sie abschließend unten im Fenster auf Speichern, um die Änderungen zu veröffentlichen.
6. Lokale Ausführung implementieren
Sie entwickeln Ihre lokale Ausführungs-App in TypeScript mit dem Typings-Paket des Local Home SDK. Sehen Sie sich das im Starterprojekt 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 Ausführung ist die Klasse smarthome.App. Das Starterprojekt 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 nicht verifizierte Geräte im lokalen Netzwerk findet. Dies geschieht auf Grundlage der in der Developer Console angegebenen Scan-Konfiguration.
In der Zwischenzeit ruft die Plattform die identifyHandler mit den resultierenden Scandaten auf, wenn Google Discover ein passendes Gerät findet. In deiner App wird der Scan über einen UDP-Broadcast durchgeführt. Die Scandaten, die an den IDENTIFY-Handler übergeben werden, enthalten die Antwortnutzlast, die vom lokalen Gerät gesendet wurde.
Der Handler gibt eine IdentifyResponse-Instanz mit einer eindeutigen Kennung für das lokale Gerät zurück. Fügen Sie Ihrer 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 deiner SYNC-Antwort übereinstimmen, wodurch das Gerät im Home Graph des Nutzers als für die lokale Ausführung verfügbar gekennzeichnet wird. Sobald Google eine Übereinstimmung findet, gilt das Gerät als verifiziert und ist für die lokale Auftragsausführung bereit.
EXECUTE-Handler hinzufügen
Das Local Home SDK löst den 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 Intent EXECUTE, der an Ihre Cloud-Auftragsausführung gesendet wird. Die Logik für die lokale Verarbeitung des Intents ähnelt also 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 wird in index.ts als Variable SERVER_PORT definiert.
Füge 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-Anwendung kompilieren
Wechseln Sie zum Verzeichnis local/ und führen Sie die folgenden Befehle aus, um den TypeScript-Compiler herunterzuladen und die Anwendung zu kompilieren:
cd local npm install npm run build
Dadurch wird die index.ts-Quelle (TypeScript) kompiliert und der folgende Inhalt im Verzeichnis public/local-home/ abgelegt:
bundle.js: Kompilierte JavaScript-Ausgabe, die die lokale App und Abhängigkeiten enthält.index.html: Lokale Hostingseite, auf der die App für Tests auf dem Gerät bereitgestellt wird.
Testprojekt bereitstellen
Stelle die aktualisierten Projektdateien in Firebase Hosting bereit, damit du über das Google Home-Gerät darauf zugreifen kannst.
firebase deploy --only hosting
7. Starte die intelligente Waschmaschine
Jetzt ist es an der Zeit, die Kommunikation zwischen deiner lokalen Ausführungs-App und der intelligenten Waschmaschine zu testen. Das Startprojekt des Codelabs enthält eine virtuelle intelligente Waschmaschine, die in Node.js geschrieben ist und eine intelligente Waschmaschine simuliert, die Nutzer lokal steuern können.
Gerät konfigurieren
Du musst das virtuelle Gerät so konfigurieren, dass es dieselben UDP-Parameter verwendet, die du in der Developer Console auf die Scankonfiguration für die Geräteerkennung angewendet hast. Außerdem musst du dem virtuellen Gerät mitteilen, welche lokale Geräte-ID gemeldet werden soll und welche Projekt-ID der Cloud-to-Cloud-Integration für Report State-Ereignisse verwendet werden soll, wenn sich der Gerätestatus ändert.
Parameter | Vorgeschlagener Wert |
deviceId |
|
discoveryPortOut |
|
discoveryPacket |
|
projectId | Die Projekt-ID Ihrer Cloud-zu-Cloud-Integration |
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. TypeScript-Anwendung debuggen
Im folgenden Abschnitt prüfst du, ob das Google Home-Gerät die virtuelle intelligente Waschmaschine über das lokale Netzwerk scannen, identifizieren und Befehle an sie senden kann. Du kannst die Google Chrome-Entwicklertools verwenden, um eine Verbindung zum Google Home-Gerät herzustellen, die Konsolenprotokolle aufzurufen und die TypeScript-App zu debuggen.
Chrome-Entwicklertools verbinden
So verbindest du den Debugger mit deiner lokalen Auftragsausführungs-App:
- Achte darauf, dass du dein Google Home-Gerät mit einem Nutzer verknüpft hast, der Zugriff auf das Developer Console-Projekt hat.
- Starte dein Google Home-Gerät neu, damit es die URL deines HTML-Codes und die in der Developer Console festgelegte Scankonfiguration abrufen kann.
- Starten Sie Chrome auf Ihrer Entwicklungsmaschine.
- Öffnen Sie einen neuen Chrome-Tab und geben Sie
chrome://inspectin die Adressleiste ein, um den Inspector zu starten.
Auf der Seite sollte eine Liste mit Geräten angezeigt werden und die App-URL sollte unter dem Namen deines Google Home-Geräts zu sehen sein.

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

Diese Ausgabe bedeutet, dass Ihre lokale Auftragsausführungs-App das virtuelle Gerät erfolgreich erkannt und identifiziert hat.
Lokale Ausführung testen
Du kannst Befehle ü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 die Waschmaschine.“
„Hey Google, halte meine Waschmaschine an.“
Dadurch sollte die Plattform einen EXECUTE-Intent an Ihre TypeScript-Anwendung senden.

Prüfe, ob sich der Status der lokalen intelligenten Waschmaschine mit jedem Befehl ändert.
... ***** The washer is RUNNING ***** ... ***** The washer is STOPPED *****
9. Glückwunsch

Glückwunsch! Du hast das Local Home SDK verwendet, um die lokale Ausführung in eine Cloud-zu-Cloud-Integration einzubinden.
Weitere Informationen
Hier sind ein paar weitere Dinge, die du ausprobieren kannst:
- Ändern Sie die Scankonfiguration, damit sie funktioniert. Versuchen Sie es beispielsweise mit einem anderen UDP-Port oder einem anderen Erkennungspaket.
- Ändere die Codebasis des virtuellen Smart-Home-Geräts so, dass sie auf einem eingebetteten Gerät wie einem Raspberry Pi ausgeführt werden kann, und verwende LEDs oder ein Display, um den aktuellen Status zu visualisieren.