Android के लिए Thread Network का SDK टूल

Thread Network SDK टूल की मदद से, डिजिटल प्लैटफ़ॉर्म पर Keychain की मदद से, आपके Android ऐप्लिकेशन, Thread नेटवर्क के क्रेडेंशियल शेयर कर सकते हैं Google Play सेवाएं. इससे आपके ऐप्लिकेशन, इनसे कोई भी Thread डिवाइस सेट अप कर सकते हैं किसी भी स्मार्ट होम नेटवर्क से कनेक्ट कर सकते हैं.

सिर्फ़ कुछ एपीआई कॉल की मदद से:

1. Google Play services से, अपने पसंदीदा Thread नेटवर्क के क्रेडेंशियल का अनुरोध करें.
2. नए बॉर्डर राऊटर सेट अप करें और Google में अपने Thread नेटवर्क के क्रेडेंशियल जोड़ें Play सेवाएं.
3. अगर आपके पास पहले से ही फ़ील्ड बॉर्डर राऊटर हैं, तो यह देखा जा सकता है कि आपके बॉर्डर राऊटर, पसंदीदा नेटवर्क में हैं या नहीं. साथ ही, ज़रूरत पड़ने पर उन्हें माइग्रेट भी किया जा सकता है.

उपयोगकर्ता और डेवलपर के अलग-अलग अनुभवों पर विचार करना चाहिए. हम इस गाइड में, इनमें से ज़्यादातर सुविधाओं के साथ-साथ अन्य मुख्य सुविधाओं और इस्तेमाल के सुझावों के बारे में बताएंगे.

मुख्य शब्दावली और एपीआई के कॉन्सेप्ट

शुरू करने से पहले, इन शर्तों को समझना ज़रूरी है:

• Thread नेटवर्क के क्रेडेंशियल: कोड में बदलने वाले Thread TLVs का बाइनरी ब्लॉब Thread नेटवर्क का नाम, नेटवर्क कुंजी, और अन्य प्रॉपर्टी दिए गए Thread नेटवर्क से जुड़ने के लिए, Thread डिवाइस को चुनें.

• Thread नेटवर्क के पसंदीदा क्रेडेंशियल: ये Thread नेटवर्क के अपने-आप चुने गए क्रेडेंशियल होते हैं. इन्हें getPreferredCredentials API का इस्तेमाल करके, अलग-अलग वेंडर के ऐप्लिकेशन के साथ शेयर किया जा सकता है.

• बॉर्डर एजेंट आईडी: Thread बॉर्डर राउटर डिवाइस के लिए, दुनिया भर में मान्य 16-बाइट का यूनीक आईडी. इस आईडी को बॉर्डर राऊटर वेंडर बनाते और मैनेज करते हैं.

• Thread Border Router सेटअप ऐप्लिकेशन: यह आपका Android ऐप्लिकेशन है जो नए Thread बॉर्डर राऊटर डिवाइस को कनेक्ट करता है और Thread नेटवर्क के क्रेडेंशियल को Google Play सेवाएं. आपका ऐप्लिकेशन, जोड़े गए क्रेडेंशियल का आधिकारिक मालिक है और उसके पास उनका ऐक्सेस है.

Thread Network के कई एपीआई, टास्क जो एसिंक्रोनस रूप से पूरा होता है. नतीजा पाने के लिए कॉलबैक रजिस्टर करने के लिए, addOnSuccessListener और addOnFailureListener का इस्तेमाल किया जा सकता है. ज़्यादा जानकारी के लिए, इस लिंक पर जाएं टास्क दस्तावेज़.

क्रेडेंशियल का मालिकाना हक और रखरखाव

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

ऐप्लिकेशन के मालिक के तौर पर, हमारा सुझाव है कि आप Thread Border Router नेटवर्क के अपडेट होने पर, Google Play services में सेव किए गए क्रेडेंशियल अप-टू-डेट रखें. इसका मतलब है कि ज़रूरत पड़ने पर क्रेडेंशियल जोड़ना, बॉर्डर राउटर के Thread नेटवर्क के क्रेडेंशियल बदलने पर उन्हें अपडेट करना, और Thread बॉर्डर राउटर को हटाने या फ़ैक्ट्री रीसेट करने पर क्रेडेंशियल हटाना.

