Włączanie lokalnego przetwarzania w przypadku integracji między chmurami

1. Zanim zaczniesz

Integracja z inteligentnym domem umożliwia Asystentowi Google sterowanie połączonymi urządzeniami w domach użytkowników. Aby stworzyć integrację między chmurami, musisz podać punkt końcowy webhooka w chmurze, który może obsługiwać intencje inteligentnego domu. Gdy na przykład użytkownik powie „OK Google, włącz światła”, Asystent wysyła polecenie do przetwarzania w chmurze, aby zaktualizować stan urządzenia.

Pakiet SDK Local Home zwiększa niezawodność integracji inteligentnego domu, dodając lokalną ścieżkę, po której intencje inteligentnego domu są kierowane bezpośrednio do urządzenia Google Home. Dzięki temu zwiększa się niezawodność i zmniejsza opóźnienie w przetwarzaniu poleceń użytkowników. Umożliwia ona pisanie i wdrażanie aplikacji do lokalnego przetwarzania w języku TypeScript lub JavaScript, która identyfikuje urządzenia i wykonuje polecenia na dowolnym głośniku Google Home lub inteligentnym ekranie Google Nest. Aplikacja komunikuje się bezpośrednio z dotychczasowymi inteligentnymi urządzeniami użytkowników przez sieć lokalną, używając do wykonywania poleceń istniejących standardowych protokołów.

Wymagania wstępne

• Tworzenie integracji między chmurami – przewodnik dla deweloperów
• Ćwiczenie z programowania Inteligentna pralka
• Przewodnik dla programistów dotyczący realizowania zamówień lokalnie

Co utworzysz

W tym laboratorium programistycznym wdrożysz wcześniej utworzoną integrację inteligentnego domu z Firebase, a potem zastosujesz konfigurację skanowania w Konsoli programisty. Następnie utworzysz lokalną aplikację w języku TypeScript, która będzie wysyłać polecenia zapisane w Node.js do wirtualnego urządzenia pralniczego.

Czego się nauczysz

• Jak włączyć i skonfigurować realizację lokalną w Developer Console.
• Jak za pomocą pakietu Local Home SDK napisać aplikację do realizacji lokalnie.
• Jak debugować lokalną aplikację obsługiwaną na głośniku Google Home lub ekranie Google Nest.

Czego potrzebujesz

• Najnowsza wersja Google Chrome
• urządzenie z iOS lub Androidem z aplikacją Google Home,
• inteligentny głośnik Google Home lub inteligentny ekran Google Nest;
• Node.js w wersji 10.16 lub nowszej
• konto Google,
• konto rozliczeniowe Google Cloud;

2. Pierwsze kroki

Włączanie Zarządzania aktywnością

Aby korzystać z Asystenta Google, musisz udostępnić Google określone dane o aktywności. Asystent Google potrzebuje tych danych do prawidłowego działania, ale udostępnianie danych nie jest wymagane w przypadku pakietu SDK. Aby udostępniać te dane, utwórz konto Google (jeśli jeszcze go nie masz). Możesz użyć dowolnego konta Google – nie musi to być Twoje konto dewelopera.

Otwórz stronę Zarządzanie aktywnością na koncie Google, którego chcesz używać z Asystentem.

Upewnij się, że te przełączniki są włączone:

• Aktywność w internecie i aplikacjach – pamiętaj też, aby zaznaczyć pole wyboru Uwzględnij historię Chrome i aktywność na stronach, urządzeniach i w aplikacjach, które używają usług Google.
• Informacje o urządzeniu
• Aktywność związana z głosem i dźwiękiem

Tworzenie projektu integracji między chmurami

1. Otwórz konsolę dewelopera.
2. Kliknij Utwórz projekt, wpisz nazwę projektu i kliknij Utwórz projekt.

Wybierz integrację chmur

W sekcji Cloud-to-cloud (Między chmurami) na stronie Project Home (Strona projektu) w Konsoli programisty kliknij Add cloud-to-cloud integration (Dodaj integrację między chmurami).

Zainstaluj wiersz poleceń Firebase

Interfejs wiersza poleceń Firebase (CLI) umożliwia obsługę aplikacji internetowych lokalnie i wdrażanie ich do hostingu Firebase.

Aby zainstalować interfejs wiersza poleceń, uruchom w terminalu to polecenie npm:

npm install -g firebase-tools

Aby sprawdzić, czy interfejs wiersza poleceń został prawidłowo zainstalowany, uruchom:

firebase --version

Autoryzuj wiersz poleceń Firebase za pomocą swojego konta Google, wykonując:

firebase login

Włącz interfejs HomeGraph API

Interfejs HomeGraph API umożliwia przechowywanie urządzeń i ich stanów oraz wysyłanie zapytań o te dane w ramach Home Graph użytkownika. Aby korzystać z tego interfejsu API, musisz najpierw otworzyć konsolę Google Cloud i włączyć interfejs HomeGraph API.

W konsoli Google Cloud wybierz projekt, który odpowiada Twojej integracji. <project-id>.Następnie na ekranie Biblioteka interfejsów API dla interfejsu HomeGraph API kliknij Włącz.

3. Uruchamianie aplikacji startowej

Gdy już skonfigurujesz środowisko programistyczne, możesz wdrożyć projekt startowy, aby sprawdzić, czy wszystko jest prawidłowo skonfigurowane.

Pobieranie kodu źródłowego

Aby pobrać na maszynę programistyczną przykładowy projekt tego ćwiczenia, kliknij ten link:

file_downloadPobierz kod źródłowy

...lub możesz sklonować repozytorium GitHub z poziomu wiersza poleceń:

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

Informacje o projekcie

Projekt startowy zawiera te katalogi podrzędne:

• public – interfejs internetowy do sterowania pralką i monitorowania jej pracy
• functions—funkcje w Cloud Functions, które implementują realizację w chmurze w przypadku integracji między chmurami
• local – szkielet projektu aplikacji do realizacji lokalnie z zaimplementowanymi obsługiwaczami intencji index.ts

Udostępnione rozwiązanie w chmurze obejmuje te funkcje w usłudze index.js:

• fakeauth – punkt końcowy autoryzacji do łączenia kont
• faketoken – punkt końcowy tokena do łączenia kont
• smarthome – punkt końcowy realizacji intencji inteligentnego domu
• reportstate— wywołuje interfejs HomeGraph API po zmianie stanu urządzenia
• updateDevice – punkt końcowy używany przez urządzenie wirtualne do wywołania stanu raportu.

Połącz się z Firebase

Przejdź do katalogu app-start, a potem skonfiguruj interfejs wiersza poleceń Firebase w ramach projektu integracji między chmurami:

cd app-start
firebase use <project-id>

Skonfiguruj projekt Firebase

Inicjalizacja projektu Firebase.

firebase init

Wybierz funkcje wiersza poleceń, Baza danych czasu rzeczywistego, Funkcje i funkcję Hosting, która obejmuje Hosting Firebase.

? 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

Spowoduje to zainicjowanie niezbędnych interfejsów API i funkcji w projekcie.

Po wyświetleniu odpowiedniej prośby zainicjuj bazę danych Firebase Realtime Database. Możesz użyć domyślnej lokalizacji dla instancji bazy danych.

? 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

Ponieważ używasz kodu projektu podstawowego, wybierz domyślny plik reguł zabezpieczeń i upewnij się, że nie zastąpisz istniejącego pliku reguł bazy danych.

? 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

Jeśli ponownie inicjujesz projekt, gdy pojawi się pytanie, czy chcesz zainicjować lub zastąpić bazę kodu, wybierz Zastąp.

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

Podczas konfigurowania funkcji użyj plików domyślnych i upewnij się, że nie zastąpisz istniejących plików index.js i package.json w próbnym projekcie.

? 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

Jeśli ponownie inicjujesz projekt, gdy pojawi się pytanie, czy chcesz zainicjować lub zastąpić pliki functions/.gitignore, wybierz Nie.

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

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

Na koniec skonfiguruj ustawienia hostingu, aby używać katalogu public w kodzie projektu, i użyj istniejącego pliku index.html. Gdy pojawi się pytanie o używanie ESLint, wybierz Nie.

? 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

Jeśli ESLint zostało przypadkowo włączone, możesz je wyłączyć na 2 sposoby:

1. Za pomocą interfejsu graficznego przejdź do folderu ../functions w ramach projektu, wybierz ukryty plik .eslintrc.js i usuń go. Nie myl go z elementem o podobnej nazwie .eslintrc.json.
2. W wierszu poleceń:

   cd functions
   rm .eslintrc.js
   

