1. शुरू करने से पहले
हमारे Thread बॉर्डर राऊटर (TBR) कोडलैब में, हम Raspबेरी Pi पर आधारित थ्रेड बॉर्डर राऊटर बनाने का तरीका बता रहे हैं. उस कोडलैब में, हम
- Thread और वाई-फ़ाई/ईथरनेट नेटवर्क के बीच दोतरफ़ा आईपी कनेक्टिविटी बनाएं.
- mडीएनएस (वाई-फ़ाई/ईथरनेट लिंक पर) और एसआरपी (Thread नेटवर्क पर) की मदद से, दो-तरफ़ा सेवा की खोज की सुविधा उपलब्ध कराएं.
यह कोडलैब पिछले कोडलैब के साथ काम करता है. इससे यह पता चलता है कि आपका बॉर्डर राऊटर और आपका ऐप्लिकेशन, Google API के साथ किस तरह इंटरैक्ट करके एक Thread नेटवर्क बना सकता है. Thread के क्रेडेंशियल का इस्तेमाल करना ज़रूरी है, क्योंकि इससे नेटवर्क को बेहतर बनाने में मदद मिलती है. साथ ही, यह Thread पर आधारित ऐप्लिकेशन के साथ उपयोगकर्ता के इंटरैक्शन को आसान बनाता है.
ज़रूरी शर्तें
- OTBR कोडलैब की प्रोसेस पूरी करें
- Linux, Android/Kotlin, और Thread नेटवर्किंग की बुनियादी जानकारी
आपको इनके बारे में जानकारी मिलेगी
- क्रेडेंशियल सेट पाने और सेट करने के लिए, थ्रेड शेयर करने वाले एपीआई इस्तेमाल करने का तरीका
- Google के नेटवर्क जैसे क्रेडेंशियल से अपना OpenThread बॉर्डर राऊटर सेट अप करने का तरीका
आपको इन चीज़ों की ज़रूरत होगी
- Raspबेरी Pi 4 बोर्ड या Linux पर आधारित कोई अन्य बोर्ड, जिस पर Open Thread Border राऊटर (OTBR) चल रहा है
- यह बोर्ड, रेडियो को-प्रोसेसर (आरसीपी) के तौर पर आईईईई 802.15.4 कनेक्टिविटी की सुविधा देता है. OpenThread Github पेज पर अलग-अलग SoC वेंडर के डेटा स्टोर करने की जगहों की सूची और उनके निर्देश देखें
2. एचटीटीपी सेवा सेट अप की जा रही है
हमें सबसे पहले एक बिल्डिंग ब्लॉक की ज़रूरत होगी. यह इंटरफ़ेस हमें आपके OTBR पर ऐक्टिव क्रेडेंशियल पढ़ने और 'बाकी क्रेडेंशियल' लिखने की सुविधा देता है. TBR बनाते समय, अपने मालिकाना हक से जुड़े मैकेनिज़्म का इस्तेमाल करें, जैसा कि यहां दो उदाहरणों में बताया गया है. पहला विकल्प दिखाता है कि DBUS के ज़रिए, स्थानीय तौर पर OTBR एजेंट के साथ कैसे इंटरफ़ेस करें, जबकि दूसरा विकल्प, OTBR पर बनाए जा सकने वाले आराम एपीआई का इस्तेमाल करता है.
दोनों में से कोई भी तरीका सुरक्षित नहीं है और न ही इसे प्रोडक्शन एनवायरमेंट में इस्तेमाल किया जाना चाहिए. हालांकि, वेंडर किसी भी तरीके को प्रोडक्शन एनवायरमेंट में इस्तेमाल करने के लिए एन्क्रिप्शन तैयार कर सकता है या आपके पास लूपबैक एचटीटीपी या लोकली DBUS कॉल जारी करने के लिए अपनी खुद की मॉनिटर सेवा को बढ़ाने का विकल्प है.
पहला विकल्प: Python स्क्रिप्ट पर DBUS और एचटीटीपी एपीआई
यह चरण एक सामान्य HTTP सेवा बनाता है, जो क्रेडेंशियल को पढ़ने और सेट करने के लिए दो एंडपॉइंट दिखाता है और आखिरकार 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 अनुरोध करने के लिए, रूट पाथ पर ध्यान देता है. पेलोड, टीएलवी के साथ हमेशा 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 एजेंट नेटिव एचटीटीपी रेस्ट एपीआई
OpenThread बॉर्डर राऊटर डिफ़ॉल्ट रूप से, REST_API=1 फ़्लैग के साथ बनता है. इससे REST API चालू हो जाता है. अगर पिछले कोडलैब के बिल्ड में REST API चालू नहीं था, तो पक्का करें कि उस फ़्लैग की मदद से आपकी आरपीआई पर 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 की मदद से, आपके नेटवर्क की सभी TBR के लिए क्रेडेंशियल के रजिस्ट्रेशन की अनुमति दी जाती है. साथ ही, ऐसी उम्मीद की जाती है. हर कॉलम की पहचान, अपने बॉर्डर राऊटर एजेंट आईडी (बीएआईडी) से की जाती है. यह टास्क करने के लिए, आपको ThreadNetworkClient इंटरफ़ेस के addCredentials() तरीके का इस्तेमाल करना है. Google Play services के स्टोरेज में जोड़े गए सबसे पहले TBR, इस मोबाइल डिवाइस के लिए पसंदीदा क्रेडेंशियल तय करते हैं.
जो ऐप्लिकेशन अपने बीएआईडी में Thread नेटवर्क के क्रेडेंशियल का सेट जोड़ता है वह क्रेडेंशियल का मालिक बन जाता है और उसके पास उन्हें ऐक्सेस करने की सभी अनुमतियां होती हैं. अगर आप दूसरे ऐप्लिकेशन के जोड़े गए क्रेडेंशियल को ऐक्सेस करने की कोशिश करते हैं, तो आपको PERMISSION_DENIED गड़बड़ी मिलेगी. हालांकि, उपयोगकर्ता की सहमति पर, पसंदीदा क्रेडेंशियल किसी भी ऐप्लिकेशन के लिए हमेशा उपलब्ध होते हैं. हमारा सुझाव है कि Thread बॉर्डर राऊटर नेटवर्क के अपडेट होने पर, Google Play services में सेव किए गए क्रेडेंशियल को अप-टू-डेट रखें. हालांकि, उस जानकारी का इस्तेमाल आज नहीं किया जाता है, लेकिन हम आने वाले समय में बेहतर अनुभव दे सकते हैं.
अगर पहले TBR को बाद में हटा दिया जाता है, तो भी पसंदीदा क्रेडेंशियल Android डिवाइस पर मौजूद रहेंगे. इस सेट के बाद, Thread क्रेडेंशियल को मैनेज करने वाले अन्य ऐप्लिकेशन, getPreferredCredentials() कॉल से क्रेडेंशियल हासिल कर सकते हैं.
Google TBR सिंक
Android डिवाइस, Google TBR के साथ अपने-आप सिंक हो जाते हैं. अगर Android पर कोई क्रेडेंशियल मौजूद नहीं है, तो डिवाइस उन्हें आपके नेटवर्क में मौजूद Google TBR से निकाल देते हैं. इसके बाद, वे क्रेडेंशियल पसंदीदा क्रेडेंशियल बन जाते हैं. TBR और Android डिवाइस के बीच सिंक करने की प्रोसेस सिर्फ़ तब होती है, जब TBR को एक ही उपयोगकर्ता के साथ जोड़ा गया हो या एक ही स्मार्ट होम ( स्ट्रक्चर) में मौजूद दो उपयोगकर्ताओं से जोड़ा गया हो.
यह प्रोसेस तब भी होगी, जब Google का कोई दूसरा उपयोगकर्ता Android के लिए GHA या iOS के लिए GHA का इस्तेमाल कर रहा हो. हालांकि, ऐसा तब होगा, जब वह उपयोगकर्ता उसी स्ट्रक्चर में हो. iOS के लिए GHA के मामले में, अगर कोई पसंदीदा क्रेडेंशियल मौजूद नहीं है, तो iOS स्टोरेज पर पसंदीदा क्रेडेंशियल सेट किए जाते हैं.
अगर एक ही नेटवर्क में पसंदीदा क्रेडेंशियल के अलग-अलग सेट के साथ दो Android डिवाइस (या Android + iGHA) मौजूद हैं, तो TBR पर मूल रूप से TBR को कॉन्फ़िगर किया गया डिवाइस ही मान्य होगा.
तीसरे पक्ष का टीबीआर शामिल करना
फ़िलहाल, क्रेडेंशियल की मेमोरी, उपयोगकर्ता के स्मार्ट होम ( स्ट्रक्चर) के दायरे में नहीं आती है. हर Android डिवाइस का बीएआईडी स्टोरेज उपलब्ध होगा. नेटवर्क में Google TBR सेट होने के बाद, iOS के लिए Google Home ऐप्लिकेशन पर चलने वाले अन्य Android डिवाइस और iOS डिवाइस, उस डिवाइस के स्टोरेज के साथ सिंक हो जाएंगे. साथ ही, फ़ोन के स्टोरेज के लिए लोकल क्रेडेंशियल सेट करने की कोशिश करेंगे.
किसी नए OOB TBR नेटवर्क को बनाने से पहले, यह देखना ज़रूरी है कि Android के स्टोरेज में कोई पसंदीदा नेटवर्क पहले से मौजूद है या नहीं.
- अगर कोई पसंदीदा नेटवर्क मौजूद है, तो वेंडर को उसका इस्तेमाल करना चाहिए. इससे यह पक्का होता है कि जब भी मुमकिन हो, Thread डिवाइस किसी एक Thread नेटवर्क से कनेक्ट किए गए हों.
- जब कोई पसंदीदा नेटवर्क मौजूद न हो, तो नया क्रेडेंशियल सेट बनाएं और उसे Google Play Services में अपने TBR को असाइन करें. Android, इन क्रेडेंशियल को Google के सभी TBR पर सेट किए गए स्टैंडर्ड क्रेडेंशियल के तौर पर इस्तेमाल करेगा. साथ ही, अन्य वेंडर अन्य डिवाइसों के साथ, मेश नेटवर्क की पहुंच और मज़बूती को बेहतर बना पाएंगे
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) से ऐप्लिकेशन चलाएं
- व्हील -> डेवलपर सुविधाएं -> Thread नेटवर्क पर जाएं
- उपलब्ध अलग-अलग विकल्पों का इस्तेमाल करें. नीचे दिए गए सेक्शन में, हम हर बटन पर एक्ज़ीक्यूट होने वाले कोड को अनपैक करेंगे.
क्या पसंदीदा क्रेडेंशियल मौजूद हैं?
TBR मैन्युफ़ैक्चरर को Google से पहला सवाल पूछना चाहिए कि क्या डिवाइस में क्रेडेंशियल का पसंदीदा सेट पहले से मौजूद है. यह आपके फ़्लो का शुरुआती पॉइंट होना चाहिए. नीचे दिया गया कोड, क्रेडेंशियल के existance के बारे में जीपीएस से क्वेरी करता है. यह उपयोगकर्ता की सहमति के लिए नहीं कहता है, क्योंकि कोई क्रेडेंशियल शेयर नहीं किया गया है.
/**
* 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?> पर क्रेडेंशियल पोस्ट करने के बारे में नीचे बताया गया है.
जीपीएस क्रेडेंशियल सेट करना
भले ही आपका TBR मौजूद हो या न हो, आपको उसे Google Play Services में रजिस्टर करना चाहिए. आपके ऐप्लिकेशन के पास सिर्फ़ आपके TBR के बॉर्डर एजेंट आईडी से जुड़े क्रेडेंशियल पढ़ने का विकल्प होगा. हालांकि, अगर आपका TBR सबसे पहले रजिस्टर होता है, तो उन क्रेडेंशियल को पसंदीदा क्रेडेंशियल सेट में कॉपी किया जाएगा. इस जानकारी को फ़ोन पर मौजूद कोई भी ऐप्लिकेशन तब तक ऐक्सेस कर सकता है, जब तक उपयोगकर्ता इसकी अनुमति देता है.
/**
* 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 HTTP बाकी सर्वर या OTBR के नेटिव एचटीटीपी रेस्ट सर्वर के ज़रिए लागू करते हैं.
/**
* 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 प्रॉडक्ट से क्रेडेंशियल लेना
जैसा कि पहले दिखाया गया है, अपने TBR से क्रेडेंशियल हासिल करने के लिए, GET एचटीटीपी वर्ब का इस्तेमाल करें. Python स्क्रिप्ट का सैंपल देखें.
बिल्ड और इंपोर्ट करना
अपना Android ऐप्लिकेशन बनाते समय, आपको Google Play Services Thread मॉड्यूल के साथ काम करने के लिए, अपने मेनिफ़ेस्ट, बिल्ड, और इंपोर्ट में बदलाव करने होंगे. नीचे दिए गए तीन स्निपेट, ज़्यादातर सुविधाओं के बारे में खास जानकारी देते हैं.
ध्यान दें कि हमारा सैंपल ऐप्लिकेशन, मुख्य रूप से 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. एमडीएनएस/एसडी डिस्कवरी
सैंपल के तौर पर उपलब्ध हमारा ऐप्लिकेशन, नेटवर्क में उपलब्ध Thread Border राऊटर और उनसे जुड़े बीएआईडी की सूची बनाने के लिए, mडीएनएस/एसडी डिस्कवरी का इस्तेमाल करता है.
यह आपके GPS क्रेडेंशियल के स्टोरेज में TBR की जानकारी डालते समय बहुत मददगार साबित होता है. हालांकि, इसका इस्तेमाल इस कोडलैब के दायरे से बाहर है. हम 'Android सर्विस डिस्कवरी लाइब्रेरी' NSDManager का इस्तेमाल करते हैं. पूरे सोर्स कोड को सैंपल ऐप्लिकेशन में ServiceDiscovery.kt में देखा जा सकता है.
6. सारा खर्च एक साथ जोड़ना
इन कॉल को लागू करने या सैंपल ऐप्लिकेशन का इस्तेमाल करने के बाद, अपने RPi OTBR को पूरी तरह से शामिल किया जा सकता है. हमारे सैंपल ऐप्लिकेशन में आठ बटन दिखते हैं:
आपके TBR को शामिल करने के लिए इनमें से कोई क्रम हो सकता है:
- क्वेरी: प्राथमिकता वाले क्रेडेंशियल मौजूद हैं या नहीं (नीली, पहली पंक्ति)
- जवाब के आधार पर
- जीपीएस के लिए प्राथमिकता वाले क्रेडेंशियल पाएं (नीला, दूसरी लाइन)
- जीपीएस में TBR क्रेडेंशियल सेट करें (नीली और तीसरी लाइन) -> अपना TBR चुनें -> रैंडम बनाएं -> नेटवर्क का नाम डालें -> ठीक है
- अब आपके पास पसंदीदा क्रेडेंशियल हो गए हैं, तो RPi OTBR क्रेडेंशियल सेट करें का इस्तेमाल करके, उन्हें अपने OTBR पर सेट करें. इससे वे क्रेडेंशियल, बाद में किए गए सेट पर लागू हो जाएंगे.
सैंपल ऐप्लिकेशन के लिए, डिफ़ॉल्ट रूप से यह अवधि 10 सेकंड की होती है. इसलिए, इस अवधि के बाद आपके RPi TBR (और इसके नेटवर्क पर मौजूद अन्य नोड) के क्रेडेंशियल, नए डेटासेट पर माइग्रेट हो जाएंगे.
7. नतीजा
इस कोडलैब में, हमने Android ऐप्लिकेशन के नमूने का क्लोन बनाया है. साथ ही, कोड के ऐसे कई स्निपेट की जांच की है जो Google Play Services के Thread Storage API का इस्तेमाल करते हैं. हमने उन एपीआई का इस्तेमाल एक सामान्य डेटासेट के लिए किया, जिसे हम RPi TBR पर सेट कर सकते हैं. इस डेटासेट को वेंडर का TBR दिखाता है.
किसी उपयोगकर्ता के सभी TBR को एक ही नेटवर्क में होने से, Thread नेटवर्क को बेहतर तरीके से इस्तेमाल किया जा सकता है. साथ ही, इसकी पहुंच भी बेहतर होती है. इससे, उपयोगकर्ता के अनुभव में गड़बड़ी को भी रोका जाता है. ऐसा तब होता है, जब ऐप्लिकेशन Thread डिवाइस को शामिल नहीं कर पाते हैं, क्योंकि उनके पास क्रेडेंशियल का ऐक्सेस नहीं होता है.
हमें उम्मीद है कि इस कोडलैब और ऐप्लिकेशन के सैंपल से, आपको अपना ऐप्लिकेशन और Thread Border राऊटर प्रॉडक्ट डिज़ाइन करने और डेवलप करने में मदद मिलेगी.
8. References
आरसीपी को-प्रोसेसर
डीबीयूएस