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.
Voraussetzungen
- Entwicklerleitfaden für Smart-Home-Aktionen 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 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
- Die aktuelle Version von Google Chrome
- Ein iOS- oder Android-Gerät mit der Google Home App
- Intelligenter Lautsprecher von Google Home oder 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
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
- Rufen Sie die Actions on Google Developer Console auf.
- Klicken Sie auf Neues Projekt, geben Sie einen Namen für das Projekt ein und klicken Sie auf PROJEKT ERSTELLEN.
Die Smart-Home App auswählen
Wählen Sie in der Actions Console auf dem Übersichtsbildschirm die Option Smart Home aus.
Wähle die Karte Smart Home aus. Du wirst dann zur Projektkonsole weitergeleitet.
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.
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 Waschmaschinefunctions
: Cloud Functions zur Implementierung der Cloud-Auftragsausführung für die Smart-Home-Aktionlocal
: Skeleton-Projekt zur lokalen Auftragsausführung mit Intent-Handlern inindex.ts
Die bereitgestellte Cloud-Auftragsausführung umfasst die folgenden Funktionen in index.js
:
fakeauth
: Autorisierungsendpunkt für die Kontoverknüpfungfaketoken
: Tokenendpunkt für die Kontoverknüpfungsmarthome
: Endpunkt für die Smart-Home-Intent-Auftragsausführungreportstate
: Ruft die HomeGraph API bei Änderungen des Gerätestatus aufupdateDevice
: 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:
- 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. - Ü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:
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
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.
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 |
|
Clientschlüssel |
|
Autorisierungs-URL |
|
Token-URL |
|
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.
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“ ().
Mit Google Assistant verknüpfen
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.
- Öffnen Sie auf Ihrem Smartphone die Google Assistant-Einstellungen. Sie sollten mit demselben Konto angemeldet sein wie in der Konsole.
- Gehen Sie zu Google Assistant > Einstellungen > Smart-Home-Steuerung (unter „Assistant“).
- Klicken Sie rechts oben auf das Suchsymbol.
- Sie können mithilfe des Präfixes [test] nach Ihrer Test-App suchen.
- 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.
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 . Dadurch wird eine Synchronisierungsanfrage ausgelöst, damit Assistant die aktualisierten SYNC
-Antwortdaten erhält.
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
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 |
|
Broadcast-Port | Port, an den Google Home die UDP-Nachricht sendet |
|
Listener-Port | Port, an dem Google Home auf eine Antwort wartet |
|
Discovery-Paket | UDP-Broadcast-Datennutzlast |
|
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ängigkeitenindex.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 |
|
discoveryPortOut |
|
discoveryPacket |
|
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:
- 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.
- 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.
- Starten Sie Chrome auf Ihrem Entwicklungscomputer.
- Ö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.
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.
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.
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
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.