लोकल फ़ुलफ़िलमेंट ऐप्लिकेशन लागू करना

लोकल फ़ुलफ़िलमेंट की सुविधा के लिए, आपको एक ऐसा ऐप्लिकेशन बनाना होगा जो इन स्मार्ट होम इंटेंट को हैंडल कर सके:

• IDENTIFY: इससे, स्थानीय तौर पर कंट्रोल किए जा सकने वाले स्मार्ट डिवाइसों का पता लगाया जा सकता है. इंटेंट हैंडलर, उस डेटा को निकालता है जो स्मार्ट डिवाइस, खोज के दौरान दिखाता है. इसके बाद, यह डेटा Google को भेजता है.
• EXECUTE: इससे निर्देशों को लागू किया जा सकता है.
• QUERY: डिवाइस की स्थिति के बारे में क्वेरी करने की सुविधा देता है.
• REACHABLE_DEVICES: (ज़रूरी नहीं) इससे, हब (या ब्रिज) डिवाइस से कनेक्ट किए गए ऐसे एंड डिवाइसों को खोजने में मदद मिलती है जिन्हें स्थानीय तौर पर कंट्रोल किया जा सकता है.

यह ऐप्लिकेशन, उपयोगकर्ता के Google Home या Google Nest डिवाइसों पर काम करता है. साथ ही, यह आपके स्मार्ट डिवाइस को Assistant से कनेक्ट करता है. ऐप्लिकेशन को TypeScript (सुझाया गया) या JavaScript का इस्तेमाल करके बनाया जा सकता है.

TypeScript का इस्तेमाल करने का सुझाव दिया जाता है. इसकी मदद से, बाइंडिंग का इस्तेमाल किया जा सकता है. इससे यह पक्का किया जा सकता है कि आपका ऐप्लिकेशन जिस तरह का डेटा दिखाता है वह प्लैटफ़ॉर्म की उम्मीदों के मुताबिक हो.

एपीआई के बारे में ज़्यादा जानने के लिए, Local Home SDK API का रेफ़रंस देखें.

यहां दिए गए स्निपेट में, लोकल फ़ुलफ़िलमेंट ऐप्लिकेशन को शुरू करने और हैंडलर अटैच करने का तरीका बताया गया है.

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

अपना प्रोजेक्ट बनाना

स्थानीय फ़ुलफ़िलमेंट ऐप्लिकेशन को डिप्लॉय करने के लिए, आपको अपने कोड और उसकी सभी डिपेंडेंसी के लिए JavaScript बंडल बनाना होगा.

अपने पसंदीदा बंडलर कॉन्फ़िगरेशन के साथ सही प्रोजेक्ट स्ट्रक्चर को बूटस्ट्रैप करने के लिए, लोकल फ़ुलफ़िलमेंट ऐप्लिकेशन project initializer का इस्तेमाल करें.

प्रोजेक्ट टेंप्लेट

बंडलर कॉन्फ़िगरेशन चुनने के लिए, npm init कमांड चलाएं. इसे यहां दिए गए उदाहरणों में दिखाया गया है:

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

प्रोजेक्ट-लेवल पर सामान्य टास्क पूरे करना

जनरेट किया गया प्रोजेक्ट, इन npm scripts के साथ काम करता है:

cd project-directory/
npm run build

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

cd project-directory/
npm run start

IDENTIFY हैंडलर लागू करना

Google Home या Google Nest डिवाइस के रीबूट होने पर, IDENTIFY हैंडलर ट्रिगर हो जाएगा. साथ ही, यह उन लोकल डिवाइसों को देखेगा जिनकी पुष्टि नहीं हुई है. इनमें हब से कनेक्ट किए गए एंड डिवाइस भी शामिल हैं. Local Home प्लैटफ़ॉर्म, स्कैन कॉन्फ़िगरेशन की उस जानकारी का इस्तेमाल करके लोकल डिवाइसों को स्कैन करेगा जो आपने पहले दी थी. साथ ही, स्कैन के नतीजों के साथ आपके IDENTIFY हैंडलर को कॉल करेगा.

लोकल होम प्लैटफ़ॉर्म से मिले IdentifyRequest में, LocalIdentifiedDevice इंस्टेंस का स्कैन किया गया डेटा होता है. सिर्फ़ एक device इंस्टेंस पॉप्युलेट होता है. यह उस स्कैन कॉन्फ़िगरेशन पर आधारित होता है जिसने डिवाइस का पता लगाया है.

अगर स्कैन के नतीजे आपके डिवाइस से मेल खाते हैं, तो आपके IDENTIFY हैंडलर को IdentifyResponsePayload ऑब्जेक्ट दिखाना चाहिए. इसमें स्मार्ट होम मेटाडेटा (जैसे कि टाइप, ट्रेट, और रिपोर्ट की स्थिति) वाला device ऑब्जेक्ट शामिल होता है.

अगर IDENTIFY रिस्पॉन्स से मिले verificationId की वैल्यू, SYNC रिस्पॉन्स से मिली otherDeviceIds वैल्यू में से किसी एक से मेल खाती है, तो Google डिवाइस को लिंक कर देता है.

उदाहरण

यहां दिए गए स्निपेट में, स्टैंडअलोन डिवाइस और हब इंटिग्रेशन के लिए IDENTIFY हैंडलर बनाने का तरीका बताया गया है.

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

हब से कनेक्ट किए गए डिवाइसों की पहचान करना

अगर Google को किसी हब डिवाइस का पता चलता है, तो वह हब को हब से कनेक्ट किए गए एंड डिवाइसों के लिए एक माध्यम के तौर पर इस्तेमाल करेगा. साथ ही, उन एंड डिवाइसों की पुष्टि करने की कोशिश करेगा.

Google को यह पुष्टि करने की अनुमति देने के लिए कि हब डिवाइस मौजूद है, अपने IDENTIFY हैंडलर के लिए इन निर्देशों का पालन करें:

• अगर SYNC के जवाब में, हब से कनेक्ट किए गए लोकल एंड डिवाइसों के आईडी दिखते हैं, तो IdentifyResponsePayload में isProxy को true के तौर पर सेट करें.
• अगर SYNC जवाब में आपके हब डिवाइस की जानकारी नहीं मिलती है, तो IdentifyResponsePayload में isLocalOnly को true के तौर पर सेट करें.
• device.id फ़ील्ड में, हब डिवाइस का लोकल डिवाइस आईडी होता है.

REACHABLE_DEVICES हैंडलर लागू करें (सिर्फ़ हब इंटिग्रेशन के लिए)

Google, REACHABLE_DEVICES इंटेंट भेजता है. इससे यह पुष्टि की जाती है कि कौनसे एंड डिवाइसों को स्थानीय तौर पर कंट्रोल किया जा सकता है. इस इंटेंट को हर बार तब ट्रिगर किया जाता है, जब Google डिस्कवरी स्कैन करता है. यह स्कैन हर मिनट में एक बार होता है. हालांकि, ऐसा तब तक होता है, जब तक हब ऑनलाइन है.

REACHABLE_DEVICES हैंडलर को IDENTIFY हैंडलर की तरह ही लागू किया जाता है. हालांकि, आपके हैंडलर को लोकल प्रॉक्सी (यानी कि हब) डिवाइस से कनेक्ट किए जा सकने वाले अतिरिक्त डिवाइस आईडी इकट्ठा करने होते हैं. device.verificationId फ़ील्ड में, हब से कनेक्ट किए गए एंड डिवाइस का लोकल डिवाइस आईडी होता है.

लोकल होम प्लैटफ़ॉर्म से मिले ReachableDevicesRequest में LocalIdentifiedDevice का उदाहरण शामिल होता है. इस इंस्टेंस के ज़रिए, आपको प्रॉक्सी डिवाइस आईडी के साथ-साथ स्कैन के नतीजों से मिला डेटा भी मिल सकता है.

आपके REACHABLE_DEVICES हैंडलर को एक ReachableDevicesPayload ऑब्जेक्ट दिखाना चाहिए. इसमें एक devices ऑब्जेक्ट शामिल होता है. इस ऑब्जेक्ट में, verificationId वैल्यू की एक ऐसी शृंखला होती है जो उन डिवाइसों को दिखाती है जिन्हें हब कंट्रोल करता है. verificationId की वैल्यू, SYNC रिस्पॉन्स में मौजूद otherDeviceIds की वैल्यू से मेल खानी चाहिए.

यहां दिए गए स्निपेट में, REACHABLE_DEVICES हैंडलर बनाने का तरीका बताया गया है.

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

EXECUTE हैंडलर लागू करना

ऐप्लिकेशन में मौजूद EXECUTE हैंडलर, उपयोगकर्ता के निर्देशों को प्रोसेस करता है. साथ ही, लोकल होम एसडीके का इस्तेमाल करके, मौजूदा प्रोटोकॉल के ज़रिए आपके स्मार्ट डिवाइसों को ऐक्सेस करता है.

Local Home प्लैटफ़ॉर्म, EXECUTE हैंडलर फ़ंक्शन को वही इनपुट पेलोड पास करता है जो वह क्लाउड फ़ुलफ़िलमेंट के लिए, EXECUTE इंटेंट को पास करता है. इसी तरह, आपका EXECUTE हैंडलर, आउटपुट डेटा को उसी फ़ॉर्मैट में दिखाता है जिस फ़ॉर्मैट में EXECUTE इंटेंट को प्रोसेस किया जाता है. जवाब बनाने की प्रोसेस को आसान बनाने के लिए, Local Home SDK की ओर से उपलब्ध कराई गई Execute.Response.Builder क्लास का इस्तेमाल किया जा सकता है.

आपके ऐप्लिकेशन के पास, डिवाइस के आईपी पते का सीधा ऐक्सेस नहीं होता. इसके बजाय, CommandRequest इंटरफ़ेस का इस्तेमाल करके, इनमें से किसी एक प्रोटोकॉल के आधार पर निर्देश बनाएं: यूडीपी, टीसीपी या एचटीटीपी. इसके बाद, निर्देश भेजने के लिए deviceManager.send() फ़ंक्शन को कॉल करें.

डिवाइसों को टारगेट करने वाले निर्देश देते समय, डिवाइस से कम्यूनिकेट करने के लिए SYNC रिस्पॉन्स से मिले डिवाइस आईडी का इस्तेमाल करें. साथ ही, अगर customData फ़ील्ड में पैरामीटर शामिल हैं, तो उनका भी इस्तेमाल करें.

उदाहरण

यहां दिए गए कोड स्निपेट में, 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());
  };

QUERY हैंडलर लागू करना

ऐप्लिकेशन में मौजूद QUERY हैंडलर, उपयोगकर्ता के अनुरोधों को प्रोसेस करता है. साथ ही, स्मार्ट डिवाइसों की स्थिति की जानकारी देने के लिए, Local Home SDK का इस्तेमाल करता है.

Local Home प्लैटफ़ॉर्म, 'QUERY' हैंडलर फ़ंक्शन को वही अनुरोध पेलोड पास करता है जो QUERY इंटेंट के लिए, आपके क्लाउड फ़ुलफ़िलमेंट को पास किया जाता है. इसी तरह, आपका QUERY हैंडलर, QUERY इंटेंट को प्रोसेस करने के बाद मिले डेटा के फ़ॉर्मैट में ही डेटा दिखाता है.

हब से कनेक्ट किए गए डिवाइसों को निर्देश भेजना

हब से कनेक्ट किए गए डिवाइसों को कंट्रोल करने के लिए, आपको प्रोटोकॉल के हिसाब से कमांड पेलोड में अतिरिक्त जानकारी देनी पड़ सकती है. यह जानकारी हब को भेजी जाती है, ताकि हब यह पहचान सके कि कमांड किस डिवाइस के लिए है. कुछ मामलों में, इस जानकारी का पता सीधे तौर पर device.id वैल्यू से लगाया जा सकता है. हालांकि, ऐसा न होने पर आपको इस अतिरिक्त डेटा को customData फ़ील्ड में शामिल करना चाहिए.

अगर आपने TypeScript का इस्तेमाल करके अपना ऐप्लिकेशन बनाया है, तो उसे JavaScript में कंपाइल करना न भूलें. कोड लिखने के लिए, अपनी पसंद की मॉड्यूल सिस्टम का इस्तेमाल किया जा सकता है. पक्का करें कि आपका टारगेट, Chrome ब्राउज़र के साथ काम करता हो.