Android विजेट को Google Assistant के साथ इंटिग्रेट करना

1. खास जानकारी

ऐप्लिकेशन कार्रवाइयों से जुड़े पहले कोडलैब में, आपने सेहत और फ़िटनेस से जुड़े बीआईआई कैटगरी के बिल्ट-इन इंटेंट (बीआईआई) लागू करके, Google Assistant को फ़िटनेस से जुड़े सैंपल ऐप्लिकेशन के साथ इंटिग्रेट करने का तरीका सीखा था.

ऐप्लिकेशन ऐक्शन की मदद से, उपयोगकर्ता सीधे तौर पर Assistant से किसी ऐप्लिकेशन की खास सुविधाओं को लॉन्च कर सकते हैं. इसके लिए, उन्हें "Ok Google, ExampleApp पर दौड़ना शुरू करो." जैसे निर्देश देने होंगे. Assistant, ऐप्लिकेशन लॉन्च करने के साथ-साथ, उपयोगकर्ता को इंटरैक्टिव Android विजेट भी दिखा सकती है. इससे, ज़रूरी शर्तों को पूरा करने वाले BII के लिए किए गए अनुरोधों को पूरा किया जा सकता है.

इस स्क्रीन में दिखाया गया है कि किसी उपयोगकर्ता की क्वेरी के जवाब में Assistant, विजेट दिखा रही है. इस क्वेरी से, ऐप्लिकेशन की GET_EXERCISE_OBSERVATION BII सुविधा ट्रिगर हुई थी.

आपको क्या बनाना है

इस कोडलैब में, आपको Assistant के उपयोगकर्ताओं के अनुरोधों को पूरा करने के लिए, Android विजेट वापस लाने का तरीका बताया गया है. आपको इन चीज़ों के बारे में भी जानकारी मिलेगी:

विजेट को मनमुताबिक बनाने के लिए, उपयोगकर्ता के बीआईआई पैरामीटर.
Assistant में मौजूद अपने विजेट के लिए, लिखाई को बोली में बदलने (टीटीएस) की सुविधा का इस्तेमाल करके जानकारी दें.
बिल्ट-इन इंटेंट के रेफ़रंस का इस्तेमाल करके, यह पता लगाएं कि कौनसे बीआईआई, विजेट फ़ुलफ़िलमेंट की सुविधा के साथ काम करते हैं.

ज़रूरी शर्तें

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

शेल कमांड चलाने के लिए टर्मिनल. साथ ही, git इंस्टॉल होना चाहिए.
Android Studio का नया स्टेबल वर्शन.
इंटरनेट की सुविधा वाला कोई फ़िज़िकल या वर्चुअल Android डिवाइस.
एक Google खाता, जिससे आपने Android Studio, Google ऐप्लिकेशन, और Google Assistant ऐप्लिकेशन में साइन इन किया हो.

अगर किसी फ़िज़िकल डिवाइस का इस्तेमाल किया जा रहा है, तो उसे अपनी लोकल डेवलपमेंट मशीन से कनेक्ट करें.

2. जानें कि यह सुविधा कैसे काम करती है

Google Assistant, नैचुरल लैंग्वेज अंडरस्टैंडिंग (एनएलयू) का इस्तेमाल करके, उपयोगकर्ता के अनुरोध को पढ़ती है. इसके बाद, उसे Assistant के बिल्ट-इन इंटेंट (बीआईआई) से मैच करती है. इसके बाद, Assistant, इंटेंट को उस सुविधा के साथ मैप करती है जो बीआईआई को लागू करती है. इस सुविधा को आपने अपने ऐप्लिकेशन में उस इंटेंट के लिए रजिस्टर किया है. आखिर में, Assistant, उपयोगकर्ता के अनुरोध को पूरा करती है. इसके लिए, वह Android विजेट दिखाती है. यह विजेट, आपका ऐप्लिकेशन जनरेट करता है. इसके लिए, वह सुविधा में मौजूद जानकारी का इस्तेमाल करता है.

इस कोडलैब में, आपको एक ऐसी सुविधा तय करनी है जो GET_EXERCISE_OBSERVATION BII के लिए सहायता रजिस्टर करती है. इस सुविधा में, Assistant को FitActions विजेट क्लास के लिए Android इंटेंट जनरेट करने का निर्देश दिया जाता है, ताकि इस BII के अनुरोधों को पूरा किया जा सके. इस क्लास को अपडेट किया जाता है, ताकि Assistant के लिए उपयोगकर्ता की दिलचस्पी के हिसाब से विजेट जनरेट किया जा सके. साथ ही, Assistant के लिए टीटीएस की मदद से जानकारी दी जा सके.

इस डायग्राम में, इस फ़्लो के बारे में बताया गया है:

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

जब कोई उपयोगकर्ता होम स्क्रीन पर विजेट जोड़ता है, तो विजेट डिवाइस के ब्रॉडकास्ट रिसीवर को पिंग करता है. यह सेवा, ऐप्लिकेशन के AndroidManifest.xml संसाधन में मौजूद विजेट के रिसीवर की परिभाषा से, विजेट के बारे में जानकारी वापस लाती है. यह इस जानकारी का इस्तेमाल करके, विजेट को दिखाने वाला RemoteViews ऑब्जेक्ट जनरेट करता है.

सैंपल ऐप्लिकेशन, रिसीवर widgets.StatsWidgetProvider को तय करता है. यह StatsWidgetProvider क्लास से मेल खाता है:

<!-- app/src/main/AndroidManifest.xml -->

<receiver
  android:name=".widgets.StatsWidgetProvider"
  android:exported="false">
  <intent-filter>
    <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
  </intent-filter>
  <meta-data
    android:name="android.appwidget.provider"
    android:resource="@xml/stats_widget" />
</receiver>

StatsWidgetProvider क्लास, StatsWidgetProvider.kt, StatsWidget ऑब्जेक्ट बनाने के फ़्लो को मैनेज करती है. यह इन ज़िम्मेदारियों को पूरा करता है:

विजेट इंस्टेंस बनाना और उन्हें ऐप्लिकेशन डेटाबेस से कसरत के डेटा से भरना.
formatDataAndSetWidget() की मदद से, कसरत के डेटा को पढ़ने में आसान बनाने के लिए फ़ॉर्मैट करना.
अगर कसरत का डेटा उपलब्ध नहीं है, तो setNoActivityDataWidget() का इस्तेमाल करके डिफ़ॉल्ट वैल्यू देना.

Assistant की सुविधा जोड़ना

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

StatsWidget ऑब्जेक्ट का इंस्टेंस वापस पाने के लिए, GET_EXERCISE_OBSERVATION BII की सुविधा कॉन्फ़िगर करना.
ऐप्लिकेशन कार्रवाइयों की सुविधाओं का इस्तेमाल करने के लिए, StatsWidget क्लास को अपडेट करना. जैसे:
- BII पैरामीटर का इस्तेमाल करके, उपयोगकर्ताओं को कसरत से जुड़े खास आंकड़े देखने की अनुमति देना. इसके लिए, उपयोगकर्ता इस तरह के सवाल पूछ सकते हैं, "Ok Google, मुझे ExampleApp पर अपनी रनिंग के आंकड़े दिखाओ."
- टीटीएस के बारे में जानकारी देने वाली स्ट्रिंग उपलब्ध कराना.
- खास मामलों को मैनेज करना. जैसे, जब उपयोगकर्ता की क्वेरी में वर्कआउट टाइप पैरामीटर शामिल न हो.

3. डेवलपमेंट एनवायरमेंट तैयार करना

अपनी बेस फ़ाइलें डाउनलोड करना

सैंपल ऐप्लिकेशन की GitHub रिपॉज़िटरी को क्लोन करने के लिए, यह निर्देश चलाएं:

git clone --branch start-widget-codelab https://github.com/actions-on-google/appactions-fitness-kotlin.git

रिपॉज़िटरी को क्लोन करने के बाद, Android Studio में इसे खोलने के लिए यह तरीका अपनाएं:

Android Studio में आपका स्वागत है डायलॉग बॉक्स में, प्रोजेक्ट इंपोर्ट करें पर क्लिक करें.
वह फ़ोल्डर ढूंढें और चुनें जहां आपने रिपॉज़िटरी को क्लोन किया है.

पूरे कोडलैब को दिखाने वाले ऐप्लिकेशन का वर्शन देखने के लिए, --branch master फ़्लैग का इस्तेमाल करके, सैंपल ऐप्लिकेशन रेपो को क्लोन करें.

Android ऐप्लिकेशन का आईडी अपडेट करना

ऐप्लिकेशन के आईडी को अपडेट करने से, आपके टेस्ट डिवाइस पर ऐप्लिकेशन की खास तौर पर पहचान होती है. साथ ही, अगर ऐप्लिकेशन को Play Console पर अपलोड किया जाता है, तो "डुप्लीकेट पैकेज का नाम" वाली गड़बड़ी नहीं होती है. ऐप्लिकेशन आईडी अपडेट करने के लिए, app/build.gradle खोलें:

android {
...
  defaultConfig {
    applicationId "com.MYUNIQUENAME.android.fitactions"
    ...
  }
}

applicationId फ़ील्ड में मौजूद "MYUNIQUENAME" को बदलकर, अपनी पसंद का कोई यूनीक नाम डालें.

टेस्ट प्लगिन इंस्टॉल करना

Google Assistant प्लगिन की मदद से, टेस्ट डिवाइस पर ऐप्लिकेशन कार्रवाइयों को आज़माया जा सकता है. यह सुविधा, आपके Android डिवाइस पर मौजूद Google ऐप्लिकेशन के ज़रिए Assistant को जानकारी भेजकर काम करती है. अगर आपके पास पहले से प्लगिन नहीं है, तो इसे इंस्टॉल करने के लिए यह तरीका अपनाएं:

फ़ाइल > सेटिंग पर जाएं (macOS पर Android Studio > प्राथमिकताएं).
Plugins सेक्शन में जाकर, Marketplace पर जाएं और "Google Assistant" खोजें. टेस्ट टूल को मैन्युअल तरीके से डाउनलोड और इंस्टॉल भी किया जा सकता है.
टूल इंस्टॉल करें और Android Studio को फिर से चालू करें.

अपने डिवाइस पर ऐप्लिकेशन को आज़माना

ऐप्लिकेशन में और बदलाव करने से पहले, यह जानना ज़रूरी है कि सैंपल ऐप्लिकेशन क्या-क्या कर सकता है.

अपने टेस्ट डिवाइस पर ऐप्लिकेशन चलाएं:

Android Studio में, अपना फ़िज़िकल या वर्चुअल डिवाइस चुनें. इसके बाद, चलाएं > ऐप्लिकेशन चलाएं को चुनें या टूलबार में चलाएं पर क्लिक करें.
Assistant को सेट अप करने के लिए, होम बटन को दबाकर रखें. साथ ही, यह पुष्टि करें कि Assistant काम कर रही है. अगर आपने पहले से ही अपने डिवाइस पर Assistant में साइन इन नहीं किया है, तो आपको साइन इन करना होगा.

Android वर्चुअल डिवाइसों के बारे में ज़्यादा जानने के लिए, वर्चुअल डिवाइस बनाना और उन्हें मैनेज करना लेख पढ़ें.

ऐप्लिकेशन के बारे में कम शब्दों में जानें, ताकि आपको पता चल सके कि यह क्या-क्या कर सकता है. ऐप्लिकेशन में, पहले से ही 10 तरह की कसरत की गतिविधियां मौजूद होती हैं. यह जानकारी, ऐप्लिकेशन के पहले व्यू में दिखती है.

अपने टेस्ट डिवाइस की होम स्क्रीन पर जाने के लिए, होम बटन पर टैप करें.
होम स्क्रीन पर किसी खाली जगह को दबाकर रखें और विजेट को चुनें.
विजेट की सूची में नीचे की ओर स्क्रोल करके, FitActions पर जाएं.
FitActions आइकॉन को दबाकर रखें और उसके विजेट को होम स्क्रीन पर रखें.

4. ऐप्लिकेशन ऐक्शन जोड़ना

इस चरण में, GET_EXERCISE_OBSERVATION BII की सुविधा जोड़ी जाती है. इसके लिए, shortcuts.xml में नया capability एलिमेंट जोड़ें. इस सुविधा से यह तय होता है कि सुविधा को कैसे ट्रिगर किया जाए, बीआईआई पैरामीटर का इस्तेमाल कैसे किया जाए, और अनुरोध को पूरा करने के लिए किन Android इंटेंट को लागू किया जाए.

इस कॉन्फ़िगरेशन के साथ, सैंपल प्रोजेक्ट shortcuts.xml रिसॉर्स में एक नया capability एलिमेंट जोड़ें:

<!-- fitnessactions/app/src/main/res/xml/shortcuts.xml -->

<capability android:name="actions.intent.GET_EXERCISE_OBSERVATION">
  <app-widget
    android:identifier="GET_EXERCISE_OBSERVATION"
    android:targetClass="com.devrel.android.fitactions.widgets.StatsWidgetProvider"
    android:targetPackage="PUT_YOUR_APPLICATION_ID_HERE">
    <parameter
      android:name="exerciseObservation.aboutExercise.name"
      android:key="aboutExerciseName"
      android:required="true">
    </parameter>
    <extra android:name="hasTts" android:value="true"/>
  </app-widget>
  <!-- Add Fallback Intent-->
</capability>

android:targetPackage वैल्यू PUT_YOUR_APPLICATION_ID_HERE को अपनी यूनीक applicationId से बदलें.

इस सुविधा की मदद से, GET_EXERCISE_OBSERVATION बीआईआई को app-widget इंटेंट पर मैप किया जाता है. इससे बीआईआई ट्रिगर होने पर, विजेट इंस्टैंटिएट हो जाता है और उपयोगकर्ता को दिखता है.

विजेट को ट्रिगर करने से पहले, Assistant उपयोगकर्ता की क्वेरी से, साथ काम करने वाले BII पैरामीटर निकालती है. इस कोडलैब के लिए, BII पैरामीटर exerciseObservation.aboutExercise.name ज़रूरी है. यह उपयोगकर्ता के अनुरोध किए गए व्यायाम के टाइप को दिखाता है. यह ऐप्लिकेशन तीन तरह की कसरत के साथ काम करता है: "दौड़ना", "चलना", और "साइकल चलाना." Assistant को इन वैल्यू के बारे में बताने के लिए, इनलाइन इन्वेंट्री उपलब्ध कराएं.

इन्वेंट्री के इन एलिमेंट को तय करें. इसके लिए, shortcuts.xml में GET_EXERCISE_OBSERVATION सुविधा के ऊपर यह कॉन्फ़िगरेशन जोड़ें:

<!-- shortcuts.xml -->

<!-- shortcuts are bound to the GET_EXERCISE_OBSERVATION capability and
     represent the types of exercises supported by the app. -->

<shortcut
  android:shortcutId="running"
  android:shortcutShortLabel="@string/activity_running">
  <capability-binding android:key="actions.intent.GET_EXERCISE_OBSERVATION">
    <parameter-binding
      android:key="exerciseObservation.aboutExercise.name"
      android:value="@array/runningSynonyms"/>
  </capability-binding>
</shortcut>

<shortcut
  android:shortcutId="walking"
  android:shortcutShortLabel="@string/activity_walking">
  <capability-binding android:key="actions.intent.GET_EXERCISE_OBSERVATION">
    <parameter-binding
      android:key="exerciseObservation.aboutExercise.name"
      android:value="@array/walkingSynonyms"/>
  </capability-binding>
</shortcut>

<shortcut
  android:shortcutId="cycling"
  android:shortcutShortLabel="@string/activity_cycling">
  <capability-binding android:key="actions.intent.GET_EXERCISE_OBSERVATION">
    <parameter-binding
      android:key="exerciseObservation.aboutExercise.name"
      android:value="@array/cyclingSynonyms"/>
  </capability-binding>
</shortcut>

<capability android:name="actions.intent.GET_EXERCISE_OBSERVATION">
  <!-- ... -->
</capability>

फ़ॉलबैक इंटेंट जोड़ना

फ़ॉलबैक इंटेंट, उन स्थितियों को हैंडल करते हैं जहां उपयोगकर्ता की क्वेरी को पूरा नहीं किया जा सकता. ऐसा इसलिए होता है, क्योंकि क्वेरी में उन पैरामीटर की जानकारी नहीं होती जिनकी ज़रूरत होती है. GET_EXERCISE_OBSERVATION सुविधा के लिए, exerciseObservation.aboutExercise.name पैरामीटर की ज़रूरत होती है. इसे android:required="true" एट्रिब्यूट के ज़रिए तय किया जाता है. इन स्थितियों में, Assistant को फ़ॉलबैक इंटेंट तय करने की ज़रूरत होती है, ताकि अनुरोध पूरा किया जा सके. भले ही, क्वेरी में कोई पैरामीटर न दिया गया हो.

shortcuts.xml में, इस कॉन्फ़िगरेशन का इस्तेमाल करके, GET_EXERCISE_OBSERVATION सुविधा में फ़ॉलबैक इंटेंट जोड़ें:

<!-- shortcuts.xml -->

<capability android:name="actions.intent.GET_EXERCISE_OBSERVATION">

  <app-widget>
    <!-- ... -->
  </app-widget>

  <!-- Fallback intent with no parameters needed to successfully execute.-->
  <intent
    android:identifier="GET_EXERCISE_OBSERVATION_FALLBACK"
    android:action="android.intent.action.VIEW"
    android:targetClass="com.devrel.android.fitactions.widgets.StatsWidgetProvider">
  </intent>
</capability>

इस सैंपल कॉन्फ़िगरेशन में, फ़ॉलबैक फ़ुलफ़िलमेंट एक Android इंटेंट है. इसके Extra डेटा में कोई पैरामीटर नहीं है.

5. Assistant के लिए विजेट चालू करें

GET_EXERCISE_OBSERVATION सुविधा को लागू करने के बाद, विजेट क्लास को अपडेट करें, ताकि वह बोलकर ऐप्लिकेशन की कार्रवाइयां चालू करने की सुविधा के साथ काम कर सके.

विजेट एक्सटेंशन लाइब्रेरी जोड़ना

ऐप्लिकेशन कार्रवाइयों की विजेट एक्सटेंशन लाइब्रेरी, Assistant को बोलकर निर्देश देने की सुविधा के लिए आपके विजेट को बेहतर बनाती है. खास तौर पर, इसकी मदद से अपने विजेट के लिए टीटीएस की मदद से, अपनी पसंद के मुताबिक जानकारी दी जा सकती है.

सैंपल ऐप्लिकेशन /app/build.gradle रिसॉर्स में, Widgets Extension लाइब्रेरी की डिपेंडेंसी जोड़ें:
```
// app/build.gradle

dependencies {
  //...
  implementation "com.google.assistant.appactions:widgets:0.0.1"
}
```
Android Studio में दिखने वाले चेतावनी वाले बॉक्स में, अभी सिंक करें पर क्लिक करें. हर build.gradle बदलाव के बाद सिंक करने से, ऐप्लिकेशन बनाते समय गड़बड़ियों से बचा जा सकता है.

Service, ऐप्लिकेशन का एक ऐसा कॉम्पोनेंट होता है जो बैकग्राउंड में लंबे समय तक चलने वाले ऑपरेशन कर सकता है. आपके ऐप्लिकेशन को विजेट के अनुरोधों को प्रोसेस करने के लिए, एक सेवा देनी होगी.

इस कॉन्फ़िगरेशन के साथ, सैंपल ऐप्लिकेशन के AndroidManifest.xml संसाधन में कोई सेवा जोड़ें:

<!-- AndroidManifest.xml -->
<service
   android:name=".widgets.StatsWidgetProvider"
   android:enabled="true"
   android:exported="true">
   <intent-filter>
       <action
           android:name="com.google.assistant.appactions.widgets.PIN_APP_WIDGET" />
   </intent-filter>
</service>

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

आपका ऐप्लिकेशन अब GET_EXERCISE_OBSERVATION सुविधा के अनुरोधों को आपकी विजेट क्लास पर रूट करने के लिए कॉन्फ़िगर किया गया है. इसके बाद, StatsWidget.kt क्लास को अपडेट करें, ताकि बीआईआई पैरामीटर वैल्यू का इस्तेमाल करके, उपयोगकर्ता के अनुरोध के हिसाब से विजेट इंस्टेंस जनरेट किया जा सके.

StatsWidget.kt क्लास खोलें और App Actions Widget Extension लाइब्रेरी इंपोर्ट करें:
```
// StatsWidget.kt

// ... Other import statements
import com.google.assistant.appactions.widgets.AppActionsWidgetExtension
```
इन निजी वैरिएबल को जोड़ें. इनका इस्तेमाल, यह तय करने के लिए किया जाता है कि विजेट में कौनसी जानकारी दिखनी चाहिए:
```
// StatsWidget.kt

private val hasBii: Boolean
private val isFallbackIntent: Boolean
private val aboutExerciseName: String
private val exerciseType: FitActivity.Type
```

क्लास में init फ़ंक्शन जोड़ें, ताकि Assistant से पास किए गए विजेट के विकल्पों के डेटा का इस्तेमाल किया जा सके:

// StatsWidget.kt

init {
  val optionsBundle = appWidgetManager.getAppWidgetOptions(appWidgetId)
  val bii = optionsBundle.getString(AppActionsWidgetExtension.EXTRA_APP_ACTIONS_BII)
  hasBii = !bii.isNullOrBlank()
  val params = optionsBundle.getBundle(AppActionsWidgetExtension.EXTRA_APP_ACTIONS_PARAMS)

  if (params != null) {
    isFallbackIntent = params.isEmpty
    if (isFallbackIntent) {
      aboutExerciseName = context.resources.getString(R.string.activity_unknown)
    } else {
        aboutExerciseName = params.get("aboutExerciseName") as String
      }
  } else {
      isFallbackIntent = false
      aboutExerciseName = context.resources.getString(R.string.activity_unknown)
  }
  exerciseType = FitActivity.Type.find(aboutExerciseName)
}

आइए, जानते हैं कि इन अपडेट की मदद से, StatsWidget.kt क्लास, GET_EXERCISE_OBSERVATION की सुविधा से जनरेट होने वाले Android इंटेंट का जवाब कैसे दे पाती है:

optionsBundle = Bundle
- बंडल ऐसे ऑब्जेक्ट होते हैं जिनका इस्तेमाल प्रोसेस की सीमाओं के पार, इंटेंट वाली गतिविधियों के बीच, और कॉन्फ़िगरेशन में होने वाले बदलावों के दौरान अस्थायी स्थिति को सेव करने के लिए किया जाता है. Assistant, Bundle ऑब्जेक्ट का इस्तेमाल करके, कॉन्फ़िगरेशन डेटा को विजेट तक पहुंचाती है.
bii = actions.intent.GET_EXERCISE_OBSERVATION
- AppActionsWidgetExtension का इस्तेमाल करके, बंडल से BII का नाम ऐक्सेस किया जा सकता है.
hasBii = true
- इस कुकी का इस्तेमाल यह देखने के लिए किया जाता है कि कोई बीआईआई मौजूद है या नहीं.
params = Bundle[{aboutExerciseName=running}]
- ऐप्लिकेशन कार्रवाइयों से जनरेट किया गया खास बंडल, विजेट के विकल्पों Bundle में नेस्ट किया जाता है. इसमें बीआईआई के की/वैल्यू पेयर शामिल होते हैं. इस मामले में, वैल्यू running को उदाहरण क्वेरी, "Ok Google, मुझे ExampleApp पर दौड़ने के आंकड़े दिखाओ" से निकाला गया है.
isFallbackIntent = false
- यह इंटेंट Extras में, ज़रूरी BII पैरामीटर की मौजूदगी की जांच करता है.
aboutExerciseName = running
- aboutExerciseName के लिए, इंटेंट Extras वैल्यू को ऐक्सेस करता है.
exerciseType = RUNNING
- यह aboutExerciseName का इस्तेमाल करके, डेटाबेस टाइप ऑब्जेक्ट को खोजता है.

अब StatsWidget क्लास, ऐप्लिकेशन ऐक्शन के Android इंटेंट डेटा को प्रोसेस कर सकती है. इसलिए, विजेट बनाने के फ़्लो के लॉजिक को अपडेट करें, ताकि यह पता चल सके कि विजेट को ऐप्लिकेशन ऐक्शन से ट्रिगर किया गया था या नहीं.

StatsWidget.kt में, updateAppWidget() फ़ंक्शन की जगह यह कोड डालें:

// StatsWidget.kt

fun updateAppWidget() {
   /**
    * Checks for App Actions BII invocation and if BII parameter data is present.
    * If parameter data is missing, use data from last exercise recorded to the
    *  fitness tracking database.
    */
   if (hasBii && !isFallbackIntent) {
       observeAndUpdateRequestedExercise()
   } else observeAndUpdateLastExercise()
}

ऊपर दिए गए कोड में, एक नए फ़ंक्शन observeAndUpdateRequestedExercise का रेफ़रंस दिया गया है. यह फ़ंक्शन, exerciseType पैरामीटर के उस डेटा का इस्तेमाल करके विजेट डेटा जनरेट करता है जिसे App Actions Android intent ने पास किया है.

इस कोड के साथ observeAndUpdateRequestedExercise फ़ंक्शन जोड़ें:

// StatsWidget.kt

/**
* Create and observe the last exerciseType activity LiveData.
*/
private fun observeAndUpdateRequestedExercise() {
  val activityData = repository.getLastActivities(1, exerciseType)

   activityData.observeOnce { activitiesStat ->
       if (activitiesStat.isNotEmpty()) {
           formatDataAndSetWidget(activitiesStat[0])
           updateWidget()
       } else {
           setNoActivityDataWidget()
           updateWidget()
       }
   }
}

ऊपर दिए गए कोड में, ऐप्लिकेशन में मौजूद repository क्लास का इस्तेमाल करके, ऐप्लिकेशन के लोकल डेटाबेस से फ़िटनेस डेटा वापस पाएं. यह क्लास, डेटाबेस को आसानी से ऐक्सेस करने के लिए एक एपीआई उपलब्ध कराती है. डेटाबेस के ख़िलाफ़ क्वेरी करते समय, रिपॉज़िटरी LiveData ऑब्जेक्ट को दिखाता है. आपको अपने कोड में यह LiveData दिखता है, ताकि फ़िटनेस से जुड़ी हाल की गतिविधि को वापस पाया जा सके.

ध्यान दें: LiveData, ऑब्ज़र्व किए जा सकने वाले डेटा होल्डर क्लास है. सामान्य ऑब्ज़र्वेबल के उलट, LiveData को लाइफ़साइकल की जानकारी होती है. इसका मतलब है कि यह ऐप्लिकेशन के अन्य कॉम्पोनेंट, जैसे कि ऐक्टिविटी, फ़्रैगमेंट या सेवाओं के लाइफ़साइकल का पालन करता है. लाइफ़साइकल के बारे में जानकारी होने से, LiveData सिर्फ़ उन ऐप्लिकेशन कॉम्पोनेंट ऑब्ज़र्वर को अपडेट करता है जो लाइफ़साइकल की चालू स्थिति में हैं. इस कोडलैब के लिए, हम एक बार इस्तेमाल किया जाने वाला ऑब्ज़र्वर इस्तेमाल कर रहे हैं.

TTS की सुविधा चालू करना

विजेट दिखाते समय, Assistant को सूचना देने के लिए टीटीएस स्ट्रिंग दी जा सकती है. हमारा सुझाव है कि इसे शामिल करें, ताकि आपके विजेट के साथ सुनाई देने वाला कॉन्टेक्स्ट उपलब्ध कराया जा सके. यह सुविधा, App Actions Widgets Extension लाइब्रेरी से मिलती है. इसकी मदद से, Assistant में अपने विजेट के साथ दिखने वाले टेक्स्ट और टीटीएस की जानकारी सेट की जा सकती है.

TTS के बारे में जानकारी देने के लिए, formatDataAndSetWidget फ़ंक्शन का इस्तेमाल किया जा सकता है. यह फ़ंक्शन, ऐप्लिकेशन के डेटाबेस से मिले गतिविधि के डेटा को फ़ॉर्मैट करता है.

StatsWidget.kt में, इस कोड को formatDataAndSetWidget फ़ंक्शन में जोड़ें:

// StatsWidget.kt

private fun formatDataAndSetWidget(
  activityStat: FitActivity,
) {
      // ...

      // Add conditional for hasBii for widget with data
      if (hasBii) {
         // Formats TTS speech and display text for Assistant
         val speechText = context.getString(
             R.string.widget_activity_speech,
             activityExerciseTypeFormatted,
             formattedDate,
             durationInMin,
             distanceInKm
         )
         val displayText = context.getString(
             R.string.widget_activity_text,
             activityExerciseTypeFormatted,
             formattedDate
         )
         setTts(speechText, displayText)
      }
}

ऊपर दिए गए कोड में, दो स्ट्रिंग रिसॉर्स के रेफ़रंस दिए गए हैं: एक स्पीच के लिए और दूसरा टेक्स्ट के लिए. टीटीएस से जुड़े सुझाव पाने के लिए, हमारे विजेट के वीडियो में लिखाई को बोली में बदलने के स्टाइल से जुड़े सुझाव वाला हिस्सा देखें. इस सैंपल में setTts का भी इस्तेमाल किया गया है. यह एक नया फ़ंक्शन है, जो विजेट इंस्टेंस को टीटीएस की जानकारी देता है.

इस कोड का इस्तेमाल करके, StatsWidget.kt में यह नया setTts फ़ंक्शन जोड़ें:

// StatsWidget.kt

/**
 * Sets TTS to widget
 */
private fun setTts(
  speechText: String,
  displayText: String,
) {
  val appActionsWidgetExtension: AppActionsWidgetExtension =
      AppActionsWidgetExtension.newBuilder(appWidgetManager)
        .setResponseSpeech(speechText)  // TTS to be played back to the user
        .setResponseText(displayText)  // Response text to be displayed in Assistant
        .build()

  // Update widget with TTS
  appActionsWidgetExtension.updateWidget(appWidgetId)
}

आखिर में, टीटीएस लॉजिक को पूरा करें. इसके लिए, कसरत के डेटाबेस से कसरत के अनुरोध किए गए टाइप के लिए खाली डेटा मिलने पर, टीटीएस की जानकारी सेट करें.

StatsWidget.kt में मौजूद setNoActivityDataWidget() फ़ंक्शन को इस कोड से अपडेट करें:

// StatsWidget.kt

private fun setNoActivityDataWidget() {
  // ...
  // Add conditional for hasBii for widget without data
  if (hasBii) {
    // formats speech and display text for Assistant
    // https://developers.google.com/assistant/app/widgets#library
    val speechText =
      context.getString(R.string.widget_no_activity_speech, aboutExerciseName)
    val displayText =
      context.getString(R.string.widget_no_activity_text)

    setTts(speechText, displayText)
  }
}

6. ऐप्लिकेशन कार्रवाई की जांच करना

डेवलपमेंट के दौरान, टेस्ट डिवाइस पर Assistant ऐप्लिकेशन कार्रवाइयों की झलक देखने के लिए, Google Assistant प्लगिन का इस्तेमाल करें. इस टूल की मदद से, ऐप्लिकेशन से जुड़ी कार्रवाई के लिए इंटेंट पैरामीटर में बदलाव किया जा सकता है. इससे यह टेस्ट किया जा सकता है कि कोई उपयोगकर्ता, Assistant से कार्रवाई करने के लिए अलग-अलग तरीके से अनुरोध कर सकता है.

गाने के टीज़र के तौर पर बना शॉर्ट वीडियो बनाना

प्लगिन की मदद से, ऐप्लिकेशन ऐक्शन की जांच करने के लिए:

टूल > Google Assistant > ऐप्लिकेशन ऐक्शन टेस्ट टूल पर जाएं. आपसे अपने Google खाते का इस्तेमाल करके, Android Studio में साइन इन करने के लिए कहा जा सकता है.
झलक बनाएं पर क्लिक करें. अगर आपसे कहा जाए, तो ऐप्लिकेशन की खास सुविधाओं के लिए कार्रवाइयों की नीतियों और सेवा की शर्तों को पढ़ें और उन्हें स्वीकार करें.

कसरत के अनुमानित टाइप की जांच करना

टेस्ट टूल में यह तरीका अपनाकर, ऐसा विजेट दिखाएं जिसमें ऐप्लिकेशन में पूरा हुआ आखिरी रन की जानकारी हो:

पहले चरण में, टूल आपसे बीआईआई चुनने और उसे कॉन्फ़िगर करने के लिए कहता है. इसमें actions.intent.GET_EXERCISE_OBSERVATION चुनें.
exerciseObservation बॉक्स में, डिफ़ॉल्ट तौर पर दिए गए व्यायाम के नाम को climbing से बदलकर run करें.
ऐप्लिकेशन की कार्रवाई चलाएं पर क्लिक करें.

किसी ऐसी कसरत को टेस्ट करना जिसकी उम्मीद नहीं थी

टेस्ट टूल में, कसरत के किसी ऐसे टाइप की जांच करने के लिए जिसका अनुमान नहीं लगाया गया था:

exerciseObservation बॉक्स में, name वैल्यू को Run से Climbing पर अपडेट करें.
ऐप्लिकेशन की कार्रवाई चलाएं पर क्लिक करें.

Assistant को एक ऐसा विजेट दिखाना चाहिए जिसमें "कोई गतिविधि नहीं मिली" जानकारी दिख रही हो.

फ़ॉलबैक इंटेंट की जांच करना

फ़ॉलबैक इंटेंट को ट्रिगर करने वाली क्वेरी के जवाब में, एक विजेट दिखना चाहिए. इसमें किसी भी तरह की कसरत की आखिरी गतिविधि के बारे में जानकारी दिखनी चाहिए.

फ़ॉलबैक इंटेंट की जांच करने के लिए:

exerciseObservation बॉक्स में, aboutExercise ऑब्जेक्ट मिटाएं.
ऐप्लिकेशन की कार्रवाई चलाएं पर क्लिक करें.

Assistant को एक ऐसा विजेट दिखाना चाहिए जिसमें पिछली कसरत की जानकारी हो.

7. अगले चरण

बधाई हो!

अब आपके पास Assistant के साथ Android विजेट का इस्तेमाल करके, लोगों की क्वेरी पूरी करने का विकल्प है.

हमने क्या-क्या कवर किया है

इस कोडलैब में, आपने ये सीखा:

किसी बीआईआई में ऐप्लिकेशन विजेट जोड़ना.
Android Extras से पैरामीटर ऐक्सेस करने के लिए, किसी विजेट में बदलाव करें.

आगे क्या करना है

यहां से, अपने फ़िटनेस ऐप्लिकेशन को और बेहतर बनाया जा सकता है. पूरे प्रोजेक्ट का रेफ़रंस देखने के लिए, GitHub पर main repo देखें.

ऐप्लिकेशन की खास सुविधाओं के लिए कार्रवाइयों की मदद से, इस ऐप्लिकेशन को बेहतर बनाने के बारे में ज़्यादा जानने के लिए, यहां कुछ सुझाव दिए गए हैं:

अपने ऐप्लिकेशन को Assistant के साथ इंटिग्रेट करने के अन्य तरीके जानने के लिए, ऐप्लिकेशन कार्रवाइयों के पहले से मौजूद इंटेंट का रेफ़रंस देखें.

Actions on Google का इस्तेमाल जारी रखने के लिए, इन संसाधनों को देखें:

developers.google.com/assistant/app: Google Assistant ऐप्लिकेशन ऐक्शन के लिए आधिकारिक दस्तावेज़ वाली साइट.
ऐप्लिकेशन कार्रवाइयों के सैंपल इंडेक्स: ऐप्लिकेशन कार्रवाइयों की सुविधाओं के बारे में जानने के लिए, सैंपल ऐप्लिकेशन और कोड.
Actions on Google GitHub रिपॉज़िटरी: सैंपल कोड और लाइब्रेरी.
r/GoogleAssistantDev: यह Google Assistant के साथ काम करने वाले डेवलपर के लिए, Reddit की आधिकारिक कम्यूनिटी है.

हमारी नई घोषणाओं के बारे में जानने के लिए, हमें Twitter पर @ActionsOnGoogle पर फ़ॉलो करें. साथ ही, आपने जो बनाया है उसे शेयर करने के लिए, #appactions पर ट्वीट करें!

सुझाव/राय देने या शिकायत करने के लिए सर्वे

आखिर में, इस कोडलैब के बारे में अपने अनुभव के बारे में सुझाव/राय देने या शिकायत करने के लिए, कृपया यह सर्वे पूरा करें.