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

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

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

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

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

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

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

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

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

आपको किन चीज़ों की ज़रूरत होगी

शुरू करने से पहले, इन चरणों को पूरा करें:

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

2. सेट अप करें

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

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

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

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

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

डिपेंडेंसी

हम आपको उस सोर्स कोड के बारे में बताएंगे जो डिवाइसों को शेयर करने और उन्हें कमीशन करने के लिए ज़रूरी है. हालांकि, शुरुआत करने से पहले आपको इन डिपेंडेंसी के बारे में जानकारी होनी चाहिए. इससे आपको मदद मिल सकती है. ध्यान दें कि इन डिपेंडेंसी का एलान libs.versions.toml फ़ाइल में किया जाता है और इनके इस्तेमाल के बारे में फ़ाइल build.gradle.kts में बताया गया है

सोर्स कोड

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

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

  • java/com/google/homesampleapp/commissioning/AppCommissioningService: इससे आपको डेवलपमेंट फ़ैब्रिक के लिए डिवाइसों को कमीशन देने की सुविधा मिलती है
  • java/com/google/homesampleapp/screens/home/HomeScreen और java/com/google/homesampleapp/screens/home/HomeViewModel.kt: इसमें Home Mobile SDK टूल को कमीशन करने की सुविधा शामिल है
  • java/com/google/homesampleapp/screens/device/DeviceScreen और java/com/google/homesampleapp/screens/device/DeviceViewModel: इसमें Share Device API कॉल शामिल हैं

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

// CODELAB: add commissioningFunction()

इसकी मदद से, कोडलैब में इससे जुड़े सेक्शन का तुरंत पता लगाया जा सकता है.

3. Google को कमीशन

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

मैटर कमीशन के बारे में इन सिद्धांतों को समझना ज़रूरी है:

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

किसी डिवाइस को चालू करने के लिए, आपको CommissioningClient API का इस्तेमाल करना होगा. .commissionDevice() को किए जाने वाले कॉल से IntentSender मिलता है, जिससे Google Play सेवाओं में सही गतिविधि लॉन्च होती है:

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

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

पहला चरण: ऐक्टिविटी लॉन्चर

CommissioningClient से IntentSender को मैनेज करने के लिए, ActivityनतीजेLauncher का इस्तेमाल किया जा सकता है:

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

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

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

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

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

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

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

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

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

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

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

पसंद के मुताबिक कमीशन से जुड़ी सेवाएं

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

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

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

आपके पास Home Mobile SDK को यह बताने का विकल्प होता है कि आपको अपने कपड़े के लिए डिवाइस कमीशन देने हैं. इसके लिए, आपको CommissioningRequest पर एक कस्टम सेवा देनी है:

class CommissioningRequest {
  static CommissioningRequest.Builder builder();

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

    CommissioningRequest build();
  }
}

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

पहला चरण: जीपीएस ऐक्टिविटी लॉन्चर बनाना

सबसे पहले, CommissioningClient API से IntentSender को मैनेज करने के लिए, ऐक्टिविटी लॉन्चर बनाते हैं.

  1. HomeScreen को java/com/google/homesampleapp/screens/home/ फ़ोल्डर में खोलें.
  2. कमीशन की गतिविधि से जुड़े नतीजे को रजिस्टर और मैनेज करने के लिए, // CODELAB: commissionDeviceLauncher definition टिप्पणी की जगह यह कोड डालें:
    val commissionDeviceLauncher =
  rememberLauncherForActivityResult(
    contract = ActivityResultContracts.StartIntentSenderForResult()
  ) { result ->
    // Commission Device Step 5.
    // The Commission Device activity in GPS (step 4) has completed.
    val resultCode = result.resultCode
    if (resultCode == Activity.RESULT_OK) {
      Timber.d("CommissionDevice: Success")
      // We let the ViewModel know that GPS commissioning has completed successfully.
      // The ViewModel knows that we still need to capture the device name and will\
      // update UI state to trigger the NewDeviceAlertDialog.
      homeViewModel.gpsCommissioningDeviceSucceeded(result)
    } else {
      homeViewModel.commissionDeviceFailed(resultCode)
    }
  }

दूसरा चरण: डिवाइस पर कमीशन की कार्रवाई को ट्रिगर करना

इस चरण में, उपयोगकर्ता "कमीशन डिवाइस" को ट्रिगर करता है "+" पर क्लिक करके कार्रवाई सबसे नीचे दाईं ओर दिए गए बटन पर क्लिक करें. इसके बाद, commissionDevice() पर कॉल किया जाता है.

