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

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

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

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

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

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

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

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

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

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

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

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

2. सेट अप करें

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

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

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

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

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

डिपेंडेंसी

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

सोर्स कोड

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

इस कोडलैब के लिए, हम इन फ़ाइलों में Matter फ़ंक्शन जोड़ देंगे:

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

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

// CODELAB: add commissioningFunction()

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

3. Google को कमीशन देना

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

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

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

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

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

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

चरण 1: गतिविधि लॉन्चर

CommissioningClient के IntentSender को हैंडल करने के लिए, ऐक्टिविटी रिज़ल्ट टूल का इस्तेमाल किया जा सकता है:

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. Matter, Home Mobile SDK टूल का एंट्री पॉइंट है. अगले कॉल में, .getCommissioningClient को this (गतिविधि) के हिसाब से कमीशनिंग क्लाइंट मिलता है.
  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 की सेटिंग की मदद से, Local Android Fabric का इस्तेमाल किया जा सकता है. इससे अपने डिवाइसों को अन्य फ़ैब्रिक के लिए आसानी से लॉन्च किया जा सकता है.

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

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

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

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

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

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

कस्टम कमीशनिंग सेवाएं

लोकल 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 ऑब्जेक्ट का इस्तेमाल करेंगे.

चरण 1: GPS गतिविधि लॉन्चर बनाएं

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

  1. HomeScreen को java/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/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 को इनहेरिट करना होगा. साथ ही, हम अपने सैंपल ऐप्लिकेशन में, डिवाइसों को कमीशन करने के लिए ज़रूरी फ़ंक्शन उपलब्ध कराने होंगे. बुनियादी कमीशनिंगसेवा को लागू करने का उदाहरण यहां दिया गया है:

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 के बारे में जानें

शुरू करने में आपकी मदद करने के लिए, हमने अपनी कस्टम कमीशनिंग सेवा के लिए बेसिक क्लास का स्ट्रक्चर पहले ही तय कर दिया है. यहां सेवा के काम करने के तरीके की खास जानकारी दी गई है. फ़ॉलो करने के लिए, 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.home_sample_app_for_matter.chip.ChipClient

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

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

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

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

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

ऐप्लिकेशन के डेवलपमेंट फ़ैब्रिक पर डिवाइसों को कमीशन करने के लिए, यह तरीका अपनाएं:

  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 की सुविधा वाले ऐप्लिकेशन और आपके डिवाइस के बीच एक सुरक्षित चैनल बनाने के लिए करता है.
    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 रेपो (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)
              }
            })
  }
}

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

किसी डिवाइस को कमीशन किए जाने के बाद, 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 Mobile SDK टूल, ShareDeviceRequest API में यह सुविधा देता है. इसकी मदद से, ये काम किए जा सकते हैं:

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

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

चरण 1: GPS गतिविधि लॉन्चर बनाएं

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

  1. DeviceScreen को java/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 = {
 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/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() एपीआई का सफल कॉलबैक, Google Play Services में डिवाइस की गतिविधि शेयर करें को लॉन्च करने के लिए इस्तेमाल किया जाने वाला IntentSender उपलब्ध कराता है.

  1. हमारे shareDevice फ़ंक्शन को पूरा करने के लिए, addOnSuccessListener और addOnFailureListener जोड़ें. सफल होने पर, डिवाइस शेयरिंग के लिए GPS गतिविधि लॉन्च करने के लिए 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 Mobile SDK टूल का इस्तेमाल करके डिवाइसों को कमीशन और शेयर करने का तरीका भी सीख लिया है.

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

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

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

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