बॉर्डर एजेंट की खोज

क्रेडेंशियल, बॉर्डर एजेंट आईडी के साथ सेव होने चाहिए. आपको यह पक्का करना होगा कि Thread बॉर्डर राऊटर का सेटअप ऐप्लिकेशन से बॉर्डर एजेंट आईडी की जानकारी हासिल की जा सकती है शामिल हैं.

Thread बॉर्डर राउटर को Thread नेटवर्क की जानकारी का विज्ञापन करने के लिए, mDNS का इस्तेमाल करना होगा. इसमें नेटवर्क का नाम, एक्सटेंडेड पैन आईडी, और बॉर्डर एजेंट आईडी शामिल है. कॉन्टेंट बनाने इन एट्रिब्यूट के लिए txt की वैल्यू nn, xp, और id हैं. क्रम से.

Google के बॉर्डर राऊटर वाले नेटवर्क के लिए, Google Play services अपने-आप इस्तेमाल करने के लिए, Google Thread नेटवर्क के क्रेडेंशियल पाएं.

अपने Android ऐप्लिकेशन के साथ SDK टूल को इंटिग्रेट करना

शुरू करने के लिए, नीचे दिया गया तरीका अपनाएं:

1. यहां दिए गए निर्देशों का पालन करें Google Play services सेट अप करना.

2. अपनी build.gradle फ़ाइल पर, Google Play services की डिपेंडेंसी जोड़ें:

   implementation 'com.google.android.gms:play-services-threadnetwork:16.2.1'
   

3. ज़रूरी नहीं: बॉर्डर राऊटर को स्टोर करने के लिए, BorderAgent डेटा क्लास तय करें जानकारी. हम इस डेटा का इस्तेमाल पूरी गाइड में करेंगे:

   data class BorderAgentInfo(
     // Network Name max 16 len
     val networkName: String = "",
     val extPanId: ByteArray = ByteArray(16),
     val borderAgentId: ByteArray = ByteArray(16),
     ...
   )
   

इसके बाद, हम Google News ऐप्लिकेशन में क्रेडेंशियल डालें.

बॉर्डर राऊटर के नए सेटअप

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

getPreferredCredentials को कॉल करने पर, एक गतिविधि शुरू होती है. इसमें उपयोगकर्ताओं को नेटवर्क अनुरोध को अनुमति देने के लिए कहा जाता है. अगर नेटवर्क क्रेडेंशियल, Thread SDK डिजिटल कीचेन में सेव किए गए हैं. वापस आ गए हैं.

क्रेडेंशियल के लिए अनुरोध करें

उपयोगकर्ता से पसंदीदा क्रेडेंशियल डालने के लिए कहने के लिए:

1. ActivityLauncher का एलान करें:

   private lateinit var preferredCredentialsLauncher: ActivityResultLauncher<IntentSenderRequest>
   

2. ThreadNetworkCredentials के तौर पर दिए गए, गतिविधि के नतीजे को मैनेज करें:

   preferredCredentialsLauncher =
    registerForActivityResult(
      StartIntentSenderForResult()
    ) { result: ActivityResult ->
      if (result.resultCode == RESULT_OK) {
        val threadNetworkCredentials = ThreadNetworkCredentials.fromIntentSenderResultData(result.data!!)
        Log.d("debug", threadNetworkCredentials.networkName)
      } else {
        Log.d("debug", "User denied request.")
      }
    }
   

3. अगर कोई नया थ्रेड बॉर्डर राऊटर सेट अप किया जा रहा है, तो हमारा सुझाव है कि आप preferredCredentials को कॉल करें और गतिविधि शुरू करें. इस कॉल से यह पक्का होगा कि आपका नया Thread Border Router, फ़ोन में पहले से पसंदीदा के तौर पर सेव किए गए क्रेडेंशियल का इस्तेमाल करेगा. इससे, एक ही नेटवर्क में अलग-अलग टीबीआर को कन्वर्ज करने में मदद मिलेगी.

   private fun getPreferredThreadNetworkCredentials() {
     ThreadNetwork.getClient(this)
       .preferredCredentials
     .addOnSuccessListener { intentSenderResult ->
       intentSenderResult.intentSender?.let {
         preferredCredentialsLauncher.launch(IntentSenderRequest.Builder(it).build())
         } ?: Log.d("debug", "No preferred credentials found.")
       }
     .addOnFailureListener { e: Exception -> Log.d(TAG, "ERROR: [${e}]") }
   }
   

4. अगर आपका इस्तेमाल का उदाहरण, टीबीआर के अलावा किसी दूसरे डिवाइस को सेट अप करने से जुड़ा है, जैसे कि नया Matter-over-Thread एंड डिवाइस, तो हमारा सुझाव है कि आप क्रेडेंशियल पाने के लिए allActiveCredentials एपीआई का इस्तेमाल करें. यह कॉल, स्थानीय नेटवर्क में मौजूद टीबीआर को स्कैन करेगा. इसलिए, यह ऐसे क्रेडेंशियल नहीं दिखाएगा जो स्थानीय तौर पर मौजूद किसी मौजूदा टीबीआर के पास उपलब्ध नहीं हैं.

   // Creates the IntentSender result launcher for the getAllActiveCredentials API
   private val getAllActiveCredentialsLauncher =
     registerForActivityResult(
       StartIntentSenderForResult()
     ) { result: ActivityResult ->
       if (result.resultCode == RESULT_OK) {
         val activeCredentials: List<ThreadNetworkCredentials> =
           ThreadNetworkCredentials.parseListFromIntentSenderResultData(
             result.data!!
           )
         // Use the activeCredentials list
       } else {
         // The user denied to share!
       }
     }
   
   // Invokes the getAllActiveCredentials API and starts the dialog activity with the returned
   // IntentSender
   threadNetworkClient
   .getAllActiveCredentials()
   .addOnSuccessListener { intentSenderResult: IntentSenderResult ->
     val intentSender = intentSenderResult.intentSender
     if (intentSender != null) {
       getAllActiveCredentialsLauncher.launch(
         IntentSenderRequest.Builder(intentSender).build()
       )
     } else {
       // No active network credentials found!
     }
   }
   // Handles the failure
   .addOnFailureListener { e: Exception ->
     // Handle the exception
   }
   

नया थ्रेड नेटवर्क बनाना

अगर Thread नेटवर्क के पसंदीदा क्रेडेंशियल या ऐक्टिव थ्रेड नहीं हैं, तो उपयोगकर्ता के Thread नेटवर्क. इसके बाद, क्रेडेंशियल जोड़ने के लिए addCredentials API का इस्तेमाल किया जा सकता है Google Play services पर जाएं. ऐसा करने के लिए, आपको एक ThreadBorderAgent, और एक ThreadNetworkCredentials ऑब्जेक्ट भी दें.

बिना किसी क्रम का नेटवर्क बनाने के लिए, newRandomizeBuilder पर कॉल करें:

val threadCredentials = ThreadNetworkCredentials.newRandomizedBuilder().build()

Thread नेटवर्क का नाम तय करने के लिए:

val threadCredentials = ThreadNetworkCredentials.newRandomizedBuilder()
  .setNetworkName("ThreadNetworkSDK")
  .build()

क्रेडेंशियल जोड़ें

Thread नेटवर्क के क्रेडेंशियल को Thread के अन्य वेंडर के लिए उपलब्ध कराने के लिए, हमें उन्हें Google Play services में जोड़ना होगा. इससे पहले कि हम अपना नया क्रेडेंशियल के साथ-साथ, हमें यह भी जानने की ज़रूरत है कि इस Thread में मौजूद कौनसा बॉर्डर राऊटर डिवाइस नेटवर्क इससे जुड़ा है.

इस उदाहरण में, हम बॉर्डर एजेंट आईडी से एक ThreadBorderAgent बनाएंगे और आपने अभी-अभी Thread नेटवर्क के नए क्रेडेंशियल पास किए हैं:

private fun addCredentials(borderAgentInfo: BorderAgentInfo, credentialsToBeAdded: ThreadNetworkCredentials) {

  val threadBorderAgent = ThreadBorderAgent.newBuilder(borderAgentInfo.borderAgentId).build()
  Log.d("debug", "border router id:" + threadBorderAgent.id)

  ThreadNetwork.getClient(this)
    .addCredentials(threadBorderAgent, credentialsToBeAdded)
      .addOnSuccessListener {
        Log.d("debug", "Credentials added.")
      }
      .addOnFailureListener { e: Exception -> Log.d(TAG, "ERROR: [${e}]") }
}

फ़ील्ड में मौजूद बॉर्डर राऊटर का पता लगाना और उन्हें माइग्रेट करना

अगर आपके पास फ़िलहाल फ़ील्ड में बॉर्डर राऊटर हैं, तो isPreferredCredentials का इस्तेमाल करके यह पता लगाया जा सकता है कि आपके बॉर्डर राऊटर, पसंदीदा नेटवर्क से जुड़े हैं या नहीं. यह एपीआई, उपयोगकर्ता की अनुमति लेता है और सेव की गई जानकारी के आधार पर बॉर्डर राऊटर के क्रेडेंशियल की जांच करता है Google Play services में जाकर.

isPreferredCredentails, मेल नहीं खाने के लिए 0 और 1 के लिए वैल्यू दिखाता है Int डेटाटाइप के तौर पर मैच किया गया. अपने नतीजे देखने के लिए, IsPreferredCredentialsResult का इस्तेमाल किया जा सकता है.

public @interface IsPreferredCredentialsResult {
    int PREFERRED_CREDENTIALS_NOT_FOUND = -1;
    int PREFERRED_CREDENTIALS_NOT_MATCHED = 0;
    int PREFERRED_CREDENTIALS_MATCHED = 1;
}

isPreferredCredentials का इस्तेमाल करने के लिए, आपको पहले एक ThreadNetworkCredentials ऑब्जेक्ट बनाना होगा. ThreadNetworkCredentials को इंस्टैंशिएट करने के कई तरीके हैं. अगले चरणों में, हम इन विकल्पों के बारे में बताएंगे.

ऑपरेशनल डेटासेट के हिसाब से थ्रेड नेटवर्क क्रेडेंशियल

ऐसा भी है कि आपका Thread Border Router पहले ही किसी Thread नेटवर्क और आपको इस Thread नेटवर्क को Google Play services में जोड़ना है अन्य वेंडर के साथ शेयर किया जा सकता है. रॉ थ्रेड ऐक्टिव ऑपरेशनल डेटासेट टीएलवी की सूची से, ThreadNetworkCredential इंस्टेंस बनाया जा सकता है:

1. ऑपरेशनल डेटासेट को ByteArray में बदलें. उदाहरण के लिए:

   val activeDataset =
         "0e080000000000010000000300000f35060004001fffe0020833333333...".dsToByteArray()
   

   fun String.dsToByteArray(): ByteArray {
     return chunked(2).map { it.toInt(16).toByte() }.toByteArray()
   }
   

2. ThreadNetworkCredentials बनाने के लिए, fromActiveOperationalDataset का इस्तेमाल करें. ऐसा करने पर, आपको Thread नेटवर्क का नाम, चैनल, और नेटवर्क की अन्य जानकारी मिल जाएगी. प्रॉपर्टी की पूरी सूची के लिए, ThreadNetworkCredentials देखें.

   val threadNetworkCredentials =
       ThreadNetworkCredentials.fromActiveOperationalDataset(activeDataset)
   Log.d(
       "threadNetworkCredentials",
       threadNetworkCredentials.channel.toString() + " - " + threadNetworkCredentials.networkName)
   

3. isPreferredCredentials एपीआई को कॉल करें और ThreadNetworkCredentials को पास करें.

   ThreadNetwork.getClient(this)
   .isPreferredCredentials(threadNetworkCredentials)
   .addOnSuccessListener { result ->
     when (result) {
       IsPreferredCredentialsResult.PREFERRED_CREDENTIALS_NOT_MATCHED ->
           Log.d("isPreferredCredentials", "Credentials not matched.")
       IsPreferredCredentialsResult.PREFERRED_CREDENTIALS_MATCHED ->
           Log.d("isPreferredCredentials", "Credentials matched.")
     }
   }
   .addOnFailureListener { e: Exception -> Log.d("isPreferredCredentials", "ERROR: [${e}]") }
   