Aby mieć pewność, że konfiguracja Firebase jest prawidłowa i pełna, skopiuj plik firebase.json z katalogu washer-done do katalogu washer-start, zastępując ten w katalogu washer-start.

W katalogu washer-start:

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

Wdrażanie w Firebase

Po zainstalowaniu zależności i skonfigurowaniu projektu możesz uruchomić aplikację po raz pierwszy.

firebase deploy

Dane wyjściowe konsoli powinny wyglądać tak:

...

✔ Deploy complete!

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

To polecenie wdraża aplikację internetową wraz z kilkoma funkcjami Cloud Functions dla Firebase.

Aby wyświetlić aplikację internetową, otwórz w przeglądarce (https://<project-id>.web.app) adres URL hostingu. Zobaczysz ten interfejs:

Ten interfejs internetowy reprezentuje platformę innej firmy, która umożliwia wyświetlanie i modyfikowanie stanów urządzenia. Aby rozpocząć wypełnianie bazy danych informacjami o urządzeniach, kliknij Zaktualizuj. Nie zobaczysz żadnych zmian na stronie, ale bieżący stan pralki zostanie zapisany w bazie danych.

Teraz musisz połączyć wdrożony przez siebie serwis w chmurze z Asystentem Google za pomocą Konsoli dla deweloperów.

Konfigurowanie projektu w Konsoli deweloperów

Na karcie Tworzenie dodaj Wyświetlaną nazwę interakcji. Ta nazwa będzie widoczna w aplikacji Google Home.

W sekcji Marka aplikacji prześlij plik png ikony aplikacji o rozmiarze 144 × 144 pikseli i nazwie .png.

Aby włączyć łączenie kont, użyj tych ustawień:

W sekcji URL realizacji w chmurze wpisz adres URL funkcji w chmurze, która zapewnia realizację intencji związanych z inteligentnym domem.

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

Aby zapisać konfigurację projektu, kliknij Zapisz, a potem kliknij Dalej: testowanie, aby włączyć testowanie projektu.

Teraz możesz zacząć wdrażać webhooki niezbędne do połączenia stanu urządzenia z Asystentem.

Łączenie z Asystentem Google

Aby przetestować integrację między chmurami, musisz połączyć projekt z kontem Google. Umożliwia to testowanie w interfejsach Asystenta Google i aplikacji Google Home, w których użytkownik jest zalogowany na to samo konto.

1. Na telefonie otwórz ustawienia Asystenta Google. Pamiętaj, że musisz zalogować się na to samo konto, którego używasz w konsoli.
2. Kliknij Asystent Google > Ustawienia > Sterowanie domem (w sekcji Asystent).
3. W prawym górnym rogu kliknij ikonę wyszukiwania.
4. Aby znaleźć konkretną aplikację testową, wyszukaj ją, używając prefiksu [test].
5. Wybierz ten element. Asystent Google uwierzytelnia się w Twojej usłudze i wysyła żądanie SYNC, aby Twoja usługa podała listę urządzeń użytkownika.

Otwórz aplikację Google Home i sprawdź, czy widzisz swoją pralkę.

Sprawdź, czy możesz sterować pralką za pomocą poleceń głosowych w aplikacji Google Home. Powinieneś też zobaczyć zmianę stanu urządzenia w interfejsie internetowym usługi w chmurze.

Teraz możesz zacząć dodawać do integracji realizację lokalną.

4. Aktualizowanie usługi w chmurze

Aby obsługiwać realizację lokalną, musisz dodać do odpowiedzi SYNC w chmurze nowe pole na urządzenie o nazwie otherDeviceIds, które zawiera unikalny identyfikator lokalny urządzenia. To pole wskazuje również możliwość sterowania tym urządzeniem lokalnie.

Dodaj pole otherDeviceIds do odpowiedzi SYNC, jak pokazano w tym fragmencie kodu:

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',
        }],
      }],
    },
  };
});

Wprowadź zaktualizowany projekt do Firebase:

firebase deploy --only functions

Po zakończeniu wdrażania przejdź do interfejsu internetowego i na pasku narzędzi kliknij przycisk Odśwież . Spowoduje to uruchomienie operacji synchronizacji żądania, dzięki której Asystent otrzyma zaktualizowane dane odpowiedzi SYNC.

5. Konfigurowanie lokalnego przetwarzania

W tej sekcji dodasz do integracji między chmurami opcje konfiguracji niezbędne do realizacji lokalnej. Podczas tworzenia opublikujesz aplikację do obsługi lokalnej w Hostingu Firebase, gdzie będzie ona dostępna dla urządzenia Google Home i można ją pobrać.

W Konsoli dewelopera wybierz Rozwijaj > Działania i znajdź sekcję Skonfiguruj lokalny SDK domowy. W polu adresu URL testowego wpisz ten adres URL, wstaw identyfikator projektu i kliknij Zapisz:

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

Następnie musimy określić, jak urządzenie Google Home ma wykrywa lokalne urządzenia inteligentne. Platforma Local Home obsługuje kilka protokołów wykrywania urządzeń, w tym mDNS, UPnP i transmisję UDP. Użyjesz transmisji UDP, aby wykryć inteligentną pralkę.

Aby dodać nową konfigurację skanowania, w sekcji Konfiguracja skanowania urządzenia kliknij Nowa konfiguracja skanowania. Jako protokół wybierz UDP i uzupełnij te atrybuty:

Aby opublikować zmiany, u góry okna kliknij Zapisz.

6. Implementacja lokalnej realizacji zamówień

Aplikację do realizacji lokalnie będziesz tworzyć w języku TypeScript za pomocą typów w pakiecie Local Home SDK. Zapoznaj się ze szkieletem udostępnionym w projekcie startowym:

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));

Głównym elementem lokalnego przetwarzania jest klasa smarthome.App. Projekt startowy dołącza procedury obsługi dla intencji IDENTIFY i EXECUTE, a następnie wywołuje metodę listen(), aby poinformować pakiet SDK Local Home, że aplikacja jest gotowa.

Dodaj moduł obsługi IDENTIFY

Pakiet SDK Local Home uruchamia element obsługi IDENTIFY, gdy urządzenie Google Home wykryje w sieci lokalnej niezweryfikowane urządzenia na podstawie konfiguracji skanowania podanej w Konsoli dla deweloperów.

Gdy Google wykryje pasujące urządzenie, platforma wywołuje identifyHandler z uzyskanymi danymi skanowania. W aplikacji skanowanie odbywa się za pomocą transmisji UDP, a dane skanowania przekazane do obsługi interfejsu IDENTIFY obejmują ładunek odpowiedzi wysłany przez urządzenie lokalne.

Obsługa zwraca instancję IdentifyResponse zawierającą unikalny identyfikator lokalnego urządzenia. Dodaj do metody identifyHandler ten kod, aby przetworzyć odpowiedź UDP z urządzenia lokalnego i określić odpowiedni identyfikator urządzenia lokalnego:

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

Pamiętaj, że pole verificationId musi być zgodne z jedną z wartości otherDeviceIds w odpowiedzi SYNC, która oznacza urządzenie jako dostępne do realizacji lokalnie w grafu domowym użytkownika. Gdy Google znajdzie dopasowanie, urządzenie zostanie uznane za zweryfikowane i gotowe do realizacji lokalnie.

Dodawanie modułu obsługi EXECUTE

Gdy urządzenie obsługujące lokalną realizację otrzyma polecenie, Local Home SDK uruchamia element obsługi EXECUTE. Treść lokalnego zamiaru jest odpowiednikiem zamiaru EXECUTE wysłanego do realizacji w chmurze, więc logika przetwarzania zamiaru lokalnie jest podobna do tej stosowanej w chmurze.

Aplikacja może używać gniazd TCP/UDP lub żądań HTTP(S) do komunikacji z urządzeniami lokalnymi. W tym ćwiczeniu kodowania protokół HTTP służy do sterowania urządzeniem wirtualnym. Numer portu jest zdefiniowany w definicji index.ts jako zmienna SERVER_PORT.

Dodaj do metody executeHandler ten kod, aby przetwarzać przychodzące polecenia i przesyłać je na urządzenie lokalne przez HTTP:

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

Zkompiluj aplikację TypeScript.

Aby pobrać kompilator TypeScript i skompilować aplikację, otwórz katalog local/ i uruchom te polecenia:

cd local
npm install
npm run build

Skompiluje to źródło index.ts (TypeScript) i umieści w katalogu public/local-home/ te pliki:

• bundle.js – skompilowany kod JavaScript zawierający lokalną aplikację i zależne komponenty.
• index.html – strona hostingu lokalnego używana do obsługi aplikacji na potrzeby testowania na urządzeniu.

Wdrażanie testowego projektu

Wdróż zaktualizowane pliki projektu do Hostingu Firebase, aby mieć do nich dostęp z urządzenia Google Home.

firebase deploy --only hosting

7. Uruchomić inteligentną pralkę

Teraz czas przetestować komunikację między aplikacją do obsługi lokalnej a inteligentną pralką. Projekt startowy w Codelab zawiera wirtualną inteligentną pralkę napisaną w Node.js, która symuluje inteligentną pralkę, którą użytkownicy mogą lokalnie kontrolować.

Konfigurowanie urządzenia

Musisz skonfigurować urządzenie wirtualne tak, aby używało tych samych parametrów UDP, które zostały zastosowane do konfiguracji skanowania w celu wykrywania urządzenia w Konsoli programisty. Musisz też podać urządzeniu wirtualnemu, który identyfikator lokalnego urządzenia ma raportować, oraz identyfikator projektu integracji między chmurami, który ma być używany do raportowania zdarzeń stanu w przypadku zmiany stanu urządzenia.

Uruchom urządzenie.

Przejdź do katalogu virtual-device/ i uruchom skrypt urządzenia, przekazując parametry konfiguracji jako argumenty:

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

Sprawdź, czy skrypt urządzenia działa z oczekiwanymi parametrami:

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

8. Debugowanie aplikacji TypeScript

W następnej sekcji sprawdzisz, czy głośnik Google Home może prawidłowo skanować, identyfikować i wysyłać polecenia do wirtualnej inteligentnej pralki przez sieć lokalną. Za pomocą Narzędzi programistycznych w Google Chrome możesz połączyć się z urządzeniem Google Home, wyświetlić dzienniki konsoli i przeprowadzić debugowanie aplikacji TypeScript.

Łączenie z Narzędziami deweloperskimi w Chrome

Aby połączyć debuger z aplikacją do obsługi lokalnej, wykonaj te czynności:

1. Upewnij się, że urządzenie Google Home jest połączone z użytkownikiem, który ma uprawnienia do dostępu do projektu Konsoli programisty.
2. Zrestartuj urządzenie Google Home, aby umożliwić mu pobranie adresu URL pliku HTML oraz konfiguracji skanowania z konsoli dla deweloperów.
3. Uruchom Chrome na komputerze programisty.
4. Otwórz nową kartę w Chrome i w polu adresu wpisz chrome://inspect, aby uruchomić inspekcję.

Na stronie powinna wyświetlić się lista urządzeń, a adres URL aplikacji powinien być widoczny pod nazwą urządzenia Google Home.

Uruchamianie inspektora

Aby otworzyć narzędzia Chrome dla programistów, kliknij Sprawdź pod adresem URL aplikacji. Kliknij kartę Konsola i sprawdź, czy widzisz treść intencji IDENTIFY wydrukowanej przez aplikację TypeScript.

Ten wynik oznacza, że aplikacja do obsługi lokalnego zamówienia wykryła i zidentyfikowała urządzenie wirtualne.

Testowanie lokalnej realizacji zamówień

Wysyłaj polecenia do urządzenia za pomocą elementów sterujących w aplikacji Google Home lub poleceń głosowych do urządzenia Google Home, takich jak:

„OK Google, włącz pralkę”

„OK Google, włącz pralkę”

„OK Google, zatrzymaj pralkę”

Powinna ona spowodować wysłanie przez platformę do Twojej aplikacji TypeScript intencji EXECUTE.

Sprawdź, czy po każdym poleceniu widzisz zmianę stanu lokalnej inteligentnej pralki.

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

9. Gratulacje

Gratulacje! Aby zintegrować lokalną realizację z integracją chmur z chmurą, użyjesz pakietu SDK Local Home.

Więcej informacji

Oto kilka dodatkowych rozwiązań, które możesz wypróbować:

• Zmień konfigurację skanowania i uruchom ją. Możesz na przykład użyć innego portu UDP lub pakietu wyszukiwania.
• Zmodyfikuj kod źródłowy wirtualnego urządzenia inteligentnego, aby działał na urządzeniu wbudowanym, takim jak Raspberry Pi, i użyj diod LED lub wyświetlacza, aby zwizualizować bieżący stan.