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

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

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

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

इस जानकारी को ऐक्शन पैकेज शामिल है. ऐक्शन पैकेज में, Assistant से मिलने वाले जवाबों का फ़ॉर्मैट तय किया जाता है. इसे नापसंद करें Actions 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

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

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

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

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

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

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

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

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

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

2. gactions वाली डायरेक्ट्री से सभी मौजूदा क्रेडेंशियल हटाएं टूल.

   rm creds.data

3. gactions सीएलआई का इस्तेमाल करके, ऐक्शन पैकेज को Google पर सेव करें. project_id को अपने Actions Console प्रोजेक्ट से बदलें आईडी.

   ./gactions update --action_package actions.json --project project_id

4. पहली बार इस निर्देश को चलाने पर, आपको एक यूआरएल दिया जाएगा और आपसे साइन इन करें. यूआरएल को कॉपी करें और उसे ब्राउज़र में चिपकाएं. ऐसा किसी भी सिस्टम पर किया जा सकता है. पेज पर आपको अपने Google खाते में साइन इन करने के लिए कहा जाएगा. हस्ताक्षर करें उस Google खाते में लिंक है जिससे प्रोजेक्ट बनाया गया था अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है step पर टैप करें.

5. एपीआई से मिला अनुमति का अनुरोध स्वीकार किए जाने के बाद, आपको एक कोड दिखेगा जैसे कि "4/XXXX". इस कोड को कॉपी करके यहां चिपकाएं टर्मिनल:

   Enter the authorization code:

   अनुमति मिलने के बाद, आपको इससे मिलता-जुलता जवाब दिखेगा निम्न:

   Your app for the Assistant for project my-devices-project was successfully
   updated with your actions.
   

6. gactions सीएलआई का इस्तेमाल करके, अपने ऐक्शन पैकेज को टेस्ट मोड में डिप्लॉय करें. आपको अपने ऐक्शन पैकेज को, पहले से ही कम से कम एक बार Google पर सेव करना होगा इस आदेश को चला रहा है. परीक्षण मोड आपके उपयोगकर्ता खाते के लिए उपलब्ध है.

   ./gactions test --action_package actions.json --project project_id

   फ़िलहाल, ऐक्शन सिम्युलेटर का इस्तेमाल करके प्रोजेक्ट की जांच नहीं की जा सकती.

7. Action पैकेज को अपडेट करने के लिए, gactions update निर्देश का इस्तेमाल करें.

8. (ज़रूरी नहीं) स्थानीय भाषा में कार्रवाई वाले पैकेज बनाए जा सकते हैं कई अलग-अलग भाषाओं और स्थान-भाषाओं के साथ काम करता है एक ही प्रोजेक्ट में एक साथ रिकॉर्ड करें.

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

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

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

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

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

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