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

1. शुरू करने से पहले

हमारे Thread Border Router (TBR) कोडलैब में, हमने Raspberry Pi पर आधारित Thread Border Router बनाने का तरीका बताया है. उस कोडलैब में हमने

Thread और वाई-फ़ाई/ईथरनेट नेटवर्क के बीच, दोनों तरफ़ से आईपी कनेक्टिविटी सेट अप करें.
एमडीएनएस (वाई-फ़ाई/ईथरनेट लिंक पर) और एसआरपी (थ्रेड नेटवर्क पर) के ज़रिए, दोनों दिशाओं में सेवा खोजने की सुविधा उपलब्ध कराता है.

यह कोडलैब, पिछले कोडलैब पर आधारित है. इसमें बताया गया है कि आपका बॉर्डर राउटर और आपका ऐप्लिकेशन, Google API के साथ इंटरैक्ट करके एक Thread नेटवर्क कैसे बना सकते हैं. थ्रेड क्रेडेंशियल को एक साथ इस्तेमाल करना ज़रूरी है. इससे नेटवर्क की मज़बूती बढ़ती है और थ्रेड पर निर्भर रहने वाले ऐप्लिकेशन के साथ उपयोगकर्ता के इंटरैक्शन आसान हो जाते हैं.

ज़रूरी शर्तें

OTBR Codelab पूरा करें
Linux, Android/Kotlin, और Thread नेटवर्किंग की बुनियादी जानकारी

आपको क्या सीखने को मिलेगा

क्रेडेंशियल सेट पाने और सेट करने के लिए, Thread Sharing API का इस्तेमाल करने का तरीका
Google के नेटवर्क के क्रेडेंशियल का इस्तेमाल करके, अपना OpenThread बॉर्डर राउटर सेट अप करने का तरीका

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

Raspberry Pi 4 बोर्ड या Linux पर आधारित कोई अन्य बोर्ड, जिस पर Open Thread Border Router (OTBR) चल रहा हो
यह एक ऐसा बोर्ड है जो रेडियो को-प्रोसेसर (आरसीपी) के तौर पर, IEEE 802.15.4 कनेक्टिविटी उपलब्ध कराता है. अलग-अलग SoC वेंडर की रिपॉज़िटरी की सूची और उनके निर्देशों को OpenThread के Github पेज पर देखें

2. एचटीटीपी सेवा सेट अप करना

हमें सबसे पहले एक ऐसे इंटरफ़ेस की ज़रूरत होती है जो हमें आपके ओटीबीआर से, चालू क्रेडेंशियल पढ़ने और लंबित क्रेडेंशियल लिखने की अनुमति दे. टीबीआर बनाते समय, अपने मालिकाना हक वाले तरीकों का इस्तेमाल करें. यहां दो उदाहरण दिए गए हैं. पहले विकल्प में दिखाया गया है कि DBUS के ज़रिए, OTBR एजेंट के साथ स्थानीय तौर पर इंटरफ़ेस कैसे किया जाता है. वहीं, दूसरा विकल्प OTBR पर बनाए जा सकने वाले Rest API का इस्तेमाल करता है.

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

पहला विकल्प: Python स्क्रिप्ट पर DBUS और HTTP API

इस चरण में, एक सामान्य एचटीटीपी सेवा बनाई जाती है. यह क्रेडेंशियल को पढ़ने और सेट करने के लिए दो एंडपॉइंट उपलब्ध कराती है. आखिर में, यह DBUS कमांड को कॉल करती है.

OTBR के तौर पर काम करने वाले RPi पर, Python 3 की डिपेंडेंसी इंस्टॉल करें:

$ pip install dbus-python shlex json

स्क्रिप्ट को इस तरह चलाएं:

$  sudo python credentials_server.py 8081
serving at port 8081

यह सैंपल, पोर्ट 8081 पर एक एचटीटीपी सर्वर सेट अप करता है. साथ ही, रूट पाथ पर थ्रेड क्रेडेंशियल पाने के लिए GET अनुरोध या थ्रेड क्रेडेंशियल सेट करने के लिए POST अनुरोध को सुनता है. पेलोड हमेशा टीएलवी के साथ JSON स्ट्रक्चर होता है.

यहां दिया गया PUT अनुरोध, /node/dataset/pending पाथ का इस्तेमाल करके, OTBR के लिए नए Pending Thread Credentials सेट करता है. इस मामले में, पुष्टि के लिए बाकी क्रेडेंशियल 10 सेकंड में लागू हो जाते हैं:

PUT /node/dataset/pending
Host: <IP>:8081
ContentType: "application/json"
acceptMimeType: "application/json"
...
{
        "ActiveDataset": "<TLV encoded new Thread Dataset>"
"PendingTimestamp": {
        "Seconds": <Unix timestamp in seconds>,
        "Ticks": 0,
        "Authoritative": false
},
"Delay": 10000 // in milliseconds
}

/node/dataset/active को किया गया GET अनुरोध, फ़िलहाल चालू क्रेडेंशियल फ़ेच करता है.

GET /node/dataset/active
Host: <IP>:8081
ContentType = "application/json"
acceptMimeType = "text/plain"
...
<TLV encoded Thread Dataset>

यह स्क्रिप्ट, बस पाथ io.openthread.BorderRouter.wpan0 और ऑब्जेक्ट पाथ /io/openthread/BorderRouter/wpan0 के लिए DBUS R/W कमांड को कॉल करती है:

# D-BUS interface
def call_dbus_method(interface, method_name, *arguments):
    bus = dbus.SystemBus()
    obj = bus.get_object('io.openthread.BorderRouter.wpan0', '/io/openthread/BorderRouter/wpan0')
    iface = dbus.Interface(obj, interface)
    method = getattr(iface, method_name)
    res = method(*arguments)
    return res

def get_dbus_property(property_name):
    return call_dbus_method('org.freedesktop.DBus.Properties', 'Get', 'io.openthread.BorderRouter',
                                 property_name)

def set_dbus_property(property_name, property_value):
    return call_dbus_method('org.freedesktop.DBus.Properties', 'Set', 'io.openthread.BorderRouter',
                                 property_name, property_value)

DBUS, अपनी क्षमताओं की जांच करने की अनुमति देता है. इसे इस तरह से किया जा सकता है:

$ sudo dbus-send --system --dest=io.openthread.BorderRouter.wpan0 \
        --type=method_call --print-reply /io/openthread/BorderRouter/wpan0 \
        org.freedesktop.DBus.Introspectable.Introspect

यहां जाकर, इस्तेमाल की जा सकने वाली सुविधाओं के बारे में भी जाना जा सकता है.

दूसरा विकल्प: OTBR एजेंट का नेटिव एचटीटीपी रेस्ट एपीआई

OpenThread बॉर्डर राउटर, डिफ़ॉल्ट रूप से REST_API=1 फ़्लैग के साथ बनाया जाता है. इससे REST API चालू हो जाता है. अगर पिछले कोडलैब से बनाए गए आपके बिल्ड में REST API चालू नहीं किया गया था, तो पक्का करें कि आपने RPi पर इस फ़्लैग के साथ OTBR बनाया हो:

$ REST_API=1 INFRA_IF_NAME=wlan0 ./script/setup

OTBR एजेंट को फिर से शुरू करने के लिए, यह कमांड चलाएं:

$ sudo systemctl restart otbr-agent.service

एजेंट, पोर्ट 8081 पर एचटीटीपी सर्वर शुरू करता है. इस सर्वर की मदद से, कोई उपयोगकर्ता या मॉनिटर प्रोग्राम, OTBR में कई टास्क पूरे कर सकता है. इसके बारे में यहां बताया गया है. इसके कॉन्टेंट की जांच करने के लिए, अपने ब्राउज़र, curl या wget का इस्तेमाल किया जा सकता है. ऊपर बताए गए इस्तेमाल के उदाहरणों के साथ-साथ, कई अन्य पाथ भी इस्तेमाल किए जा सकते हैं. इनमें /node/dataset/active पर GET वर्ब और /node/dataset/pending पर PUT वर्ब शामिल हैं.

3. Android पर क्रेडेंशियल फ़्रेमवर्क सेट अप करना

प्राथमिकता वाले क्रेडेंशियल

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

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

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

Google TBR Sync

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

यह प्रोसेस तब भी होगी, जब कोई दूसरा Google उपयोगकर्ता, GHA for Android या GHA for iOS पर हो और वह उसी स्ट्रक्चर में हो. iOS के लिए GHA के मामले में, अगर पसंदीदा क्रेडेंशियल मौजूद नहीं हैं, तो iOS स्टोरेज पर पसंदीदा क्रेडेंशियल सेट किए जाते हैं.

अगर एक ही नेटवर्क में दो Android डिवाइस (या Android + iGHA) मौजूद हैं और दोनों में क्रेडेंशियल के अलग-अलग सेट हैं, तो TBR पर उस डिवाइस के क्रेडेंशियल लागू होंगे जिसने TBR को कॉन्फ़िगर किया था.

तीसरे पक्ष के टीबीआर को ऑनबोर्ड करना

फ़िलहाल, क्रेडेंशियल का स्टोरेज, उपयोगकर्ता के स्मार्ट होम (स्ट्रक्चर) के दायरे में नहीं है. हर Android डिवाइस में अपना BAID स्टोरेज होगा. हालांकि, नेटवर्क में Google TBR मौजूद होने पर, Google Home ऐप्लिकेशन for iOS का इस्तेमाल करने वाले अन्य Android डिवाइस और iOS डिवाइस, उस TBR के साथ सिंक हो जाएंगे. साथ ही, फ़ोन स्टोरेज पर स्थानीय क्रेडेंशियल सेट करने की कोशिश करेंगे.

नया OOB TBR, नेटवर्क बनाने से पहले यह जांच करता है कि Android के स्टोरेज में कोई पसंदीदा नेटवर्क पहले से मौजूद है या नहीं.

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

4. अपने Android ऐप्लिकेशन को क्लोन करना और उसमें बदलाव करना

हमने एक Android ऐप्लिकेशन बनाया है. इसमें Thread API को कॉल करने के मुख्य तरीके दिखाए गए हैं. इन पैटर्न का इस्तेमाल अपने ऐप्लिकेशन में किया जा सकता है. इस कोडलैब में, हम Github से Google Home Sample App for Matter को क्लोन करेंगे.

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

इसका क्लोन बनाने के लिए, इनका इस्तेमाल करें:

$ git clone https://github.com/google-home/sample-apps-for-matter-android.git

Android Studio डाउनलोड करें और खोलें.
फ़ाइल > खोलें पर क्लिक करें और अपनी क्लोन की गई रिपॉज़िटरी पर जाएं.
अपने Android फ़ोन पर, डेवलपर मोड चालू करें.
इसे यूएसबी केबल की मदद से अपने कंप्यूटर से कनेक्ट करें.
Android Studio से ऐप्लिकेशन को <Cmd+R> (OS X) या <Ctrl+R> (Win, Linux) की मदद से चलाएं
पहिए -> डेवलपर टूल -> थ्रेड नेटवर्क पर जाएं
उपलब्ध अलग-अलग विकल्पों के साथ इंटरैक्ट करें. नीचे दिए गए सेक्शन में, हम उस कोड के बारे में जानकारी देंगे जो हर बटन पर लागू होता है.

क्या पसंदीदा क्रेडेंशियल मौजूद हैं?

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

/**
* Prompts whether credentials exist in storage or not. Consent from user is not necessary
*/

fun doGPSPreferredCredsExist(activity: FragmentActivity) {
 try {
   // Uses the ThreadNetwork interface for the preferred credentials, adding
   // a listener that will receive an intentSenderResult. If that is NULL, 
   // preferred credentials don't exist. If that isn't NULL, they exist.
   // In this case we'll not use it.

   ThreadNetwork.getClient(activity).preferredCredentials.addOnSuccessListener { intentSenderResult ->
     intentSenderResult.intentSender?.let { intentSender ->
       ToastTimber.d("threadClient: preferred credentials exist", activity)
       // don't post the intent on `threadClientIntentSender` as we do when
       // we really want to know which are the credentials. That will prompt a
       // user consent. In this case we just want to know whether they exist
     } ?: ToastTimber.d(
       "threadClient: no preferred credentials found, or no thread module found", activity
     )
   }.addOnFailureListener { e: Exception ->
     Timber.d("ERROR: [${e}]")
   }
 } catch (e: Exception) {
   ToastTimber.e("Error $e", activity)
 }
}

जीपीएस के पसंदीदा क्रेडेंशियल पाना

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

हमारे कोड में, संगठन/आर्किटेक्चर के मकसद से हम MutableLiveData<IntentSender?> का इस्तेमाल करते हैं. ऐसा इसलिए, क्योंकि ओरिजनल कोड ViewModel (ThreadViewModel.kt) में है और इंटेंट ऑब्ज़र्वर, ऐक्टिविटी फ़्रैगमेंट (ThreadFragment.kt) में हैं. इसलिए, intentSenderResult को लाइव डेटा में पोस्ट करने के बाद, हम इस ऑब्ज़र्वर के कॉन्टेंट को लागू करेंगे:

viewModel.threadClientIntentSender.observe(viewLifecycleOwner) { sender ->
 Timber.d(
   "threadClient: intent observe is called with [${intentSenderToString(sender)}]"
 )
 if (sender != null) {
   Timber.d("threadClient: Launch GPS activity to get ThreadClient")
   threadClientLauncher.launch(IntentSenderRequest.Builder(sender).build())
   viewModel.consumeThreadClientIntentSender()
 }
}

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

threadClientLauncher =
 registerForActivityResult(ActivityResultContracts.StartIntentSenderForResult()) { result ->
   if (result.resultCode == RESULT_OK) {
     val threadNetworkCredentials =
       ThreadNetworkCredentials.fromIntentSenderResultData(result.data!!)
     viewModel.threadPreferredCredentialsOperationalDataset.postValue(
       threadNetworkCredentials
     )
   } else {
     val error = "User denied request."
     Timber.d(error)
     updateThreadInfo(null, "")
   }
 }

MutableLiveData<ThreadNetworkCredentials?> पर क्रेडेंशियल पोस्ट करने के बारे में यहां बताया गया है.

जीपीएस क्रेडेंशियल सेट करना

चाहे वे मौजूद हों या न हों, आपको Google Play services में अपने टीबीआर को रजिस्टर करना चाहिए. आपका ऐप्लिकेशन ही, आपके टीबीआर के बॉर्डर एजेंट आईडी से जुड़े क्रेडेंशियल को पढ़ पाएगा. हालांकि, अगर आपका टीबीआर रजिस्टर करने वाला पहला टीबीआर है, तो उन क्रेडेंशियल को Preferred Credentials सेट में कॉपी कर दिया जाएगा. जब तक उपयोगकर्ता अनुमति देता है, तब तक फ़ोन पर मौजूद कोई भी ऐप्लिकेशन इस जानकारी को ऐक्सेस कर सकता है.

/**
* Last step in setting the GPS thread credentials of a TBR
*/
private fun associateGPSThreadCredentialsToThreadBorderRouterAgent(
 credentials: ThreadNetworkCredentials?,
 activity: FragmentActivity,
 threadBorderAgent: ThreadBorderAgent,
) {
 credentials?.let {
   ThreadNetwork.getClient(activity).addCredentials(threadBorderAgent, credentials)
     .addOnSuccessListener {
       ToastTimber.d("threadClient: Credentials added", activity)
     }.addOnFailureListener { e: Exception ->
       ToastTimber.e("threadClient: Error adding the new credentials: $e", activity)
     }
 }
}

टीबीआर प्रॉडक्ट के लिए क्रेडेंशियल सेट करना

यह हिस्सा हर वेंडर के लिए मालिकाना हक वाला होता है. इस कोडलैब में, हम इसे DBUS+Python HTTP Rest Server या OTBR के नेटिव HTTP Rest Server की मदद से लागू करते हैं.

/**
* Creates credentials in the format used by the OTBR HTTP server. See its documentation in
* https://github.com/openthread/ot-br-posix/blob/main/src/rest/openapi.yaml#L215
*/
fun createJsonCredentialsObject(newCredentials: ThreadNetworkCredentials): JSONObject {
 val jsonTimestamp = JSONObject()
 jsonTimestamp.put("Seconds", System.currentTimeMillis() / 1000)
 jsonTimestamp.put("Ticks", 0)
 jsonTimestamp.put("Authoritative", false)

 val jsonQuery = JSONObject()
 jsonQuery.put(
   "ActiveDataset",
   BaseEncoding.base16().encode(newCredentials.activeOperationalDataset)
 )
 jsonQuery.put("PendingTimestamp", jsonTimestamp)
 // delay of committing the pending set into active set: 10000ms
 jsonQuery.put("Delay", 10000)

 Timber.d(jsonQuery.toString())

 return jsonQuery
}

//(...)

var response = OtbrHttpClient.createJsonHttpRequest(
 URL("http://$ipAddress:$otbrPort$otbrDatasetPendingEndpoint"),
 activity,
 OtbrHttpClient.Verbs.PUT,
 jsonQuery.toString()
)

अपने टीबीआर प्रॉडक्ट से क्रेडेंशियल पाना

जैसा कि पहले दिखाया गया है, अपने टीबीआर से क्रेडेंशियल पाने के लिए, GET HTTP Verb का इस्तेमाल करें. Python स्क्रिप्ट का सैंपल देखें.

बनाएं और इंपोर्ट करें

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

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

मेनिफ़ेस्ट में हुए बदलाव

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    (...)
    <!-- usesCleartextTraffic needed for OTBR local unencrypted communication -->
    <!-- Not needed for Thread Module, only used for HTTP -->
    <uses-feature
    (...)
        android:usesCleartextTraffic="true">

    <application>
    (...)
    <!-- GPS automatically downloads scanner module when app is installed -->
    <!-- Not needed for Thread Module, only used for scanning QR Codes -->
    <meta-data
        android:name="com.google.mlkit.vision.DEPENDENCIES"
        android:value="barcode_ui"/>
    </application>
</manifest>

Build.gradle

// Thread Network
implementation 'com.google.android.gms:play-services-threadnetwork:16.0.0'
// Thread QR Code Scanning
implementation 'com.google.android.gms:play-services-code-scanner:16.0.0'
// Thread QR Code Generation
implementation 'com.journeyapps:zxing-android-embedded:4.1.0'
// Needed for using BaseEncoding class
implementation 'com.google.guava:guava:31.1-jre'

काम के इंपोर्ट

// Thread Network Module
import com.google.android.gms.threadnetwork.ThreadNetworkCredentials
import com.google.android.gms.threadnetwork.ThreadBorderAgent
import com.google.android.gms.threadnetwork.ThreadNetwork

// Conversion of credentials to/fro Base16 (hex)
import com.google.common.io.BaseEncoding

// HTTP
import java.io.BufferedInputStream
import java.io.InputStream
import java.net.HttpURLConnection
import java.net.URL
import java.nio.charset.StandardCharsets

// Co-routines for HTTP calls
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch


// JSON
import org.json.JSONObject

// Logs
import timber.log.Timber

// mDNS/SD
import android.net.nsd.NsdServiceInfo

// QR Code reader / writer
import com.google.mlkit.vision.barcode.common.Barcode
import com.google.mlkit.vision.codescanner.GmsBarcodeScannerOptions
import com.google.mlkit.vision.codescanner.GmsBarcodeScanning
import com.google.zxing.BarcodeFormat
import com.google.zxing.MultiFormatWriter
import com.journeyapps.barcodescanner.BarcodeEncoder

5. mDNS/SD Discovery

हमारा सैंपल ऐप्लिकेशन, mDNS/SD डिस्कवरी का इस्तेमाल करता है. इससे नेटवर्क में उपलब्ध Thread बॉर्डर राऊटर की सूची बनाई जाती है. साथ ही, उनके बीआईडी भी बनाए जाते हैं.

जीपीएस क्रेडेंशियल के स्टोरेज में, अपने टीबीआर की जानकारी डालते समय यह बहुत काम आता है. हालांकि, इसका इस्तेमाल इस कोडलैब के दायरे से बाहर है. हम Android Service Discovery लाइब्रेरी NSDManager का इस्तेमाल करते हैं. इसका पूरा सोर्स कोड, सैंपल ऐप्लिकेशन में ServiceDiscovery.kt में उपलब्ध है.

6. सारा खर्च एक साथ जोड़ना

इन कॉल को लागू करने या सैंपल ऐप्लिकेशन का इस्तेमाल करने के बाद, RPi OTBR को पूरी तरह से चालू किया जा सकता है. हमारे सैंपल ऐप्लिकेशन में आठ बटन हैं:

टीबीआर को शामिल करने का संभावित क्रम यह है:

क्वेरी करें कि क्या प्राथमिकता वाले क्रेडेंशियल मौजूद हैं (नीला, पहली लाइन)
जवाब के हिसाब से
जीपीएस के लिए पसंदीदा क्रेडेंशियल पाएं (नीले रंग का, दूसरी लाइन में)
GPS में TBR क्रेडेंशियल सेट करें (नीला, तीसरी लाइन) -> अपना TBR चुनें -> रैंडम बनाएं -> नेटवर्क का नाम डालें -> ठीक है
अब जब आपके पास पसंदीदा क्रेडेंशियल हैं, तो उन्हें Set RPi OTBR credentials का इस्तेमाल करके, अपने OTBR पर सेट करें. इससे उन क्रेडेंशियल को, सेट किए जाने वाले डिवाइसों पर लागू किया जा सकेगा.

सैंपल ऐप्लिकेशन के लिए, डिफ़ॉल्ट रूप से 10 सेकंड की देरी का इस्तेमाल किया जाता है. इसलिए, इस अवधि के बाद, आपके RPi TBR (और इसके नेटवर्क पर मौजूद अन्य नोड) के क्रेडेंशियल, नए डेटासेट पर माइग्रेट हो जाएंगे.

7. नतीजा

इस कोडलैब में, हमने एक सैंपल Android ऐप्लिकेशन को क्लोन किया है. साथ ही, हमने कोड के कई ऐसे स्निपेट का विश्लेषण किया है जो Google Play services के Thread Storage API का इस्तेमाल करते हैं. हमने उन एपीआई का इस्तेमाल करके एक सामान्य डेटासेट बनाया है. इसे RPi TBR पर शामिल किया जा सकता है. इससे वेंडर का TBR दिखता है.

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

हमें उम्मीद है कि इस कोडलैब और सैंपल ऐप्लिकेशन से, आपको अपना ऐप्लिकेशन और Thread बॉर्डर राउटर प्रॉडक्ट डिज़ाइन और डेवलप करने में मदद मिलेगी.

8. रेफ़रंस

आरसीपी को-प्रोसेसर

DBUS