1. शुरू करने से पहले
थ्रेड बॉर्डर राउटर (टीबीआर) कोडलैब में, हम Raspberry Pi पर आधारित थ्रेड बॉर्डर राउटर बनाने का तरीका बताते हैं. उस कोडलैब में हमने
- Thread और वाई-फ़ाई/ईथरनेट नेटवर्क के बीच, दोनों तरफ़ से आईपी कनेक्शन सेट अप करना.
- mDNS (वाई-फ़ाई/इथरनेट लिंक पर) और SRP (थ्रेड नेटवर्क पर) के ज़रिए, सेवा की जानकारी को दोनों तरफ़ से खोजने की सुविधा दें.
यह कोडलैब, पिछले कोडलैब पर आधारित है. इसमें बताया गया है कि सिंगल थ्रेड नेटवर्क बनाने के लिए, आपका बॉर्डर राउटर और ऐप्लिकेशन, Google के एपीआई के साथ कैसे इंटरैक्ट कर सकते हैं. Thread के क्रेडेंशियल को एक ही जगह पर सेव करना ज़रूरी है, क्योंकि इससे नेटवर्क की परफ़ॉर्मेंस बेहतर होती है. साथ ही, Thread पर काम करने वाले ऐप्लिकेशन के साथ उपयोगकर्ताओं के इंटरैक्शन को आसान बनाता है.
ज़रूरी शर्तें
- OTBR कोडलैब पूरा करें
- Linux, Android/Kotlin, और Thread नेटवर्किंग के बारे में बुनियादी जानकारी
आपको क्या सीखने को मिलेगा
- क्रेडेंशियल सेट पाने और सेट करने के लिए, Thread Sharing API का इस्तेमाल करने का तरीका
- Google के नेटवर्क के क्रेडेंशियल का इस्तेमाल करके, अपना OpenThread बॉर्डर राउटर सेट अप करने का तरीका
आपको किन चीज़ों की ज़रूरत होगी
- Raspberry Pi 4 बोर्ड या Open Thread Border Router (OTBR) चलाने वाला कोई अन्य Linux-based बोर्ड
- बोर्ड, जो रेडियो को-प्रोसेसर (आरसीपी) के तौर पर IEEE 802.15.4 कनेक्टिविटी देता है. OpenThread के GitHub पेज पर, अलग-अलग SoC वेंडर के डेटा स्टोर करने की जगहों की सूची और उनके निर्देश देखें
2. एचटीटीपी सेवा सेट अप करना
हमें सबसे पहले एक ऐसा इंटरफ़ेस चाहिए जिसकी मदद से, हम ऐक्टिव क्रेडेंशियल पढ़ सकें और आपके ओटीबीआर में, पुष्टि बाकी क्रेडेंशियल डाल सकें. टीबीआर बनाते समय, अपने मालिकाना हक वाले तरीकों का इस्तेमाल करें. यहां दो उदाहरणों के साथ दिखाया गया है. पहले विकल्प में, DBUS के ज़रिए स्थानीय तौर पर OTBR एजेंट के साथ इंटरफ़ेस करने का तरीका बताया गया है. वहीं, दूसरे विकल्प में उस Rest API का फ़ायदा लिया गया है जिसे OTBR पर बनाया जा सकता है.
इनमें से कोई भी तरीका सुरक्षित नहीं है. इसलिए, प्रोडक्शन एनवायरमेंट में इनका इस्तेमाल नहीं किया जाना चाहिए. हालांकि, कोई वेंडर प्रोडक्शन एनवायरमेंट में इस्तेमाल करने के लिए, इनमें से किसी भी तरीके के हिसाब से एन्क्रिप्शन बना सकता है. इसके अलावा, लूपबैक एचटीटीपी या डिफ़ॉल्ट रूप से स्थानीय डीबीयूएस कॉल जारी करने के लिए, अपनी मॉनिटर सेवा को बढ़ाया जा सकता है.
पहला विकल्प: Python स्क्रिप्ट पर DBUS और एचटीटीपी एपीआई
इस चरण में, एक ऐसी एचटीटीपी सेवा बनाई जाती है जिसमें क्रेडेंशियल पढ़ने और सेट करने के लिए दो एंडपॉइंट होते हैं. आखिर में, यह DBUS निर्देशों को कॉल करती है.
उस 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 में थ्रेड के लिए मंज़ूरी बाकी होने की स्थिति वाले नए क्रेडेंशियल सेट करता है. इस मामले में, 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 एजेंट का नेटिव एचटीटीपी REST API
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, आपके नेटवर्क में मौजूद सभी टीबीआर के लिए क्रेडेंशियल रजिस्टर करने की अनुमति देता है और ऐसा करने की उम्मीद करता है. हर बॉर्डर राऊटर एजेंट की पहचान, उसके बॉर्डर राऊटर एजेंट आईडी (BAID) से की जाती है. यह काम करने के लिए, आपको ThreadNetworkClient इंटरफ़ेस के addCredentials() तरीके का इस्तेमाल करना होगा. Google Play services के स्टोरेज में जोड़ा गया पहला टीबीआर, इस मोबाइल डिवाइस के लिए पसंदीदा क्रेडेंशियल तय करता है.
जो ऐप्लिकेशन अपने बीएआईडी में Thread नेटवर्क क्रेडेंशियल का सेट जोड़ता है वह क्रेडेंशियल का मालिक बन जाता है. साथ ही, उसके पास उन्हें ऐक्सेस करने की सभी अनुमतियां होती हैं. अगर दूसरे ऐप्लिकेशन से जोड़े गए क्रेडेंशियल ऐक्सेस करने की कोशिश की जाती है, तो आपको PERMISSION_DENIED गड़बड़ी का मैसेज मिलेगा. हालांकि, उपयोगकर्ता की सहमति मिलने पर, पसंदीदा क्रेडेंशियल किसी भी ऐप्लिकेशन के लिए हमेशा उपलब्ध रहते हैं. हमारा सुझाव है कि Thread Border Router नेटवर्क अपडेट होने पर, Google Play services में सेव किए गए क्रेडेंशियल अप-टू-डेट रखें. फ़िलहाल, इस जानकारी का इस्तेमाल नहीं किया जाता है. हालांकि, आने वाले समय में हम बेहतर अनुभव देने के लिए, इस जानकारी का इस्तेमाल कर सकते हैं.
भले ही, पहले टीबीआर को बाद में हटा दिया जाए, लेकिन Android डिवाइस पर पसंदीदा क्रेडेंशियल सेव रहेंगे. सेट होने के बाद, Thread के क्रेडेंशियल मैनेज करने वाले अन्य ऐप्लिकेशन, getPreferredCredentials() कॉल से क्रेडेंशियल हासिल कर सकते हैं.
Google TBR Sync
Android डिवाइस, Google के टीबीआर के साथ अपने-आप सिंक हो जाते हैं. अगर Android पर कोई क्रेडेंशियल मौजूद नहीं है, तो डिवाइस आपके नेटवर्क में मौजूद Google TBRs से क्रेडेंशियल निकालते हैं. ये क्रेडेंशियल, डिवाइसों के लिए पसंदीदा क्रेडेंशियल बन जाते हैं. टीबीआर और Android डिवाइस के बीच सिंक करने की सुविधा सिर्फ़ तब काम करती है, जब टीबीआर को किसी एक उपयोगकर्ता के साथ जोड़ा गया हो या फिर उसे दो ऐसे उपयोगकर्ताओं के साथ जोड़ा गया हो जो एक ही स्मार्ट होम (स्ट्रक्चर) में हों.
यह प्रोसेस तब भी होगी, जब कोई दूसरा Google उपयोगकर्ता, Android के लिए GHA या iOS के लिए GHA का इस्तेमाल कर रहा हो और वह उपयोगकर्ता उसी स्ट्रक्चर में हो. iOS के लिए GHA के मामले में, अगर कोई पसंदीदा क्रेडेंशियल मौजूद नहीं है, तो iOS स्टोरेज पर पसंदीदा क्रेडेंशियल सेट किए जाते हैं.
अगर एक ही नेटवर्क में दो Android डिवाइस (या Android + iGHA) मौजूद हैं और उनके पास पसंदीदा क्रेडेंशियल के अलग-अलग सेट हैं, तो टीबीआर पर वह डिवाइस लागू होगा जिसने मूल रूप से टीबीआर को कॉन्फ़िगर किया था.
तीसरे पक्ष के टीबीआर को ऑनबोर्ड करना
फ़िलहाल, क्रेडेंशियल का स्टोरेज, उपयोगकर्ता के स्मार्ट होम (स्ट्रक्चर) के दायरे में नहीं आता. हर Android डिवाइस में BAID स्टोरेज होगा. हालांकि, नेटवर्क में Google TBR होने पर, iOS के लिए Google Home ऐप्लिकेशन चलाने वाले अन्य Android डिवाइस और iOS डिवाइस उस TBR के साथ सिंक हो जाएंगे. साथ ही, वे फ़ोन के स्टोरेज में स्थानीय क्रेडेंशियल सेट करने की कोशिश करेंगे.
नया ओओबी टीबीआर नेटवर्क बनाने से पहले, यह देखना ज़रूरी है कि Android के स्टोरेज में कोई पसंदीदा नेटवर्क पहले से मौजूद है या नहीं.
- अगर कोई पसंदीदा नेटवर्क मौजूद है, तो वेंडर को उसका इस्तेमाल करना चाहिए. इससे यह पक्का होता है कि Thread डिवाइस, जहां तक हो सके एक ही Thread नेटवर्क से कनेक्ट हों.
- अगर कोई पसंदीदा नेटवर्क मौजूद नहीं है, तो नया क्रेडेंशियल सेट बनाएं और उसे Google Play services में अपने टीबीआर को असाइन करें. Android, उन क्रेडेंशियल को Google के सभी टीबीआर पर सेट किए गए स्टैंडर्ड क्रेडेंशियल के तौर पर स्वीकार करेगा. साथ ही, दूसरे वेंडर अन्य डिवाइसों की मदद से, आपके मेश की पहुंच और बेहतर बनाने में मदद कर पाएंगे
4. अपने Android ऐप्लिकेशन को क्लोन करना और उसमें बदलाव करना
हमने एक Android ऐप्लिकेशन बनाया है, जो Thread API के मुख्य कॉल दिखाता है. इन पैटर्न का इस्तेमाल अपने ऐप्लिकेशन में किया जा सकता है. इस कोडलैब में, हम Github से Matter के लिए Google Home के सैंपल ऐप्लिकेशन को क्लोन करेंगे.
यहां दिखाया गया सारा सोर्स कोड, सैंपल ऐप्लिकेशन में पहले से कोड किया गया है. हम आपको इसे अपनी ज़रूरतों के हिसाब से बदलने का न्योता देते हैं. हालांकि, फ़ंक्शन की जांच करने के लिए, ऐप्लिकेशन को क्लोन किया जा सकता है या पहले से बनी बाइनरी को चलाया जा सकता है.
- इसका क्लोन बनाने के लिए, इनका इस्तेमाल करें:
$ 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 में रजिस्टर करना चाहिए. आपका ऐप्लिकेशन ही आपके टीबीआर के बॉर्डर एजेंट आईडी से जुड़े क्रेडेंशियल पढ़ पाएगा. हालांकि, अगर आपका टीबीआर पहले रजिस्टर होता है, तो उन क्रेडेंशियल को 'पसंदीदा क्रेडेंशियल' सेट में कॉपी कर दिया जाएगा. जब तक उपयोगकर्ता अनुमति देता है, तब तक फ़ोन पर मौजूद कोई भी ऐप्लिकेशन इस जानकारी को ऐक्सेस कर सकता है.
/**
* 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 एचटीटीपी REST सर्वर या OTBR के नेटिव एचटीटीपी REST सर्वर की मदद से लागू करते हैं.
/**
* 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 एचटीटीपी वर्ब का इस्तेमाल करें. 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/एसडी डिस्कवरी
हमारा सैंपल ऐप्लिकेशन, नेटवर्क में उपलब्ध थ्रेड बॉर्डर राउटर की सूची बनाने के लिए, mDNS/SD डिस्कवरी का इस्तेमाल करता है. साथ ही, उनके BAID की भी सूची बनाता है.
जीपीएस क्रेडेंशियल के स्टोरेज में अपने टीबीआर की जानकारी डालते समय, यह सुविधा काफ़ी मददगार होती है. हालांकि, इसका इस्तेमाल इस कोडलैब के दायरे से बाहर है. हम Android Service Discovery लाइब्रेरी NSDManager का इस्तेमाल करते हैं. इसका पूरा सोर्स कोड, सैंपल ऐप्लिकेशन में ServiceDiscovery.kt में उपलब्ध है.
6. सारा खर्च एक साथ जोड़ना
इन कॉल को लागू करने या सैंपल ऐप्लिकेशन का इस्तेमाल करने के बाद, अपने RPi OTBR को पूरी तरह से शामिल किया जा सकता है. हमारे सैंपल ऐप्लिकेशन में आठ बटन हैं:
टीबीआर को शामिल करने का संभावित क्रम:
- क्वेरी करें कि प्राथमिक क्रेडेंशियल मौजूद हैं या नहीं (नीली, पहली पंक्ति)
- जवाब के आधार पर
- जीपीएस के लिए पसंदीदा क्रेडेंशियल पाना (नीला, दूसरी पंक्ति)
- जीपीएस में टीबीआर क्रेडेंशियल सेट करें (नीले रंग में, तीसरी लाइन) -> अपना टीबीआर चुनें -> रैंडम बनाएं -> नेटवर्क का नाम डालें -> ठीक है
- अब आपके पास पसंदीदा क्रेडेंशियल हैं. RPi OTBR क्रेडेंशियल सेट करें का इस्तेमाल करके, उन्हें अपने OTBR पर सेट करें. इससे वे क्रेडेंशियल, बाकी बचे सेट पर लागू हो जाएंगे.
सैंपल ऐप्लिकेशन के लिए, डिफ़ॉल्ट रूप से 10 सेकंड की देरी का इस्तेमाल किया जाता है. इसलिए, इस अवधि के बाद, आपके RPi TBR (और उसके नेटवर्क पर मौजूद अन्य नोड) के क्रेडेंशियल, नए डेटासेट में माइग्रेट हो जाएंगे.
7. नतीजा
इस कोडलैब में, हमने एक सैंपल Android ऐप्लिकेशन का क्लोन बनाया है. साथ ही, Google Play services के Thread Storage API का इस्तेमाल करने वाले कोड के कई स्निपेट का विश्लेषण किया है. हमने उन एपीआई का इस्तेमाल करके एक सामान्य डेटासेट बनाया, जिसे RPi TBR पर शामिल किया जा सकता है. यह वेंडर का टीबीआर दिखाता है.
जब किसी उपयोगकर्ता के सभी टीबीआर एक ही नेटवर्क से जुड़े होते हैं, तो थ्रेड नेटवर्क की पहुंच और परफ़ॉर्मेंस बेहतर होती है. इससे उपयोगकर्ताओं को बेहतर अनुभव मिलता है. ऐसा तब होता है, जब ऐप्लिकेशन Thread डिवाइसों को शामिल नहीं कर पाते, क्योंकि उनके पास क्रेडेंशियल का ऐक्सेस नहीं होता.
हमें उम्मीद है कि इस कोडलैब और सैंपल ऐप्लिकेशन से, आपको अपना ऐप्लिकेशन और Thread Border Router प्रॉडक्ट डिज़ाइन और डेवलप करने में मदद मिलेगी.
8. रेफ़रंस
आरसीपी को-प्रोसेसर
DBUS