val onCommissionDevice = {
  ...
  commissionDevice(activity!!.applicationContext, commissionDeviceLauncher)
}

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

  1. java/com/google/homesampleapp/screens/home फ़ोल्डर में अब भी HomeScreen.kt में है.
  2. // CODELAB: commissionDevice टिप्पणी को इस commissionDeviceRequest से बदलें. setCommissioningService, AppCommissioningService को CommissioningService इंस्टेंस से बाइंड करता है. यह कॉलबैक फ़ंक्शन में दिया जाता है. अगर आपने अपनी पसंद के मुताबिक कोई सेवा पास की है, तो Home Mobile SDK टूल सबसे पहले डिवाइसों को Android के लोकल फै़ब्रिक के लिए कमीशन देगा. इसके बाद, ऑनबोर्डिंग पेलोड को AppCommissioningService पर वापस भेजेगा.
    val commissionDeviceRequest =
    CommissioningRequest.builder()
        .setCommissioningService(ComponentName(
            context, AppCommissioningService::class.java))
        .build()
  3. .getCommissioningClient() पर कॉल करें. इसके बाद, .commissionDevice() पर कॉल करें.
Matter.getCommissioningClient(context)
    .commissionDevice(commissionDeviceRequest)

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

    .addOnSuccessListener { result ->
      commissionDeviceLauncher.launch(IntentSenderRequest.Builder(result).build())
    }
    .addOnFailureListener { error ->
      Timber.e(error)
    }

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

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

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

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

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())
   }
 }

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

शुरू करने में आपकी मदद करने के लिए, हमने अपनी कस्टम CommissioningService की बुनियादी क्लास का स्ट्रक्चर पहले ही तय कर दिया है. यहां सेवा की सुविधाओं के बारे में खास जानकारी दी गई है. फ़ॉलो करने के लिए, 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 में Matter रेपो (connectedhomeip) की लाइब्रेरी भी शामिल हैं:

import com.google.homesampleapp.chip.ChipClient

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

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

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

अब कमीशन देने वाले फ़ंक्शन जोड़ने का समय आ गया है.

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

ऐप्लिकेशन के डेवलपमेंट फ़ैब्रिक के हिसाब से डिवाइसों को चालू करने के लिए, इन चरणों को पूरा करें:

  1. AppCommissioningService को java/commissioning में खोलें.
  2. onCommissioningRequested() फ़ंक्शन ढूंढें. हमने एक लॉग मैसेज उपलब्ध कराया है, जो CommissioningRequestMetadata को प्रिंट करता है. serviceScope कोरूटीन शुरू करने और deviceId पाने के लिए, // CODELAB: onCommissioningRequested() टिप्पणी को बदलें.
    // Perform commissioning on custom fabric for the sample app.
serviceScope.launch {
  val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
  3. कमीशन दें. इस चरण में, हम CommissioningRequestMetadata ऑब्जेक्ट में दिखाई गई, डिवाइस की जानकारी पास कर सकते हैं. ChipClient, मेटाडेटा की इस जानकारी का इस्तेमाल, Matter ऐप्लिकेशन और आपके डिवाइस के लिए GHSA के बीच सुरक्षित चैनल बनाने के लिए करता है.
    try {
  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)
} catch (e: Exception) {
  Timber.e(e, "onCommissioningRequested() failed")
  // No way to determine whether this was ATTESTATION_FAILED or DEVICE_UNREACHABLE.
  commissioningServiceDelegate
      .sendCommissioningError(CommissioningError.OTHER)
      .addOnSuccessListener {
        Timber.d(
            "Commissioning: commissioningServiceDelegate.sendCommissioningError() succeeded")
      }
      .addOnFailureListener { e2 ->
        Timber.e(e2, "Commissioning: commissioningServiceDelegate.sendCommissioningError() failed")
      }
  return@launch
}
  4. Google Play Services को यह बताने के लिए कि कमीशन की प्रोसेस पूरी हो गई है, commissioningServiceDelegate का इस्तेमाल करें. .sendCommissioningComplete() में, CommissioningCompleteMetadata को पास करें.
    commissioningServiceDelegate
    .sendCommissioningComplete(
        CommissioningCompleteMetadata.builder().setToken(deviceId.toString()).build())
    .addOnSuccessListener {
      Timber.d("Commissioning: commissioningServiceDelegate.sendCommissioningComplete() succeeded")
    }
    .addOnFailureListener { e ->
      Timber.e(e, "Commissioning: commissioningServiceDelegate.sendCommissioningComplete() failed")
    }
}

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

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

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

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

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

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

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)
              }
            })
  }
}

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

डिवाइस को कमीशन करने के बाद, CommissioningResult पर लौटाए गए पेलोड को 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")
    }

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

// On/Off Switch click.
val onOnOffClick: (value: Boolean) -> Unit = { value ->
  deviceViewModel.updateDeviceStateOn(deviceUiModel!!, value)
}

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

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

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

Matter की जानकारी में, किसी डिवाइस को शेयर करने को एक से ज़्यादा एडमिन वाला फ़्लो कहा जाता है.

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

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