Border Agent के ज़रिए Thread नेटवर्क के क्रेडेंशियल

बॉर्डर एजेंट आईडी किसी बॉर्डर राऊटर डिवाइस की खास तौर पर पहचान करता है. getCredentialsByBorderAgent एपीआई का इस्तेमाल करने के लिए, आपको सबसे पहले ThreadBorderAgent ऑब्जेक्ट बनाना होगा और बॉर्डर एजेंट आईडी पास करना होगा.

ThreadBorderAgent ऑब्जेक्ट बनाने के बाद, getCredentialsByBorderAgent को कॉल करें. अगर क्रेडेंशियल सेव कर लिए गए हैं, तो देखें प्राथमिकता दी जा सकती है.

private fun isPreferredThreadNetworkByBorderAgent(borderAgentInfo: BorderAgentInfo) {

  val threadBorderAgent = ThreadBorderAgent.newBuilder(borderAgentInfo.borderAgentId).build()
  Log.d("debug", "border router id:" + threadBorderAgent.id)

  var isPreferred = IsPreferredCredentialsResult.PREFERRED_CREDENTIALS_NOT_FOUND
  var borderAgentCredentials: ThreadNetworkCredentials?
  val taskByBorderAgent = ThreadNetwork.getClient(this)
  taskByBorderAgent
      .getCredentialsByBorderAgent(threadBorderAgent)
      .addOnSuccessListener { result: ThreadNetworkCredentialsResult ->
        borderAgentCredentials = result.credentials
        result.credentials?.let {
          taskByBorderAgent.isPreferredCredentials(it).addOnSuccessListener { result ->
            isPreferred = result
          }
        }
      }
      .addOnFailureListener { e: Exception -> Log.d(TAG, "ERROR: [${e}]") }
}

एक्सटेंडेड पैन आईडी के हिसाब से Thread नेटवर्क के क्रेडेंशियल

getPreferredCredentials की तरह ही, उपयोगकर्ता से बॉर्डर राउटर के एक्सटेंडेड पैन आईडी से क्रेडेंशियल भी मांगे जा सकते हैं. कॉन्टेंट बनाने getCredentialsByExtendedPanId, IntentSender और गतिविधि दिखाता है उपयोगकर्ता की अनुमति मिलने पर, नतीजे में ThreadNetworkCredentials ऑब्जेक्ट होगा.

private fun getCredentialsByExtPanId(borderAgentInfo: BorderAgentInfo) {
  ThreadNetwork.getClient(this)
    .getCredentialsByExtendedPanId(borderAgentInfo.extPanId)
    .addOnSuccessListener { intentSenderResult ->
      intentSenderResult.intentSender?.let {
        preferredCredentialsLauncher.launch(IntentSenderRequest.Builder(it).build())
      }
        ?: Log.d("debug", "No credentials found.")
    }
    .addOnFailureListener { e: Exception -> Log.d(TAG, "ERROR: [${e}]") }
}

क्रेडेंशियल हटाएं

जब आपके होम से बॉर्डर राऊटर डिवाइस को हटाया जाता है या उसे फ़ैक्ट्री रीसेट किया जाता है, तो आपको Google Play services से उसका Thread नेटवर्क हटाना होगा.

private fun removeCredentials(borderAgentInfo: BorderAgentInfo) {

  val threadBorderAgent = ThreadBorderAgent.newBuilder(borderAgentInfo.borderAgentId).build()
  Log.d("debug", "border router id:" + threadBorderAgent.id)

  ThreadNetwork.getClient(this)
      .removeCredentials(threadBorderAgent)
      .addOnSuccessListener { Log.d("debug", "Credentials removed.") }
      .addOnFailureListener { e: Exception -> Log.d(TAG, "ERROR: [${e}]") }
}

संसाधन

Thread Network SDK टूल के बारे में ज़्यादा जानने के लिए, एपीआई रेफ़रंस देखें.