कस्टम डिवाइस से जुड़ी कार्रवाइयां रजिस्टर करें

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

डिवाइस पर कस्टम ऐक्शन तय करने के लिए, आपको इनकी ज़रूरत होगी:

उपयोगकर्ता की क्वेरी से मैच करने वाला पैटर्न
मिलती-जुलती क्वेरी से जोड़ने के लिए, कस्टम डिवाइस ऐक्शन
अगर डिवाइस पर कार्रवाई की सुविधा काम करती है, तो उपयोगकर्ता को वापस बताया गया टेक्स्ट
एक निर्देश नाम जिसे सभी पैरामीटर के साथ आपके डिवाइस को वापस भेजा जाता है

इस जानकारी को किसी ऐक्शन पैकेज में डालकर, डिवाइस पर अपने हिसाब से ऐक्शन बनाया जा सकता है. कार्रवाई वाले पैकेज, Assistant के जवाबों का फ़ॉर्मैट तय करते हैं. कार्रवाई SDK टूल से अलग, डिवाइस पर कस्टम कार्रवाइयां स्थानीय तौर पर पूरी होती हैं; आप अनुरोधों को प्रोसेस करने और जवाब देने के लिए कोई एंडपॉइंट तय नहीं करते. डिवाइस पर कस्टम कार्रवाइयां, बातचीत वाली टोन में नहीं होतीं.

ऐक्शन पैकेज बनाना

नीचे दिए गए उदाहरण का इस्तेमाल करके, एक ऐसी फ़ाइल (जैसे कि actions.json) बनाएं जो जांच के निर्देश के बारे में बताती हो: एलईडी को ब्लिंक करना. पिछले चरण में डाउनलोड किए गए सैंपल कोड से इसे कॉपी करें:

cd assistant-sdk-python/google-assistant-sdk/googlesamples/assistant/grpc/

cp ~/assistant-sdk-python/google-assistant-sdk/actions.json .

उदाहरण

{
    "manifest": {
        "displayName": "Blinky light",
        "invocationName": "Blinky light",
        "category": "PRODUCTIVITY"
    },
    "actions": [
        {
            "name": "com.example.actions.BlinkLight",
            "availability": {
                "deviceClasses": [
                    {
                        "assistantSdkDevice": {}
                    }
                ]
            },
            "intent": {
                "name": "com.example.intents.BlinkLight",
                "parameters": [
                    {
                        "name": "number",
                        "type": "SchemaOrg_Number"
                    },
                    {
                        "name": "speed",
                        "type": "Speed"
                    }
                ],
                "trigger": {
                    "queryPatterns": [
                        "blink ($Speed:speed)? $SchemaOrg_Number:number times",
                        "blink $SchemaOrg_Number:number times ($Speed:speed)?"
                    ]
                }
            },
            "fulfillment": {
                "staticFulfillment": {
                    "templatedResponse": {
                        "items": [
                            {
                                "simpleResponse": {
                                    "textToSpeech": "Blinking $number times"
                                }
                            },
                            {
                                "deviceExecution": {
                                    "command": "com.example.commands.BlinkLight",
                                    "params": {
                                        "speed": "$speed",
                                        "number": "$number"
                                    }
                                }
                            }
                        ]
                    }
                }
            }
        }
    ],
    "types": [
        {
            "name": "$Speed",
            "entities": [
                {
                    "key": "SLOWLY",
                    "synonyms": [
                        "slowly",
                        "slow"
                    ]
                },
                {
                    "key": "NORMALLY",
                    "synonyms": [
                        "normally",
                        "regular"
                    ]
                },
                {
                    "key": "QUICKLY",
                    "synonyms": [
                        "quickly",
                        "fast",
                        "quick"
                    ]
                }
            ]
        }
    ]
}actions.json

पिछला उदाहरण, कस्टम डिवाइस ऐक्शन तय करने के लिए नीचे दी गई जानकारी का इस्तेमाल करता है:

उपयोगकर्ता की क्वेरी से मेल खाने वाला पैटर्न (Blink N बार)
संगठन के मकसद से, मेल खाने वाली क्वेरी (com.example.actions.BlinkLight) से जोड़ने के लिए, कस्टम डिवाइस ऐक्शन
अगर डिवाइस पर कार्रवाई की सुविधा काम करती है, तो उपयोगकर्ता को वापस बोला गया टेक्स्ट (बार-बार ब्लिंक करना)
एक निर्देश का नाम (com.example.commands.BlinkLight) जिसे किसी भी पैरामीटर (संख्या या शायद स्पीड का ब्यौरा) के साथ डिवाइस को वापस भेजा जाता है

क्वेरी पैटर्न तय करने के लिए, इन बातों का ध्यान रखें:

क्वेरी पैटर्न में, schema.org के तय किए गए टाइप इस्तेमाल किए जा सकते हैं.
types [...] कलेक्शन, कस्टम टाइप (उदाहरण के लिए, $Speed) की सूची के बारे में बताता है.
क्वेरी पैटर्न में, कस्टम टाइप इस्तेमाल किए जा सकते हैं. उपयोगकर्ता क्वेरी पैटर्न से मिलान करने के लिए आपके कस्टम प्रकार में किसी भी समानार्थी को बोल सकता है.
जब कोई समानार्थी शब्द मेल खाता है, तो टाइप इंस्टेंस (speed) सामान्य कुंजी (SLOWLY) दिखाएगा. उदाहरण के लिए, कई इकाइयां हो सकती हैं, जैसे कि अलग-अलग ऐसी लाइटें हैं जो ब्लिंक करने की अलग-अलग स्पीड पर काम करती हैं.
टीटीएस पैटर्न के लिए अनुरोध के कुछ हिस्से वैकल्पिक हो सकते हैं. उदाहरण के लिए, इस हिस्से को वैकल्पिक बनाने के लिए, क्वेरी पैटर्न में ($Speed:speed)? का इस्तेमाल करें.
जवाब में $type.raw (उदाहरण के लिए, $speed.raw) को उपयोगकर्ता के बोले गए शब्दों से बदल दिया जाता है.

इनमें से कई फ़ील्ड की जानकारी के लिए, ActionPackage दस्तावेज़ देखें.

ऐक्शन पैकेज को डिप्लॉय करें

किसी सेट की गई कार्रवाई के पैकेज में डिवाइस के लिए अपनी पसंद के मुताबिक़ कार्रवाई बनाने के बाद, Assistant उस कार्रवाई पैकेज को ऐक्सेस कर सकती है.

हालांकि, इस सेक्शन में दिए गए चरणों को अपने डिवाइस पर पूरा किया जा सकता है, लेकिन डेवलपमेंट सिस्टम पर इन्हें पूरा करना आसान हो सकता है. यहां दिए गए निर्देशों को चलाने के लिए, वर्चुअल एनवायरमेंट की ज़रूरत नहीं होती.

gactions कमांड लाइन टूल डाउनलोड करें.

ध्यान दें: डाउनलोड की गई बाइनरी को एक्ज़ीक्यूट करने लायक बनाने के लिए, Linux पर chmod +x gactions चलाएं.
gactions टूल वाली डायरेक्ट्री से सभी मौजूदा क्रेडेंशियल हटाएं.
```
rm creds.data
```
gactions सीएलआई का इस्तेमाल करके, Google पर अपनी सेट की गई कार्रवाई का पैकेज सेव करें. project_id की जगह अपने Actions Console प्रोजेक्ट आईडी का इस्तेमाल करें.
```
./gactions update --action_package actions.json --project project_id
```
ध्यान दें: अगर आपको Requested entity is not found मैसेज दिखता है, तो आपको अपना प्रोजेक्ट इंपोर्ट करना कार्रवाइयां कंसोल में
होगा.
पहली बार यह निर्देश चलाने पर आपको एक यूआरएल दिया जाएगा और आपसे साइन इन करने के लिए कहा जाएगा. यूआरएल कॉपी करें और उसे ब्राउज़र में चिपकाएं (ऐसा किसी भी सिस्टम पर किया जा सकता है). पेज पर आपसे अपने Google खाते में साइन इन करने के लिए कहा जाएगा. उस Google खाते में साइन इन करें जिसका इस्तेमाल करके पिछले चरण.
एपीआई से अनुमति के अनुरोध को स्वीकार करने के बाद, आपके ब्राउज़र में एक कोड दिखेगा, जैसे कि "4/XXXX". इस कोड को कॉपी करें और टर्मिनल में चिपकाएं:
```
Enter the authorization code:
```
अनुमति मिलने पर, आपको इनके जैसा जवाब दिखेगा:
```
Your app for the Assistant for project my-devices-project was successfully
updated with your actions.
```
gactions सीएलआई का इस्तेमाल करके, अपनी सेट की गई कार्रवाई के पैकेज को टेस्ट मोड में डिप्लॉय करें. इस निर्देश को चलाने से पहले, आपने कम से कम एक बार अपनी कार्रवाई के पैकेज को Google में सेव किया होगा. टेस्ट मोड, सिर्फ़ आपके उपयोगकर्ता खाते पर ऐक्शन पैकेज को चालू करता है.
```
./gactions test --action_package actions.json --project project_id
```
फ़िलहाल, ऐक्शन सिम्युलेटर का इस्तेमाल करके प्रोजेक्ट की जांच नहीं की जा सकती.

ध्यान दें: टेस्ट मोड 30 दिनों की होता है. समयसीमा खत्म होने पर, gactions test को फिर से चलाएं.
सेट की गई कार्रवाई के पैकेज को अपडेट करने के लिए, gactions update निर्देश का इस्तेमाल करें.
(ज़रूरी नहीं) एक प्रोजेक्ट में एक साथ कई अलग-अलग भाषाओं और स्थान-भाषाओं के साथ काम करने के लिए, स्थानीय ऐक्शन पैकेज बनाए जा सकते हैं.

सैंपल में बदलाव करें

डिवाइस पर इस सेक्शन में बताया गया तरीका अपनाएं.

nano pushtotalk.py

अपनी कस्टम कार्रवाई के लिए कोई हैंडलर जोड़ें. ध्यान दें कि नीचे दिए गए हैंडलर को पहले ही ऊपर दिए गए सैंपल ऐक्शन पैकेज के लिए, सैंपल कोड में जोड़ा जा चुका है.

...

device_handler = device_helpers.DeviceRequestHandler(device_id)

@device_handler.command('com.example.commands.BlinkLight')
def blink(speed, number):
    logging.info('Blinking device %s times.' % number)
    delay = 1
    if speed == "SLOWLY":
        delay = 2
    elif speed == "QUICKLY":
        delay = 0.5
    for i in range(int(number)):
        logging.info('Device is blinking.')
        # GPIO.output(25, 1)
        time.sleep(delay)
        # GPIO.output(25, 0)
        time.sleep(1)

सैंपल चलाएं

सोर्स कोड चलाएं.

python pushtotalk.py

कोई क्वेरी डालकर देखें. ऊपर दिए गए उदाहरण के लिए, नीचे दिए गए तरीके आज़माएं:

पांच बार ब्लिंक करें.

ध्यान दें कि क्वेरी, कार्रवाई वाले पैकेज में दिए गए क्वेरी पैटर्न से मेल खानी चाहिए.