Android पर होम को शुरू करना

Android के लिए Home API का इस्तेमाल करने से पहले, आपको अपने ऐप्लिकेशन में होम को शुरू करना होगा. इस चरण में, आपको लोकल कॉन्टेक्स्ट के लिए सिंगलटन इंस्टेंस Home बनाना होगा.

एक बार में, Home का सिर्फ़ एक इंस्टेंस चालू होना चाहिए.

यह Home API का एंट्री पॉइंट है. इसमें यह भी तय किया जाता है कि Device & Structure और Automation API के साथ, आपको कौनसी ट्रेट और डिवाइस टाइप इस्तेमाल करने हैं. अगर आपने अभी-अभी Google Home के साथ काम करने वाले डिवाइसों का इस्तेमाल शुरू किया है और आपको यह नहीं पता कि कौनसी सुविधाएं या डिवाइस टाइप रजिस्टर करने हैं, तो हमने इस गाइड में कुछ सामान्य सुझाव दिए हैं.

होम इंस्टेंस बनाना

शुरू करने के लिए, इन पैकेज को अपने ऐप्लिकेशन में इंपोर्ट करें:

import android.content.Context
import com.google.home.FactoryRegistry
import com.google.home.HomeConfig
import com.google.home.Home

Home API को शुरू करने के लिए:

1. Application कॉन्टेक्स्ट का रेफ़रंस पाएं. यह कॉन्टेक्स्ट, किसी भी गतिविधि के लाइफ़साइकल पर निर्भर नहीं करता. यह तब तक उपलब्ध रहेगा, जब तक आपका ऐप्लिकेशन चालू है. इसे पाने के लिए, Activity या Service के बीच getApplicationContext() पर कॉल करें:

   val context = getApplicationContext()
   

2. अपने ऐप्लिकेशन में इस्तेमाल की जाने वाली सभी सुविधाओं और डिवाइस टाइप के साथ FactoryRegistry इंस्टेंस बनाएं.

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

   val registry = FactoryRegistry(
     traits = listOf(
               AirQuality,
               AreaAttendanceState,
               AreaPresenceState,
               AssistantBroadcast,
               AssistantFulfillment,
               BooleanState,
               ColorControl,
               ExtendedColorControl,
               FlowMeasurement,
               IlluminanceMeasurement,
               LevelControl,
               Notification,
               OccupancySensing,
               OnOff,
               RelativeHumidityMeasurement,
               Switch,
               TemperatureMeasurement,
               Thermostat),
     types = listOf(
               AirQualitySensorDevice,
               ColorDimmerSwitchDevice,
               ColorTemperatureLightDevice,
               ContactSensorDevice,
               DimmableLightDevice,
               DimmablePlugInUnitDevice,
               DimmerSwitchDevice,
               ExtendedColorLightDevice,
               FlowSensorDevice,
               GenericSwitchDevice,
               HumiditySensorDevice,
               LightSensorDevice,
               OccupancySensorDevice,
               OnOffLightDevice,
               OnOffLightSwitchDevice,
               OnOffPluginUnitDevice,
               OnOffSensorDevice,
               SpeakerDevice,
               TemperatureSensorDevice,
               ThermostatDevice))
   

   यहां रजिस्टर की गई हर एक खासियत और डिवाइस टाइप के लिए, इंपोर्ट स्टेटमेंट ज़रूरी हैं (Android Studio आपको इन्हें जोड़ने के लिए कहेगा).

3. Dispatchers.IO कोरुटीन कॉन्टेक्स्ट और अपने रजिस्ट्री इंस्टेंस का इस्तेमाल करके, HomeConfig को इंस्टैंशिएट करें.

   val homeConfig = HomeConfig(
           coroutineContext = Dispatchers.IO,
           factoryRegistry = registry)
   

4. आखिर में, कॉन्टेक्स्ट और HomeConfig का इस्तेमाल करके, Home का सिंगलटन इंस्टेंस बनाएं. यह एपीआई का एंट्री पॉइंट है.

   val homeManager: HomeClient = Home.getClient(context, homeConfig)
   

अमान्य सेशन से जुड़ी गड़बड़ियों से बचने के लिए, यह ज़रूरी है कि Home का सिर्फ़ एक सिंगलटन इंस्टेंस बनाया जाए. इसके लिए, इसे ऑब्जेक्ट डिक्लेरेशन में रैप करें.

उदाहरण के लिए, सैंपल ऐप्लिकेशन में ऐसा इस तरह किया जाता है:

internal object HomeClientModule {
  @Provides
  @Singleton
  fun provideHomeClient(@ApplicationContext context: Context): HomeClient {
    return Home.getClient(
      context,
      HomeConfig(
        coroutineContext = IODispatcherModule.provideIoDispatcher(),
        factoryRegistry = registry,
      ),
    )
  }
}

ऐप्लिकेशन से शुरू होने वाला Google साइन-इन

ऐसा हो सकता है कि आपको अपने ऐप्लिकेशन में, उपयोगकर्ता के Google ऑथेंटिकेशन को मैनेज करना हो. ऐसा करने से, Google की अलग-अलग सेवाओं में एक ही उपयोगकर्ता खाते का इस्तेमाल किया जा सकता है. जैसे, Google Home, Drive, Maps वगैरह.

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

इसके अलावा, इस तरीके से उपयोगकर्ताओं को खाता चुनने के लिए दो अलग-अलग स्क्रीन नहीं दिखतीं. एक स्क्रीन, ऐप्लिकेशन में साइन इन करने के लिए होती है और दूसरी Google Home के लिए.

इसके लिए, होम इंस्टेंस बनाना में बताया गया तरीका अपनाएं. हालांकि, चौथे चरण में Home.getClient(context, homeConfig) को कॉल करने के बजाय, Home.getClient(context, userAccount, homeConfig) को कॉल करें. इसमें दूसरा पैरामीटर Lazy<UserAccount> होता है. इससे HomeClientWithProvidedAccount का एक इंस्टेंस मिलता है. यह HomeClient की एक सबक्लास है. यह खास तौर पर, बताए गए Google खाते से जुड़ी होती है:

val client =
     Home.getClient(
       context = context.applicationContext,
       account =
         lazy {
         // 1. Create the Account object.
           val androidAccount = Account(userEmail,
                                        GoogleAuthUtil.GOOGLE_ACCOUNT_TYPE)
         // 2. Wrap it in UserAccount.GoogleAccount.
           UserAccount.GoogleAccount(androidAccount)
         },
       homeConfig = HomeConfig()
     )

अगर तय किया गया उपयोगकर्ता, अनुमति देने के लिए अधिकृत नहीं है, तो HomeClientWithProvidedAccount इंस्टेंस पर यहां दिए गए तरीकों को कॉल करके, उपयोगकर्ता से अनुमति मांगें:

1. registerActivityResultCallerForPermissions() को उस ActivityResultCaller के रेफ़रंस के साथ कॉल करें जिसका आपको इस्तेमाल करना है.
2. requestPermissions(). इससे GHP की सहमति वाली स्क्रीन खुल जाती है. यहां उपयोगकर्ता अपनी अनुमति दे सकता है.

UserAccount की मदद से HomeClient बनाया जा सकता है. इसके बाद, forceLaunch==true के साथ requestPermissions() को कॉल करके, सहमति वाली स्क्रीन को फिर से लॉन्च किया जा सकता है. इससे उपयोगकर्ता को अनुमतियां अपडेट करने का विकल्प मिलता है:

val client =
     Home.getClient(
       context = context.applicationContext,
       account =
         lazy {
              UserAccount.GoogleAccount(androidAccount)
         },
       homeConfig = HomeConfig()
     )

client.registerActivityResultCallerForPermissions(this)
client.requestPermissions(forceLaunch= true)

होम एपीआई की अनुमतियां मैनेज करने के बारे में ज़्यादा जानने के लिए, Permissions API देखें.

ट्रेड और डिवाइस टाइप का रजिस्ट्रेशन

FactoryRegistry क्लास की मदद से डेवलपर, अपने ऐप्लिकेशन के बाइनरी साइज़ को ऑप्टिमाइज़ कर सकते हैं. इसके लिए, उन्हें साफ़ तौर पर यह बताना होता है कि उनके ऐप्लिकेशन में कौनसी खासियतें और डिवाइस टाइप इस्तेमाल किए जाते हैं.

ध्यान दें कि अनुमतियां और फ़ैक्ट्री रजिस्ट्री अलग-अलग होती हैं. इसलिए, बिना रजिस्टर की गई ऐसी खासियतें और टाइप जो अनुमतियों का इस्तेमाल करके आपके ऐप्लिकेशन के लिए उपलब्ध हैं, लेकिन फ़ैक्ट्री रजिस्ट्री में शामिल नहीं हैं उन्हें Automation API का इस्तेमाल करके ऐक्सेस नहीं किया जा सकता. साथ ही, वे traits() या types() तरीके के कॉल में भी नहीं दिखते.