Home मोबाइल SDK टूल, ShareDeviceRequest API में यह सुविधा उपलब्ध कराता है. इसकी मदद से, ये काम किए जा सकते हैं:

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

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

पहला चरण: जीपीएस ऐक्टिविटी लॉन्चर बनाना

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

  1. DeviceScreen को java/com/google/homesampleapp/screens/device/ फ़ोल्डर में खोलें.
  2. .shareDevice() गतिविधि के नतीजे को रजिस्टर और मैनेज करने के लिए, // CODELAB: shareDeviceLauncher definition टिप्पणी की जगह यह कोड डालें:
    val shareDeviceLauncher = rememberLauncherForActivityResult(
  contract = ActivityResultContracts.StartIntentSenderForResult()
) { result ->
  // Commission Device Step 5.
  // The Share Device activity in GPS (step 4) has completed.
  val resultCode = result.resultCode
  if (resultCode == Activity.RESULT_OK) {
    deviceViewModel.shareDeviceSucceeded()
  } else {
    deviceViewModel.shareDeviceFailed(resultCode)
  }
}

दूसरा चरण: 'डिवाइस शेयर करें' कार्रवाई को ट्रिगर करना

इसमें उपयोगकर्ता, "डिवाइस शेयर करें" को ट्रिगर करता है तो "शेयर करें" बटन पर क्लिक करें और बटन पर क्लिक करें. इसके बाद, deviceViewModel पर कॉल किया जाता है, ताकि डिवाइस शेयर करने की सुविधा इस्तेमाल करने के लिए, पेयरिंग विंडो को खोला जा सके.

// Share Device button click.
val onShareDevice: () -> Unit = remember {
 {
   deviceViewModel.openPairingWindow(deviceUiModel!!.device.deviceId)
 }
}

दूसरे डिवाइस से डेटा जोड़ने वाली विंडो को खोलने के बाद, deviceViewModel इस जानकारी को यूज़र इंटरफ़ेस (यूआई) में भेजता है. ViewModel और यूज़र इंटरफ़ेस (यूआई) के बीच कम्यूनिकेशन StateFlow ऑब्जेक्ट की मदद से किया जाता है.

// Communicate to the UI that the pairing window is open.
// UI can then launch the GPS activity for device sharing.
_pairingWindowOpenForDeviceSharing.value = true

StateFlow ऑब्जेक्ट में बदलाव देखने पर, DeviceScreen यह कॉल करता है:

shareDevice(activity!!.applicationContext, shareDeviceLauncher, deviceViewModel)

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

अब डिवाइस शेयर करने का टास्क शुरू किया जा सकता है.

  1. DeviceScreen.kt को java/com/google/homesampleapp/screens/device/ फ़ोल्डर में खोलें.
  2. shareDevice() फ़ंक्शन ढूंढें. // CODELAB: shareDevice टिप्पणी को ShareDeviceRequest से बदलें. DeviceDescriptor, डिवाइस के बारे में खास जानकारी देता है, जैसे कि उसका वेंडर आईडी, प्रॉडक्ट आईडी, और deviceType. इस उदाहरण में, हमने वैल्यू को हार्ड कोड किया है.
    val shareDeviceRequest =
  ShareDeviceRequest.builder()
    .setDeviceDescriptor(DeviceDescriptor.builder().build())
    .setDeviceName("GHSAFM temp device name")
  3. CommissioningWindow और पैरामीटर सेट करें.
        .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() एपीआई का इस्तेमाल करें.
    Matter.getCommissioningClient(context)
    .shareDevice(shareDeviceRequest)

commissioningClient.shareDevice() एपीआई के सक्सेस कॉलबैक से, Intentभेजने वाले व्यक्ति को Google Play services में शेयर डिवाइस गतिविधि लॉन्च करने में मदद मिलती है.

  1. हमारे shareDevice फ़ंक्शन को पूरा करने के लिए, addOnSuccessListener और addOnFailureListener जोड़ें. सफल होने पर, डिवाइस शेयर करने के लिए जीपीएस गतिविधि लॉन्च करने के लिए, launch को shareDeviceLauncher पर कॉल किया गया.
        .addOnSuccessListener { result ->
      Timber.d("ShareDevice: Success getting the IntentSender: result [${result}]")
      shareDeviceLauncher.launch(IntentSenderRequest.Builder(result).build())
    }
    .addOnFailureListener { error ->
      Timber.e(error)
      deviceViewModel.showMsgDialog("Share device failed", error.toString())
    }

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

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

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

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

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

8. अगले चरण

बधाई हो

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

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

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

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

समुदाय से तकनीकी सहायता पाने के लिए, Stack Overflow पर google-smart-home टैग का इस्तेमाल करें: