Matter के लिए एक Android ऐप्लिकेशन बनाएं

1. आपका स्वागत है

IoT स्टैंडर्ड को एक साथ लाने के मकसद से बनाया गया, Matter, स्मार्ट होम डिवाइसों को Google Home, Zigbee, ब्लूटूथ मेश, Z-Wave जैसे नेटवर्क से जोड़ता है.

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

Matter के लिए Google Home सैंपल ऐप्लिकेशन (GHSA) के लिए, Home के मोबाइल SDK टूल के एपीआई दिखाता है. इससे, उपयोगकर्ता डिवाइसों को कमीशन और शेयर कर सकते हैं. Matter के सिद्धांतों को बेहतर ढंग से समझने के लिए, सैंपल ऐप्लिकेशन का इस्तेमाल लर्निंग टूल के तौर पर भी किया जा सकता है. इसके अलावा, यह एक ऐसा टूल भी है जिसका इस्तेमाल, Matter डिवाइसों के साथ इंटरैक्शन को डीबग और समस्या हल करने के लिए किया जाता है.

आपको क्या करना होगा

इस कोडलैब में, आपको सैंपल ऐप्लिकेशन के लिए सोर्स कोड डाउनलोड करना होगा. साथ ही, डिवाइसों को कमीशन और शेयर करने के लिए, Home मोबाइल SDK टूल को इस्तेमाल करने का तरीका पता चलेगा. आप Mater repo (connectedhomeip) से भी, कमीशन और क्लस्टर लाइब्रेरी का इस्तेमाल करने के तरीके के बारे में जान सकते हैं.

ऐप्लिकेशन का नमूना डाउनलोड करने के बाद, हम Android Studio में सोर्स कोड की समीक्षा करेंगे. साथ ही, नीचे दिए गए Home Mobile SDK API लागू करेंगे:

साथ ही, आपको Matter के कॉन्सेप्ट, Matter के कपड़ों, और Matter की सुविधा वाले डिवाइसों को कंट्रोल करने के तरीके के बारे में भी ज़्यादा जानकारी मिलेगी.

आपको इनकी ज़रूरत होगी

शुरू करने से पहले, इन कदमों को पूरा करना न भूलें:

सैंपल ऐप्लिकेशन वाले डिवाइसों को कमीशन और कंट्रोल करने के लिए, आपको हब की ज़रूरत नहीं होती. जैसे, Google Nest Hub.

2. सेट अप करें

GitHub ऐप्लिकेशन के डेटा स्टोर करने की जगह के नमूने में, Mater repo (connectedhomeip) से तीसरे पक्ष की लाइब्रेरी शामिल हैं. इन नेटिव लाइब्रेरी का साइज़ 50 एमबी से ज़्यादा है. साथ ही, इन्हें Git लार्ज फ़ाइल स्टोरेज (एलएफ़एस) के इस्तेमाल की ज़रूरत होती है.

कोडलैब स्टार्टर ऐप्लिकेशन codelab ब्रांच में मौजूद है. कोडलैब सोर्स कोड के साथ काम शुरू करने के लिए, ZIP फ़ाइल डाउनलोड करें. इस ZIP में, Matter SDK टूल की नेटिव लाइब्रेरी शामिल हैं. इसके लिए, Git LFS की ज़रूरत नहीं होती:

काम करने वाले किसी सैंपल को बनाने के लिए, codelab ZIP फ़ाइल का इस्तेमाल किया जाएगा.

कोडलैब (कोड बनाना सीखना) के वर्शन

codelab ब्रांच, सैंपल ऐप्लिकेशन के 1.2.2 रिलीज़ के साथ टैग की गई है. हर चरण पर काम करते समय, अपने अपडेट की तुलना करने के लिए, इस रिलीज़ के लिए पूरा किया गया सोर्स कोड डाउनलोड करें.

अगर आपको GitHub रिपॉज़िटरी (डेटा स्टोर करने की जगह) का क्लोन बनाना है, तो सैंपल के तौर पर ऐप्लिकेशन README में दिए गए निर्देशों का पालन करें.

डिपेंडेंसी

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

  • Home मोबाइल SDK टूल.
    implementation 'com.google.android.gms:play-services-home:16.0.0'
  • Matter के लिए, SDK टूल की लाइब्रेरी.
    // Native libs
implementation fileTree(dir: "third_party/connectedhomeip/libs", include: ["*.jar", "*.so"])
  • मटीरियल डिज़ाइन. ज़्यादा जानने के लिए, MDC-103 Android: मटीरियल थीमिंग विद कलर, एलिवेशन ऐंड टाइप (Kotlin) और मटीरियल थीम बिल्डर देखें.
    implementation 'com.google.android.material:material:1.5.0'
  • Proto DataStore, जिसका इस्तेमाल ऐप्लिकेशन डेटा को बनाए रखने के लिए किया जाता है. Datastore Repositories और Serializers को java/data में स्टोर किया जाता है. इसमें डिवाइस और उपयोगकर्ता की प्राथमिकताओं के लिए स्कीमा भी शामिल होते हैं. DataStore के बारे में ज़्यादा जानने के लिए, Proto DataStore के साथ काम करना देखें.
    implementation "androidx.datastore:datastore:$dataStoreVersion"
implementation 'androidx.datastore:datastore-core:1.0.0'
implementation 'com.google.protobuf:protobuf-javalite:3.18.0'
  • डेटा बनाए रखने और डिपेंडेंसी इंजेक्शन देने के लिए, हिट.
    kapt 'com.google.dagger:hilt-compiler:2.41'
implementation 'com.google.dagger:hilt-android:2.41'

सोर्स कोड

आपके लिए यूज़र इंटरफ़ेस और ज़्यादातर फ़ंक्शन पहले ही बनाए जा चुके हैं.

इस कोडलैब के लिए, हम इन फ़ाइलों में Matter की सुविधा को जोड़ेंगे:

  • java/commissioning/AppCommissioningService: अपने ऐप्लिकेशन को डेवलपमेंट फ़ैब्रिक में कमीशन करने की अनुमति देता है
  • java/screens/HomeFragment और java/screens/HomeViewModel.kt: इसमें, होम मोबाइल SDK टूल को चालू करने का फ़ंक्शन शामिल है
  • java/screens/DeviceViewModel में, शेयर डिवाइस एपीआई कॉल शामिल हैं

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

// CODELAB: add commissioningFunction()

इससे, कोडलैब (कोड बनाना सीखना) में मौजूद सेक्शन को तुरंत ढूंढा जा सकता है.

3. Google को कमीशन

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

Matter को चालू करने के बारे में इन बातों को समझना ज़रूरी है:

  • फ़ैब्रिक की मदद से डिवाइस एक-दूसरे से जुड़ पाते हैं.
  • फ़ैब्रिक, खास क्रेडेंशियल का शेयर किया गया सेट बनाए रखते हैं.
  • भरोसेमंद सिस्टम सर्टिफ़िकेट देने, कपड़े का आईडी असाइन करने, और यूनीक नोड आईडी असाइन करने की ज़िम्मेदारी नेटवर्क की होती है. ईकोसिस्टम एक कमिश्नर की बैकएंड सेवा है. उदाहरण के लिए, Google Home नेटवर्क के लिए होम ग्राफ़.
  • डिवाइसों को एक से ज़्यादा फ़ैब्रिक (मल्टी-एडमिन फ़ीचर) के लिए कमीशन दिया जा सकता है.

किसी डिवाइस को कमीशन देने के लिए, आपको कमीशन क्लाइंट एपीआई का इस्तेमाल करना होगा. .commissionDevice() को किए गए कॉल से एक इंटेंट भेजने वाला दिखता है, जो Google Play सेवाओं में सही गतिविधि को लॉन्च करता है:

interface CommissioningClient {
  Task<IntentSender> commissionDevice(CommissioningRequest request);
}

अगले सेक्शन में, हम डिवाइस में Google फ़ैब्रिक को कमीशन करने के लिए ज़रूरी कम से कम कोड की जानकारी देंगे.

पहला चरण: गतिविधि लॉन्चर

CommissioningClient से मिले IntentSender को मैनेज करने के लिए, गतिविधि के नतीजे वाले लॉन्चर का इस्तेमाल किया जा सकता है:

private lateinit var commissioningLauncher: ActivityResultLauncher<IntentSenderRequest>

commissioningLauncher = registerForActivityResult(
    StartIntentSenderForResult()
) { result: ActivityResult ->
    if (result.resultCode == RESULT_OK) {
        Timber.d(TAG, "Commissioning succeeded.")
    } else {
        Timber.d(TAG, "Commissioning failed. " + result.resultCode)
    }
}

दूसरा चरण: कमीशन फ़ंक्शन

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

  1. कमीशन की प्रोसेस, commissionDevice() फ़ंक्शन से शुरू होती है. सबसे पहले, CommissioningRequest के बारे में बताया गया है. इस डिफ़ॉल्ट कॉन्फ़िगरेशन के साथ, डिवाइसों को सिर्फ़ Android के लोकल फ़ैब्रिक पर सेट किया जाता है.
  2. Matter, Home मोबाइल SDK टूल का एंट्री पॉइंट है. अगले कॉल में, .getCommissioningClient को this (गतिविधि) से कमीशन क्लाइंट मिलता है.
  3. .commissionDevice() ने CommissioningRequest को स्वीकार कर लिया है.
  4. आखिर में, .addOnSuccessListener को CommissioningResult प्रोसेस करने और Google Play सेवाएं (जीपीएस) कमीशन डिवाइस गतिविधि लॉन्च करने के लिए कहा जाता है.
private fun commissionDevice() {
    val request: CommissioningRequest = CommissioningRequest.builder().build()
    Matter.getCommissioningClient(this)
        .commissionDevice(request)
        .addOnSuccessListener { result ->
            commissioningLauncher.launch(IntentSenderRequest.Builder(result).build())
        }
}

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

इसके बाद, आपको डिवाइस को डेवलपमेंट फ़ैब्रिक में कमीशन करने का तरीका पता चलेगा.

कमीशन प्रोसेस के दौरान यूज़र इंटरफ़ेस की खास जानकारी पाने के लिए, Matter के लिए Google Home सैंपल ऐप्लिकेशन गाइड देखें.

4. डेवलपमेंट फ़ैब्रिक पर कमीशन

डिवाइस को एक से ज़्यादा कपड़ों पर लागू किया जा सकता है. डिवाइसों को भरोसेमंद पेयरिंग के लिए मैनेज करने के लिए, डिवाइसों में FabricTable कई FabricInfo सदस्य होते हैं. उदाहरण के लिए:

  • फ़ैब्रिक की पहचान
  • डिवाइस से कपड़े का असाइन किया गया नोड आईडी
  • वेंडर का आईडी
  • फ़ैब्रिक आईडी
  • डिवाइस ऑपरेशनल क्रेडेंशियल

एडमिन डोमेन मैनेजर (एडीएम), फ़ैब्रिक क्रेडेंशियल की जानकारी देता है. पिछले उदाहरण में, Google Play services एक ऐसा नेटवर्क है जो भरोसेमंद रूट सर्टिफ़िकेट अथॉरिटी (CA) के तौर पर काम करता है. लोकल Android फ़ैब्रिक पर डिवाइस कमीशन करते समय, हर डिवाइस में फ़ैब्रिक क्रेडेंशियल का एक ही सेट और CA का एक ही सेट शामिल होता है.

कस्टम कमीशन सर्विस

लोकल Android कपड़े पर कमीशन करने के लिए, हमने कमीशनिंग क्लाइंट एपीआई में CommissioningRequest बनाने के लिए डिफ़ॉल्ट पैरामीटर का इस्तेमाल किया:

val request: CommissioningRequest = CommissioningRequest.builder().build()

अगर आपको अपने ऐप्लिकेशन से नए डिवाइसों को कंट्रोल और मैनेज करना है, तो लोकल डेवलपमेंट फ़ैब्रिक तैयार करें और कमीशन वाले डिवाइसों पर ऑपरेशनल क्रेडेंशियल पाएं. इस स्थिति में, आपका ऐप्लिकेशन एक यूनीक और स्वतंत्र नेटवर्क बन जाता है जो डिवाइसों को सही नोड क्रेडेंशियल असाइन करता है.

आप कमीशन के अनुरोध में पसंद के मुताबिक सेवा पास करके, होम मोबाइल SDK टूल को यह जानकारी दे सकते हैं कि आपको अपने डिवाइस पर डिवाइसों को कमीशन देना है:

class CommissioningRequest {
  static CommissioningRequest.Builder builder();

  class Builder {
    Builder setCommissioningService(@Nullable ComponentName commissioningService);

    CommissioningRequest build();
  }
}

अगले चरण में, हम commissionDevice() फ़ंक्शन में बदलाव करके, कस्टम सेवा का इस्तेमाल करेंगे. हम होम फ़्रैगमेंट में भी गतिविधि लॉन्चर जोड़ेंगे और एपीआई फ़्लो को मैनेज करने के लिए, LiveData ऑब्जेक्ट का इस्तेमाल करेंगे.

पहला चरण: GPS गतिविधि लॉन्चर बनाना

सबसे पहले, आइए कमीशन क्लाइंट से IntentSender को हैंडल करने के लिए एक गतिविधि लॉन्चर बनाएं.

  1. HomeFragment को java/screens/home/ फ़ोल्डर में खोलें.
  2. // CODELAB: commissionDeviceLauncher declaration टिप्पणी को यहां दिए गए एलान से बदलें:
    // The ActivityResult launcher that launches the "commissionDevice" activity in Google Play
// Services.
private lateinit var commissionDeviceLauncher: ActivityResultLauncher<IntentSenderRequest>
  3. कमीशन की गतिविधि के नतीजे को रजिस्टर करने और उसे मैनेज करने के लिए, // CODELAB: commissionDeviceLauncher definition टिप्पणी को इस कोड से बदलें:
    commissionDeviceLauncher =
    registerForActivityResult(ActivityResultContracts.StartIntentSenderForResult()) { result ->
      // Commission Device Step 5.
      // The Commission Device activity in GPS has completed.
      val resultCode = result.resultCode
      if (resultCode == Activity.RESULT_OK) {
        Timber.d("CommissionDevice: Success")
        // We now need to capture the device information for the app's fabric.
        // Once this completes, a call is made to the viewModel to persist the information
        // about that device in the app.
        showNewDeviceAlertDialog(result)
      } else {
        viewModel.commissionDeviceFailed(resultCode)
      }
    }    ```

दूसरा चरण: LiveData ऑब्जेक्ट बनाना

.commissionDevice() एपीआई के सक्सेस कॉलबैक होने की वजह से, Google Play services में कमीशन डिवाइस की गतिविधि लॉन्च करने के लिए IntentSender का इस्तेमाल होता है. HomeViewModel में हम इस एपीआई कॉल के नतीजे की रिपोर्ट करने के लिए, दो LiveData ऑब्जेक्ट बनाएंगे:

  • commissionDeviceStatus, TaskStatus को ट्रैक करने के लिए.
  • .commissionDevice() कॉल का नतीजा मैनेज करने के लिए commissionDeviceIntentSender. यह LiveData ऑब्जेक्ट ActivityLauncher को अभी लॉन्च करेगा और उपयोगकर्ता को जीपीएस कमीशन डिवाइस गतिविधि दिखाएगा.
  1. private fun setupObservers() की // CODELAB: commissionDeviceStatus टिप्पणी को इस ऑब्ज़र्वर से बदलें:
    // The current status of the share device action.
viewModel.commissionDeviceStatus.observe(viewLifecycleOwner) { status ->
  Timber.d("commissionDeviceStatus.observe: status [${status}]")
}
  2. इसके बाद, // CODELAB: commissionDeviceIntentSender टिप्पणी को इन ऑब्ज़र्वर से बदलें:
    viewModel.commissionDeviceIntentSender.observe(viewLifecycleOwner) { sender ->
  Timber.d(
      "commissionDeviceIntentSender.observe is called with [${intentSenderToString(sender)}]")
  if (sender != null) {
    // Commission Device Step 4: Launch the activity described in the IntentSender that
    // was returned in Step 3 (where the viewModel calls the GPS API to commission
    // the device).
    Timber.d("CommissionDevice: Launch GPS activity to commission device")
    commissionDeviceLauncher.launch(IntentSenderRequest.Builder(sender).build())
    viewModel.consumeCommissionDeviceIntentSender()
  }
}

तीसरा चरण: एपीआई को कॉल करना

हमने एपीआई फ़्लो को मैनेज करने के लिए कोड लिख लिया है. इसलिए, अब एपीआई को कॉल करें और अपनी पसंद के मुताबिक किसी सेवा को पास करें. अगले चरण में, हम इस जानकारी को अपने LiveData ऑब्जेक्ट में पोस्ट करेंगे.

  1. HomeViewModel.kt को java/screens/home/ फ़ोल्डर में खोलें.
  2. // CODELAB: commissionDevice टिप्पणी को नीचे दिए गए commissionDeviceRequest से बदलें. setCommissioningService, AppCommissioningService को CommissioningService इंस्टेंस से बाइंड करता है. इसे कॉलबैक फ़ंक्शन में दिखाया जाता है. पसंद के मुताबिक सेवा देने की किसी प्रक्रिया को पूरा करने पर, Home मोबाइल SDK टूल पहले Google फ़ैब्रिक पर कमीशन देता है. इसके बाद, ऑनबोर्डिंग पेलोड को वापस AppCommissioningService में भेजता है.
    fun commissionDevice(context: Context) {
  _commissionDeviceStatus.postValue(TaskStatus.InProgress)

  val commissionDeviceRequest =
      CommissioningRequest.builder()
          .setCommissioningService(ComponentName(context, AppCommissioningService::class.java))
          .build()
  3. .getCommissioningClient() पर कॉल करें. इसके बाद, .commissionDevice() पर कॉल करें.
    Matter.getCommissioningClient(context)
    .commissionDevice(commissionDeviceRequest)

हमारा commissionDevice फ़ंक्शन पूरा करने के लिए, addOnSuccessListener और addOnFailureListener जोड़कर LiveData ऑब्जेक्ट में पोस्ट करें:

      .addOnSuccessListener { result ->
        // Communication with fragment is via livedata
        _commissionDeviceIntentSender.postValue(result)
      }
      .addOnFailureListener { error ->
        Timber.e(error)
        _commissionDeviceStatus.postValue(
          TaskStatus.Failed("Failed to to get the IntentSender.", error)
      }
}

भेजने वाले का इस्तेमाल करने के बाद, consumeCommissionDeviceIntentSender() को कॉल किया जाना चाहिए, ताकि कॉन्फ़िगरेशन में बदलाव होने के बाद भेजने वाले को फिर से न मिले.

  /**
   * Consumes the value in [_commissionDeviceIntentSender] and sets it back to null. Needs to be
   * called to avoid re-processing the IntentSender after a configuration change (where the LiveData
   * is re-posted).
   */
  fun consumeCommissionDeviceIntentSender() {
    _commissionDeviceIntentSender.postValue(null)
  }

5. कमीशन सेवा बनाएं

commissionDevice() फ़ंक्शन में, हमने कमीशन क्लाइंट के एपीआई से कमीशन सर्विस पाने का अनुरोध किया है. इस फ़्लो में, कमीशन देने वाला क्लाइंट एपीआई पहले लोकल Android फ़ैब्रिक पर कमीशन करता है, फिर एक कॉलबैक दिखाता है, जिसमें कमीशन अनुरोध मेटाडेटा ऑब्जेक्ट शामिल होता है:

public interface CommissioningService {
interface Callback {
    void onCommissioningRequested(CommissioningRequestMetadata metadata);
  }
}

अब, हमें CommissioningService.Callback को इनहेरिट करना होगा और हमारे सैंपल ऐप्लिकेशन के लिए डिवाइसों को कमीशन करने के लिए ज़रूरी फ़ंक्शन उपलब्ध कराने होंगे. यहां बेसिक कमीशन सर्विस को लागू करने का एक उदाहरण दिया गया है:

class MatterCommissioningService : Service(), CommissioningService.Callback {
   private val commissioningServiceDelegate =
     CommissioningService.Builder(this)
       .setCallback(this)
       .build()

   override fun onBind(intent: Intent) = commissioningServiceDelegate.asBinder()

   override fun onCommissioningRequested(metadata: CommissioningRequestMetadata) {
     // perform commissioning

     commissioningServiceDelegate
       .sendCommissioningComplete(CommissioningCompleteMetadata.builder().build())
   }
 }

चरण 1: कस्टम AppCommissioningService के बारे में जानें

शुरू करने में आपकी मदद करने के लिए, हमने पहले से ही अपनी कस्टम कमीशन सेवा के लिए बुनियादी क्लास स्ट्रक्चर तय कर लिया है. यहां सेवा की सुविधाओं के बारे में खास जानकारी दी गई है. इसके साथ-साथ, java/commissioning में AppCommissioningService खोलें.

हमने Home Mobile SDK API के लिए, ये इंपोर्ट जोड़े हैं:

import com.google.android.gms.home.matter.commissioning.CommissioningCompleteMetadata
import com.google.android.gms.home.matter.commissioning.CommissioningRequestMetadata
import com.google.android.gms.home.matter.commissioning.CommissioningService

AppCommissioningService में Mater repo (connectedhomeip) की लाइब्रेरी भी शामिल हैं:

import com.google.home_sample_app_for_matter.chip.ChipClient

आखिर में, इस सेवा में इंपोर्ट के तौर पर हिट और Kotlin कोरूटीन के साथ काम करना शामिल है.

इसके बाद, हम कंस्ट्रक्टर बनाते हैं और commissioningServiceDelegate को मिलाकर कुछ चीज़ें सेट अप करते हैं. इनका इस्तेमाल हम Google Play सेवाओं को यह बताने के लिए करेंगे कि कमीशन पूरा होने के बाद क्या होगा.

private lateinit var commissioningServiceDelegate: CommissioningService
...
commissioningServiceDelegate = CommissioningService.Builder(this).setCallback(this).build()

अब कमीशन फ़ंक्शन जोड़ें.

दूसरा चरण: onCommissioningRequested को बदलना

ऐप्लिकेशन को डेवलप करने वाले कपड़े को कमीशन देने के लिए, नीचे दिया गया तरीका अपनाएं:

  1. java/commissioning में AppCommissioningService खोलें.
  2. onCommissioningRequested() फ़ंक्शन का पता लगाएं. हमने CommissioningRequestMetadata पर प्रिंट करने के लिए एक लॉग मैसेज दिया है. serviceScope कोरूटीन शुरू करने और deviceId पाने के लिए, // CODELAB: onCommissioningRequested() टिप्पणी बदलें.
    // Perform commissioning on custom fabric for the sample app.
serviceScope.launch {
  val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
  3. लाइसेंसिंग की प्रक्रिया पूरी करें. इस चरण के लिए, हम कमीशन अनुरोध मेटाडेटा ऑब्जेक्ट में दी गई डिवाइस की जानकारी पास कर सकते हैं. ChipClient, मेटाडेटा की इस जानकारी का इस्तेमाल, Matter ऐप्लिकेशन और आपके डिवाइस के GHSA के बीच एक सुरक्षित चैनल बनाने के लिए करता है.
    Timber.d("Commissioning: App fabric -> ChipClient.establishPaseConnection(): deviceId [${deviceId}]")
chipClient.awaitEstablishPaseConnection(
    deviceId,
    metadata.networkLocation.ipAddress.hostAddress!!,
    metadata.networkLocation.port,
    metadata.passcode)
Timber.d("Commissioning: App fabric -> ChipClient.commissionDevice(): deviceId [${deviceId}]")
chipClient.awaitCommissionDevice(deviceId, null)
  4. Google Play services को यह बताने के लिए कि कमीशन की प्रक्रिया पूरी हो गई है, commissioningServiceDelegate का इस्तेमाल करें. .sendCommissioningComplete() कमीशन को पूरा करने से जुड़ा मेटाडेटा पास करें.
      Timber.d("Commissioning: Calling commissioningServiceDelegate.sendCommissioningComplete()")
  commissioningServiceDelegate
      .sendCommissioningComplete(
          CommissioningCompleteMetadata.builder().setToken(deviceId.toString()).build())
      .addOnSuccessListener {
          Timber.d("Commissioning: OnSuccess for commissioningServiceDelegate.sendCommissioningComplete()")
      }
      .addOnFailureListener { ex -> 
        Timber.e(ex, "Commissioning: Failed to send commissioning complete.", ex)
      }
}

ऐप्लिकेशन चलाएं

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

जब कमीशन पूरा होता है, तो आपका डिवाइस अब दो तरह के कपड़ों में काम करता है: लोकल Android कपड़े और आपका लोकल डेवलपमेंट फ़ैब्रिक. हर कपड़े के लिए उसका अपना क्रेडेंशियल और 64-बिट का सबसे खास फ़ैब्रिक आईडी होता है.

6. कंट्रोल डिवाइस

डेवलपमेंट फ़ैब्रिक पर कमीशन करके आप Matter repo (connectedhomeip) की लाइब्रेरी का उपयोग करके नमूना ऐप्स से डिवाइसों को नियंत्रित कर सकते हैं.

हमने क्लस्टर को ऐक्सेस करने और निर्देशों को आसानी से भेजने के लिए, कुछ हेल्पर क्लास बनाई हैं. ज़्यादा जानने के लिए, java/clusters में ClustersHelper खोलें. यह सिंगलटन हेल्पर, डिवाइस की जानकारी ऐक्सेस करने के लिए इन लाइब्रेरी को इंपोर्ट करता है:

import chip.devicecontroller.ChipClusters
import chip.devicecontroller.ChipStructs

हम इस क्लास का इस्तेमाल, किसी डिवाइस पर क्लस्टर को चालू/बंद करने के लिए कर सकते हैं, फिर .toggle पर कॉल कर सकते हैं:

suspend fun toggleDeviceStateOnOffCluster(deviceId: Long, endpoint: Int) {
  Timber.d("toggleDeviceStateOnOffCluster())")
  val connectedDevicePtr =
      try {
        chipClient.getConnectedDevicePointer(deviceId)
      } catch (e: IllegalStateException) {
        Timber.e("Can't get connectedDevicePointer.")
        return
      }
  return suspendCoroutine { continuation ->
    getOnOffClusterForDevice(connectedDevicePtr, endpoint)
        .toggle(
            object : ChipClusters.DefaultClusterCallback {
              override fun onSuccess() {
                continuation.resume(Unit)
              }
              override fun onError(ex: Exception) {
                Timber.e("readOnOffAttribute command failure: $ex")
                continuation.resumeWithException(ex)
              }
            })
  }
}

किसी डिवाइस को टॉगल करें

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

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

डिवाइस पर, पैकेट की पुष्टि की जाती है, उन्हें डिक्रिप्ट किया जाता है. इसके बाद, उन्हें कॉलबैक के साथ भेजा जाता है. कॉलबैक फ़ंक्शन में, EndpointId, ClusterId, और AttributeId शामिल हैं, जिन्हें attributePath से ऐक्सेस किया जा सकता है. उदाहरण के लिए, इस कोड को Matter डिवाइस पर लागू किया जा सकता है:

void MatterPostAttributeChangeCallback(const chip::app::ConcreteAttributePath & attributePath, uint8_t mask, uint8_t type,
                                       uint16_t size, uint8_t * value)
{
    // handle callback
    ClusterId clusterId     = attributePath.mClusterId;
    AttributeId attributeId = attributePath.mAttributeId;
}

अगले चरण में, डिवाइस को टॉगल करने के लिए, Matter के SDK टूल और ClustersHelper का इस्तेमाल किया जाएगा.

  1. java/screens/device में DeviceViewModel पर जाएं.
  2. updateDeviceStateOn फ़ंक्शन का पता लगाएं.
  3. clustersHelper को कॉल करने के लिए, // CODELAB: toggle टिप्पणी को कोड से बदलें. इसके बाद, डिवाइस की 'डेटा स्टोर करने की जगह' को अपडेट करें:
    Timber.d("Handling real device")
    try {
      clustersHelper.setOnOffDeviceStateOnOffCluster(deviceUiModel.device.deviceId, isOn, 1)
      devicesStateRepository.updateDeviceState(deviceUiModel.device.deviceId, true, isOn)
    } catch (e: Throwable) {
      Timber.e("Failed setting on/off state")
    }

इस फ़ंक्शन को DeviceFragment से कॉल किया गया है:

// Change the on/off state of the device
binding.onoffSwitch.setOnClickListener {
  val isOn = binding.onoffSwitch.isChecked
  viewModel.updateDeviceStateOn(selectedDeviceViewModel.selectedDeviceLiveData.value!!, isOn)
}

ऐप्लिकेशन चलाएं

अपडेट लोड करने के लिए, ऐप्लिकेशन चलाएं. होम स्क्रीन पर, अपने डिवाइस को टॉगल करके चालू और बंद करें.

7. अन्य नेटवर्क से डिवाइसों को शेयर करना

शेयर करने के लिए, मल्टी-एडमिन फ़्लो का मतलब ऐसे डिवाइसों से है जो शेयर करने की सुविधा के हिसाब से काम करते हैं.

पिछले चरणों में, हमें पता चला है कि Home Mobile SDK, लोकल Android फ़ैब्रिक पर डिवाइसों को कमीशन देना और सैंपल ऐप्लिकेशन के लिए डेवलपमेंट फ़ैब्रिक में रखना मुमकिन बनाता है. यह मल्टी-एडमिन फ़्लो का एक उदाहरण है, जहां डिवाइसों को एक से ज़्यादा फ़ैब्रिक में कमीशन किया जा सकता है.

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

Home Mobile SDK टूल से ShareDeviceRequest API में यह सुविधा मिलती है. इसकी मदद से:

  1. डिवाइसों के लिए, अस्थायी तौर पर कमीशन विंडो खोलें.
  2. अपने डिवाइसों की स्थिति बदलें, ताकि इन्हें किसी अन्य कपड़े में कमीशन किया जा सके.
  3. अन्य ऐप्लिकेशन और नेटवर्क से अपने डिवाइसों को कंट्रोल करें.

अगले चरणों में, आपको डिवाइसों को शेयर करने के लिए, Home मोबाइल SDK टूल का इस्तेमाल करना होगा.

पहला चरण: GPS गतिविधि लॉन्चर बनाना

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

  1. DeviceFragment को java/screens/device/ फ़ोल्डर में खोलें.
  2. .shareDevice() गतिविधि के नतीजे को रजिस्टर करने और उसे मैनेज करने के लिए, // CODELAB: shareDeviceLauncher definition टिप्पणी को इस कोड से बदलें:
    shareDeviceLauncher =
    registerForActivityResult(ActivityResultContracts.StartIntentSenderForResult()) { result ->
      // Share Device Step 5.
      // The Share Device activity in GPS (step 4) has completed.
      val resultCode = result.resultCode
      if (resultCode == RESULT_OK) {
        Timber.d("ShareDevice: Success")
        viewModel.shareDeviceSucceeded(selectedDeviceViewModel.selectedDeviceLiveData.value!!)
      } else {
        viewModel.shareDeviceFailed(
            selectedDeviceViewModel.selectedDeviceLiveData.value!!, resultCode)
      }
    }

दूसरा चरण: LiveData ऑब्जेक्ट की समीक्षा करना

.shareDevice() एपीआई के सबसे पुराने कॉलबैक में, IntentSender का इस्तेमाल 'Google Play सेवाएं' में 'डिवाइस शेयर करने की गतिविधि' को लॉन्च करने के लिए किया जाता है. DeviceViewModel में हमने इस एपीआई कॉल के नतीजे पर रिपोर्ट करने के लिए, दो LiveData ऑब्जेक्ट बनाए हैं:

  • _shareDeviceStatus, TaskStatus को ट्रैक करने के लिए.
    // The current status of the share device action.
viewModel.shareDeviceStatus.observe(viewLifecycleOwner) { status ->
  val isButtonEnabled = status !is InProgress
  updateShareDeviceButton(isButtonEnabled)
  if (status is TaskStatus.Failed) {
    showAlertDialog(errorAlertDialog, status.message, status.cause!!.toString())
  }
}
  • .sharedevice() कॉल का नतीजा मैनेज करने के लिए _shareDeviceIntentSender.
    viewModel.shareDeviceIntentSender.observe(viewLifecycleOwner) { sender ->
  Timber.d("shareDeviceIntentSender.observe is called with [${intentSenderToString(sender)}]")
  if (sender != null) {
    // Share Device Step 4: Launch the activity described in the IntentSender that
    // was returned in Step 3 (where the viewModel calls the GPS API to commission
    // the device).
    Timber.d("ShareDevice: Launch GPS activity to share device")
    shareDeviceLauncher.launch(IntentSenderRequest.Builder(sender).build())
    viewModel.consumeShareDeviceIntentSender()
  }
}

अगले चरणों में, हम अपने .shareDevice() एपीआई कॉल में इन LiveData ऑब्जेक्ट का इस्तेमाल करेंगे.

तीसरा चरण: एपीआई को कॉल करना

अब शेयर डिवाइस का इस्तेमाल शुरू करने का समय आ गया है.

  1. DeviceViewModel.kt को java/screens/device/ फ़ोल्डर में खोलें.
  2. shareDevice() फ़ंक्शन का पता लगाएं. // CODELAB: shareDevice टिप्पणी को ShareDeviceRequest से बदलें. DeviceDescriptor, डिवाइस के बारे में खास जानकारी देता है. जैसे, डिवाइस का वेंडर आईडी, प्रॉडक्ट आईडी, और डिवाइस टाइप. इस उदाहरण में, हमने वैल्यू को हार्ड कोड किया है.
      Timber.d("ShareDevice: Setting up the IntentSender")
  val shareDeviceRequest =
      ShareDeviceRequest.builder()
          .setDeviceDescriptor(DeviceDescriptor.builder().build())
          .setDeviceName("temp device name")
  3. कमीशन विंडो और पैरामीटर सेट करें. इस समय, डिवाइस पर अस्थायी तौर पर कमीशन विंडो खुल चुकी है.
              .setCommissioningWindow(
              CommissioningWindow.builder()
                  .setDiscriminator(Discriminator.forLongValue(DISCRIMINATOR))
                  .setPasscode(SETUP_PIN_CODE)
                  .setWindowOpenMillis(SystemClock.elapsedRealtime())
                  .setDurationSeconds(OPEN_COMMISSIONING_WINDOW_DURATION_SECONDS.toLong())
                  .build())
          .build()
  4. .getCommissioningClient() को सिर्फ़ इस बार कॉल करें, इसके लिए .shareDevice() एपीआई का इस्तेमाल करें. commissioningClient.shareDevice() एपीआई के सक्सेस कॉलबैक होने पर, इंटेंट भेजने वाले का इस्तेमाल किया जाता है. इसका इस्तेमाल Google Play सेवाओं में 'डिवाइस शेयर करने की गतिविधि' को लॉन्च करने के लिए किया जाता है.
    Matter.getCommissioningClient(activity)
    .shareDevice(shareDeviceRequest)
  5. हमारा shareDevice फ़ंक्शन पूरा करने के लिए, addOnSuccessListener और addOnFailureListener जोड़कर LiveData ऑब्जेक्ट में पोस्ट करें:
          .addOnSuccessListener { result ->
        Timber.d("ShareDevice: Success getting the IntentSender: result [${result}]")
        // Communication with fragment is via livedata
        _backgroundWorkAlertDialogAction.postValue(BackgroundWorkAlertDialogAction.Hide)
        _shareDeviceIntentSender.postValue(result)
      }
      .addOnFailureListener { error ->
        Timber.e(error)
        _backgroundWorkAlertDialogAction.postValue(BackgroundWorkAlertDialogAction.Hide)
        _shareDeviceStatus.postValue(
            TaskStatus.Failed("Setting up the IntentSender failed", error))
      }

भेजने वाले का इस्तेमाल करने के बाद, consumeShareDeviceIntentSender को कॉल किया जाना चाहिए, ताकि कॉन्फ़िगरेशन में बदलाव होने के बाद भेजने वाले को फिर से न मिले.

  /**
   * Consumes the value in [_shareDeviceIntentSender] and sets it back to null. Needs to be called
   * to avoid re-processing an IntentSender after a configuration change where the LiveData is
   * re-posted.
   */
  fun consumeShareDeviceIntentSender() {
    _shareDeviceIntentSender.postValue(null)
  }

ऐप्लिकेशन चलाएं

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

अपने Android डिवाइस पर टारगेट कमिश्नर का इंस्टॉल होने के बाद, पुष्टि करें कि आपके Matter डिवाइस को शेयर किया जा सकता है. टारगेट कमीशन ऐप्लिकेशन को GHSAFM-TC लेबल दिया गया है.

आपके डिवाइस अब तीन फ़ैब्रिक में हिस्सा ले सकते हैं:

  1. स्थानीय Android कपड़ा.
  2. डेवलपमेंट फ़ैब्रिक (यह ऐप्लिकेशन).
  3. यह तीसरा कपड़े है जिसके साथ आपने डिवाइस को अभी शेयर किया है.

8. अगले चरण

बधाई हो

बधाई हो, आपने यह कोडलैब (कोड बनाना सीखना) पूरा कर लिया है और Home Mobile SDK का इस्तेमाल करके, डिवाइसों को कमीशन और शेयर करने का तरीका जान लिया है.

अगर आपको ऐप्लिकेशन के नमूने को इस्तेमाल करने में कोई समस्या आ रही है, तो अपने एनवायरमेंट की पुष्टि करने के लिए यह तरीका अपनाएं:

अगर आपके पास सैंपल ऐप्लिकेशन का इस्तेमाल करने या कोड की गड़बड़ी का पता लगाने से जुड़े सवाल हैं, तो GitHub डेटा स्टोर करने की जगह में समस्या को ट्रैक करने वाले टूल में समस्याओं को सबमिट करें:

तकनीकी सवालों के बारे में Google से आधिकारिक सलाह पाने के लिए, स्मार्ट होम डेवलपर फ़ोरम का इस्तेमाल करें:

समुदाय से तकनीकी सहायता पाने के लिए, स्टैक ओवरफ़्लो पर google-smart-home टैग का उपयोग करें: