Implementa la app de entrega local

Para admitir la entrega local, debes compilar una app que controle estas Intents de casa inteligente:

• IDENTIFY: Admite el descubrimiento de dispositivos inteligentes que se pueden controlar de forma local. El el controlador de intents extrae los datos que muestra tu dispositivo inteligente durante la detección. y lo envía en respuesta a Google.
• EXECUTE: Admite la ejecución de comandos.
• QUERY: Admite consultar el estado del dispositivo.
• REACHABLE_DEVICES: Admite el descubrimiento de elementos que se pueden controlar de forma local (opcional). detrás de un dispositivo concentrador (o puente).

Esta app se ejecuta en los dispositivos Google Home o Google Nest de los usuarios y conecta tu dispositivo inteligente a los siguientes dispositivos: Asistente Puedes crear la app con TypeScript (opción preferida) o JavaScript.

Se recomienda usar TypeScript porque puedes aprovechar vinculaciones para asegurarte de que los datos que muestra tu app coincidan con los tipos que espera la plataforma.

Para obtener más información sobre la API, consulta la Referencia de la API del SDK de Local Home

En los siguientes fragmentos, se muestra cómo puedes inicializar la app de entrega local y adjuntar los controladores.

import App = smarthome.App;
const localHomeApp: App = new App("1.0.0");
localHomeApp
  .onIdentify(identifyHandler)
  .onExecute(executeHandler)
  .listen()
  .then(() => {
    console.log("Ready");
  });

import App = smarthome.App;
const localHomeApp: App = new App("1.0.0");
localHomeApp
  .onIdentify(identifyHandler)
  .onReachableDevices(reachableDevicesHandler)
  .onExecute(executeHandler)
  .listen()
  .then(() => {
    console.log("Ready");
  });

Crea tu proyecto

Para implementar tu app de entrega local, debes compilar un paquete de JavaScript para tu código y todas sus dependencias.

Usa el proyecto de la app de entrega local . inicializador para iniciar la estructura de proyecto adecuada con tu agrupador preferido configuración.

Plantillas de proyectos

Para seleccionar la configuración de tu agrupador, ejecuta el comando npm init como se muestra en el los siguientes ejemplos:

npm init @google/local-home-app project-directory/ --bundler none

project-directory/
├── node_modules/
├── package.json
├── .gitignore
├── index.ts
├── test.ts
├── tsconfig.json
├── tslint.json
└── serve.js

npm init @google/local-home-app project-directory/ --bundler webpack

project-directory/
├── node_modules/
├── package.json
├── .gitignore
├── index.ts
├── test.ts
├── tsconfig.json
├── tslint.json
├── webpack.config.web.js
├── webpack.config.node.js
└── serve.js

npm init @google/local-home-app project-directory/ --bundler rollup

project-directory/
├── node_modules/
├── package.json
├── .gitignore
├── index.ts
├── test.ts
├── tsconfig.json
├── tslint.json
├── rollup.config.js
└── serve.js

npm init @google/local-home-app project-directory/ --bundler parcel

project-directory/
├── node_modules/
├── package.json
├── .gitignore
├── index.ts
├── test.ts
├── tsconfig.json
├── tslint.json
└── serve.js

Realizar tareas comunes a nivel de proyecto

El proyecto generado es compatible con el siguiente comando npm secuencia de comandos:

cd project-directory/
npm run build

cd project-directory/
npm run lint
npm run compile
npm test

cd project-directory/
npm run start

Implementa el controlador IDENTIFY

El controlador IDENTIFY se activará cuando el dispositivo Google Home o Google Nest se reinicie y ve dispositivos locales no verificados (incluidos los dispositivos finales conectados a una unidad central). El La plataforma de Local Home buscará dispositivos locales con la información de configuración de análisis que especificaste anteriormente y llama a tu controlador IDENTIFY con los resultados del análisis.

El IdentifyRequest de la plataforma de Local Home contiene los datos de análisis de una LocalIdentifiedDevice instancia. Solo se propaga una instancia de device, según la configuración del análisis que descubrieron el dispositivo.

Si los resultados del análisis coinciden con tu dispositivo, tu controlador IDENTIFY debe mostrar un IdentifyResponsePayload que incluye un objeto device con Metadatos de la casa inteligente (como los tipos, las características y el estado del informe)

Google establece una asociación de dispositivos si el verificationId de la respuesta de IDENTIFY coincide con uno de los Valores otherDeviceIds que muestra la respuesta SYNC.

Ejemplo

Los siguientes fragmentos muestran cómo puedes crear controladores IDENTIFY para integraciones de dispositivo independiente y concentrador, respectivamente.

const identifyHandler = (request: IntentFlow.IdentifyRequest):
  IntentFlow.IdentifyResponse => {

    // Obtain scan data from protocol defined in your scan config
    const device = request.inputs[0].payload.device;
    if (device.udpScanData === undefined) {
      throw Error("Missing discovery response");
    }
    const scanData = device.udpScanData.data;

    // Decode scan data to obtain metadata about local device
    const verificationId = "local-device-id";

    // Return a response
    const response: IntentFlow.IdentifyResponse = {
      intent: Intents.IDENTIFY,
      requestId: request.requestId,
      payload: {
        device: {
          id: device.id || "",
          verificationId, // Must match otherDeviceIds in SYNC response
        },
      },
    };
    return response;
  };

const identifyHandler = (request: IntentFlow.IdentifyRequest):
  IntentFlow.IdentifyResponse => {

    // Obtain scan data from protocol defined in your scan config
    const device = request.inputs[0].payload.device;
    if (device.udpScanData === undefined) {
      throw Error("Missing discovery response");
    }
    const scanData = device.udpScanData.data;

    // Decode scan data to obtain metadata about local device
    const proxyDeviceId = "local-hub-id";

    // Return a response
    const response: IntentFlow.IdentifyResponse = {
      intent: Intents.IDENTIFY,
      requestId: request.requestId,
      payload: {
        device: {
          id: proxyDeviceId,
          isProxy: true,     // Device can control other local devices
          isLocalOnly: true, // Device not present in `SYNC` response
        },
      },
    };
    return response;
  };

Identifica dispositivos detrás de un concentrador

Si Google identifica un dispositivo de concentrador, lo tratará como un conducto. a los dispositivos finales conectados de la unidad central para verificarlos.

Para permitir que Google confirme que hay una unidad central, sigue estos pasos: instrucciones para tu controlador IDENTIFY:

• Si tu respuesta SYNC informa los IDs de los dispositivos finales locales conectados al central, establece isProxy como true en IdentifyResponsePayload
• Si tu respuesta de SYNC no informa sobre tu dispositivo central, configura isLocalOnly como true en el IdentifyResponsePayload
• El campo device.id contiene el ID de dispositivo local del dispositivo concentrador.

Implementa el controlador REACHABLE_DEVICE (solo integraciones de concentrador)

Google envía el intent REACHABLE_DEVICES para confirmar qué dispositivos finales se pueden controlar a nivel local. Este intent se activa cada vez que Google ejecuta un de descubrimiento (aproximadamente una vez por minuto), siempre que se detecte que el concentrador estar en línea.

Implementa el controlador REACHABLE_DEVICES de manera similar a IDENTIFY. de Google, excepto que este debe recopilar IDs de dispositivo adicionales al que puede acceder el dispositivo proxy local (es decir, el concentrador). El El campo device.verificationId contiene el ID de dispositivo local de un dispositivo final que está conectada al concentrador.

El ReachableDevicesRequest de la plataforma de Local Home contiene una instancia de LocalIdentifiedDevice En esta instancia, puedes obtener el ID de dispositivo del proxy, así como los datos de los resultados del análisis.

Tu controlador REACHABLE_DEVICES debería mostrar un ReachableDevicesPayload que incluye un objeto devices que contiene un array de Valores verificationId que representan los dispositivos finales que controla la unidad central El Los valores de verificationId deben coincidir con uno de los otherDeviceIds del Respuesta de SYNC.

En el siguiente fragmento, se muestra cómo puedes crear tu REACHABLE_DEVICES controlador.

const reachableDevicesHandler = (request: IntentFlow.ReachableDevicesRequest):
  IntentFlow.ReachableDevicesResponse => {

    // Reference to the local proxy device
    const proxyDeviceId = request.inputs[0].payload.device.id;

    // Gather additional device ids reachable by local proxy device
    // ...

    const reachableDevices = [
      // Each verificationId must match one of the otherDeviceIds
      // in the SYNC response
      { verificationId: "local-device-id-1" },
      { verificationId: "local-device-id-2" },
    ];

    // Return a response
    const response: IntentFlow.ReachableDevicesResponse = {
      intent: Intents.REACHABLE_DEVICES,
      requestId: request.requestId,
      payload: {
        devices: reachableDevices,
      },
    };
    return response;
  };

Implementa el controlador EXECUTE

El controlador EXECUTE de la app procesa los comandos del usuario y usa el SDK de Local Home para acceder a tus dispositivos inteligentes a través de un protocolo existente.

La plataforma de Local Home pasa la misma carga útil de entrada al controlador EXECUTE. que para EXECUTE a tu entrega en la nube. Del mismo modo, tu controlador EXECUTE muestra datos de salida en el mismo formato que a partir del procesamiento del intent EXECUTE Para simplificar la creación de respuestas, puedes usar la Execute.Response.Builder que proporciona el SDK de Local Home.

Tu app no tiene acceso directo a la dirección IP del dispositivo. Más bien, usa el CommandRequest para crear comandos basados en uno de estos protocolos: UDP, TCP o HTTP. Luego, llama al deviceManager.send() para enviar los comandos.

Cuando orientes comandos a dispositivos, usa el ID de dispositivo (y los parámetros de la customData, si se incluye) de la respuesta de SYNC para comunicarse. con el dispositivo.

Ejemplo

En el siguiente fragmento de código, se muestra cómo puedes crear tu controlador EXECUTE.

const executeHandler = (request: IntentFlow.ExecuteRequest):
  Promise<IntentFlow.ExecuteResponse> => {

    // Extract command(s) and device target(s) from request
    const command = request.inputs[0].payload.commands[0];
    const execution = command.execution[0];

    const response = new Execute.Response.Builder()
      .setRequestId(request.requestId);

    const result = command.devices.map((device) => {
      // Target id of the device provided in the SYNC response
      const deviceId = device.id;
      // Metadata for the device provided in the SYNC response
      // Use customData to provide additional required execution parameters
      const customData: any = device.customData;

      // Convert execution command into payload for local device
      let devicePayload: string;
      // ...

      // Construct a local device command over TCP
      const deviceCommand = new DataFlow.TcpRequestData();
      deviceCommand.requestId = request.requestId;
      deviceCommand.deviceId = deviceId;
      deviceCommand.data = devicePayload;
      deviceCommand.port = customData.port;
      deviceCommand.operation = Constants.TcpOperation.WRITE;

      // Send command to the local device
      return localHomeApp.getDeviceManager()
        .send(deviceCommand)
        .then((result) => {
          response.setSuccessState(result.deviceId, state);
        })
        .catch((err: IntentFlow.HandlerError) => {
          err.errorCode = err.errorCode || IntentFlow.ErrorCode.INVALID_REQUEST;
          response.setErrorState(device.id, err.errorCode);
        });
    });

    // Respond once all commands complete
    return Promise.all(result)
      .then(() => response.build());
  };

Implementa el controlador QUERY

El controlador QUERY de la app procesa las solicitudes del usuario y usa el elemento SDK de Local Home para informar sobre el estado de tus dispositivos inteligentes.

La plataforma Local Home pasa la misma carga útil de la solicitud a 'QUERY' controlador que para QUERY a tu entrega en la nube. De manera similar, tu controlador QUERY muestra datos en el mismo formato que a partir del procesamiento del intent QUERY.

Enviar comandos a dispositivos detrás de un concentrador

Para controlar dispositivos finales detrás de un concentrador, es posible que debas proporcionar información adicional en la carga útil del comando específico de protocolo enviado al concentrador para que el concentrador para identificar a qué dispositivo está destinado el comando. En algunos casos, esto puede ser inferido directamente del valor device.id, pero cuando este no es el caso, debes incluir estos datos adicionales como parte del campo customData.

Si creaste tu app con TypeScript, recuerda compilarla para JavaScript: Puedes usar el sistema de módulos que desees para escribir el código. Asegúrate de que el navegador Chrome admita tu segmentación.