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

इस कोडलैब (कोड बनाना सीखने के लिए ट्यूटोरियल) के बारे में जानकारी
schedule44 मिनट
subjectपिछली बार 5 अक्तूबर 2023 को अपडेट किया गया
account_circleDoug Ferraz ने लिखा

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

  • Thread और वाई-फ़ाई/ईथरनेट नेटवर्क के बीच बाई-डायरेक्शनल आईपी कनेक्टिविटी बनाएं.
  • mडीएनएस (वाई-फ़ाई/ईथरनेट लिंक पर) और SRP (Thread नेटवर्क पर) के ज़रिए, बाय-डायरेक्शनल सेवा की खोज करने की सुविधा दें.

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

  • क्रेडेंशियल सेट पाने और सेट करने के लिए, Thread Share API इस्तेमाल करने का तरीका
  • Google के नेटवर्क वाले अपने OpenThread Border राऊटर को सेट अप करने का तरीका

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

  • Raspberry Pi 4 बोर्ड या ओपन थ्रेड बॉर्डर राऊटर (ओटीबीआर) चलाने वाला कोई दूसरा Linux-आधारित बोर्ड
  • यह बोर्ड आईईईई 802.15.4 कनेक्टिविटी को रेडियो को-प्रोसेसर (आरसीपी) के तौर पर उपलब्ध कराता है. OpenThread GitHub पेज पर, अलग-अलग SoC वेंडर के डेटा स्टोर करने की जगहों की सूची देखें और उनके निर्देश देखें

2. एचटीटीपी सेवा सेट अप की जा रही है

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

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

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

91e5fdeed83e9354.png

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

जिस आरपीआई का इस्तेमाल आपके OTBR के तौर पर किया जाएगा उस पर Python 3 डिपेंडेंसी इंस्टॉल करें:

$ pip install dbus-python shlex json

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

$  sudo python credentials_server.py 8081
serving at port 8081

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

नीचे दिया गया PUT अनुरोध, /node/dataset/pending पाथ के ज़रिए OTBR पर नए थ्रेड के क्रेडेंशियल सेट करता है जिन्हें मंज़ूरी मिलना बाकी है. इस मामले में, मंज़ूरी बाकी वाले क्रेडेंशियल 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 एजेंट नेटिव एचटीटीपी रेस एपीआई

c748ca5151b6cacb.png

REST_API=1 फ़्लैग के साथ OpenThread बॉर्डर राऊटर को डिफ़ॉल्ट रूप से बनाया जाता है. इससे 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 के स्टोरेज में जोड़ा गया पहला टीबीआर, इस मोबाइल डिवाइस के लिए पसंदीदा क्रेडेंशियल तय करता है.

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

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

Google TBR सिंक

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

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

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

तीसरे पक्ष की टीबीआर में शामिल होना

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

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

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

cd8bc726f67b1fa1.png

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

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

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

  1. इसका उपयोग करके इसका क्लोन बनाएं:
$ git clone https://github.com/google-home/sample-apps-for-matter-android.git
  1. Android Studio डाउनलोड करें और खोलें.
  2. फ़ाइल > पर क्लिक करें अपनी क्लोन की गई रिपॉज़िटरी को खोलें और उस पर जाएं.
  3. अपने Android फ़ोन पर डेवलपर मोड चालू करें.
  4. इसे यूएसबी केबल की मदद से अपने कंप्यूटर से कनेक्ट करें.
  5. <Cmd+R> के ज़रिए Android Studio से ऐप्लिकेशन चलाएं (OS X) या <Ctrl+R> (विन, लिनक्स)
  6. व्हील पर जाएं -> डेवलपर उपयोगिताएं -> Thread नेटवर्क
  7. उपलब्ध अलग-अलग विकल्पों का इस्तेमाल करें. नीचे दिए गए सेक्शन में, हम हर बटन पर चलने वाले कोड को अनपैक करेंगे.

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

पहले सवाल, TBR मैन्युफ़ैक्चरर को 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) में होते हैं. इसलिए, जब इंटेंट हेडर को लाइव डेटा में पोस्ट कर दिया जाएगा, तब हम इस ऑब्ज़र्वर के कॉन्टेंट को लागू करेंगे:

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 सेवाओं में रजिस्टर करना चाहिए. आपके टीबीआर के बॉर्डर एजेंट आईडी से जुड़े क्रेडेंशियल को सिर्फ़ आपका ऐप्लिकेशन ही पढ़ पाएगा. हालांकि, अगर आपका टीबीआर सबसे पहले रजिस्टर किया जाता है, तो उन क्रेडेंशियल को पसंदीदा क्रेडेंशियल सेट में कॉपी कर दिया जाएगा. फ़ोन पर मौजूद किसी भी ऐप्लिकेशन से तब तक इस जानकारी को ऐक्सेस किया जा सकता है, जब तक उपयोगकर्ता ने उसे अनुमति दी हो.

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

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

यह हिस्सा हर वेंडर के पास होता है. इस कोडलैब में हम इसे DBUS+Python एचटीटीपी रेस्ट सर्वर या ओटीबीआर के नेटिव एचटीटीपी रेस्ट सर्वर के ज़रिए लागू करते हैं.

/**
* 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()
)

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

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

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

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

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

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

<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. mडीएनएस/एसडी डिस्कवरी

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

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

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

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

91979bf065e9673d.png

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

  1. क्वेरी कि प्राथमिकता वाले क्रेडेंशियल मौजूद हैं या नहीं (नीली, पहली पंक्ति)
  2. जवाब के आधार पर
  3. जीपीएस के लिए सुझाए गए क्रेडेंशियल पाएं (नीला, दूसरी पंक्ति)
  4. जीपीएस में टीबीआर क्रेडेंशियल सेट करें (नीली, तीसरी पंक्ति) -> अपना टीबीआर चुनें -> रैंडम तरीके से बनाएं -> नेटवर्क का नाम डालें -> ठीक है
  5. अब आपने पसंदीदा क्रेडेंशियल को सेट कर लिया है, तो RPi OTBR क्रेडेंशियल सेट करें का इस्तेमाल करके, उन्हें अपने OTBR पर सेट करें. ऐसा करने से, वे क्रेडेंशियल बाकी सेट पर लागू हो जाएंगे.

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

7. नतीजा

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

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

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

8. रेफ़रंस

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

DBUS