หน้านี้ได้รับการแปลโดย Cloud Translation API

การแชร์เครือข่ายเทรดด้วย API ข้อมูลเข้าสู่ระบบเทรดของ Google

1. ก่อนเริ่มต้น

ใน Codelab ของ Thread Border Router (TBR) เราจะแสดงวิธีสร้าง Thread Border Router โดยอิงตาม Raspberry Pi ใน Codelab นั้น

สร้างการเชื่อมต่อ IP แบบ 2 ทิศทางระหว่างเครือข่าย Thread กับ Wi-Fi/อีเทอร์เน็ต
ให้บริการค้นหาบริการแบบ 2 ทิศทางผ่าน mDNS (ในลิงก์ Wi-Fi/อีเทอร์เน็ต) และ SRP (ในเครือข่ายเทรด)

โค้ดแล็บนี้ต่อยอดจากโค้ดแล็บก่อนหน้า โดยอธิบายวิธีที่ Border Router และแอปของคุณโต้ตอบกับ Google API เพื่อสร้างเครือข่ายเทรดแบบเดียว การรวมข้อมูลเข้าสู่ระบบเทรดเป็นสิ่งสำคัญเนื่องจากจะช่วยเพิ่มความเสถียรของเครือข่ายและลดความซับซ้อนในการโต้ตอบของผู้ใช้กับแอปพลิเคชันที่อาศัยเทรด

ข้อกำหนดเบื้องต้น

ทำ OTBR Codelab ให้เสร็จสมบูรณ์
ความรู้พื้นฐานเกี่ยวกับ Linux, Android/Kotlin และเครือข่ายเทรด

สิ่งที่คุณจะได้เรียนรู้

วิธีใช้ Thread Sharing API เพื่อรับและตั้งค่าชุดข้อมูลเข้าสู่ระบบ
วิธีตั้งค่า Border Router แบบ OpenThread ของคุณเองด้วยข้อมูลเข้าสู่ระบบเดียวกับเครือข่ายของ Google

สิ่งที่คุณต้องมี

บอร์ด Raspberry Pi 4 หรือบอร์ดที่ใช้ Linux อื่นที่ใช้ Open Thread Border Router (OTBR)
บอร์ดที่ให้การเชื่อมต่อ IEEE 802.15.4 ในฐานะตัวประมวลผลร่วมแบบไร้สาย (RCP) ดูรายการที่เก็บของผู้ให้บริการ SoC รายต่างๆ และวิธีการในหน้า GitHub ของ OpenThread

2. การตั้งค่าบริการ HTTP

องค์ประกอบพื้นฐานแรกที่เราต้องมีคืออินเทอร์เฟซที่ช่วยให้เราสามารถอ่านข้อมูลเข้าสู่ระบบที่ใช้งานอยู่และเขียนข้อมูลเข้าสู่ระบบที่รอดำเนินการไปยัง OTBR ได้ เมื่อสร้าง TBR ให้ใช้กลไกที่เป็นกรรมสิทธิ์ของคุณเอง ดังที่แสดงที่นี่พร้อมตัวอย่าง 2 ตัวอย่าง ตัวเลือกแรกแสดงวิธีเชื่อมต่อกับตัวแทน OTBR ในเครื่องผ่าน DBUS ส่วนตัวเลือกที่ 2 ใช้ประโยชน์จาก Rest API ที่สามารถสร้างใน OTBR

วิธีการทั้ง 2 อย่างนี้ไม่ปลอดภัยและไม่ควรนำมาใช้แบบเดิมในสภาพแวดล้อมที่ใช้งานจริง อย่างไรก็ตาม ผู้ให้บริการสามารถสร้างการเข้ารหัสสำหรับวิธีการใดวิธีการหนึ่งเพื่อใช้ในสภาพแวดล้อมการทำงานจริง หรือคุณจะขยายบริการตรวจสอบของคุณเองเพื่อออก HTTP loopback หรือการเรียก DBUS ในเครื่องโดยพื้นฐานก็ได้

ตัวเลือกที่ 1: DBUS และ HTTP API ในสคริปต์ Python

ขั้นตอนนี้จะสร้างบริการ HTTP พื้นฐานที่แสดงปลายทาง 2 แห่งเพื่ออ่านและตั้งค่าข้อมูลเข้าสู่ระบบ ซึ่งจะเรียกใช้คำสั่ง DBUS ในท้ายที่สุด

ใน RPi ที่จะใช้เป็น OTBR ให้ติดตั้งข้อกำหนดเบื้องต้นของ Python 3 ดังนี้

$ pip install dbus-python shlex json

เรียกใช้สคริปต์โดยทำดังนี้

$  sudo python credentials_server.py 8081
serving at port 8081

ตัวอย่างนี้จะตั้งค่าเซิร์ฟเวอร์ HTTP ในพอร์ต 8081 และรอรับคำขอ GET เพื่อดึงข้อมูลเข้าสู่ระบบของ Thread หรือคำขอ POST เพื่อตั้งค่าข้อมูลเข้าสู่ระบบของ Thread ในเส้นทางรูท เพย์โหลดจะเป็นโครงสร้าง JSON ที่มี TLV เสมอ

คําขอ PUT ต่อไปนี้จะตั้งค่าข้อมูลเข้าสู่ระบบชุดใหม่ของชุดข้อความที่รอดําเนินการให้กับ OTBR โดยใช้เส้นทาง /node/dataset/pending ในกรณีนี้ ระบบจะใช้ข้อมูลเข้าสู่ระบบที่รอดำเนินการใน 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
}

คําขอ GET ไปยัง /node/dataset/active จะดึงข้อมูลเข้าสู่ระบบที่ใช้งานอยู่ในปัจจุบัน

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

สคริปต์เรียกใช้คำสั่ง R/W ของ DBUS ไปยังเส้นทางบัส io.openthread.BorderRouter.wpan0, เส้นทางออบเจ็กต์ /io/openthread/BorderRouter/wpan0

# 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 ช่วยให้ตรวจสอบความสามารถของ DBUS ได้ โดยคุณอาจดำเนินการดังนี้

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

นอกจากนี้ คุณยังดูความสามารถที่รองรับซึ่งระบุไว้ในเอกสารประกอบได้ที่นี่

ตัวเลือกที่ 2: HTTP Rest API ของตัวแทน OTBR

OpenThread Border Router จะสร้างโดยค่าเริ่มต้นด้วย Flag REST_API=1 ซึ่งจะเปิดใช้ REST API ในกรณีที่บิลด์จากโค้ดแล็บก่อนหน้านี้ไม่ได้เปิดใช้ REST API โปรดตรวจสอบว่าได้สร้าง OTBR ใน RPi ด้วย Flag ดังกล่าว

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

คุณสามารถรีสตาร์ทตัวแทน OTBR ได้โดยเรียกใช้คำสั่งต่อไปนี้

$ sudo systemctl restart otbr-agent.service

ตัวแทนจะเริ่มเซิร์ฟเวอร์ HTTP ในพอร์ต 8081 เซิร์ฟเวอร์นี้ช่วยให้ผู้ใช้หรือโปรแกรมตรวจสอบทำงานหลายอย่างใน OTBR ได้ (มีเอกสารประกอบที่นี่) คุณสามารถใช้เบราว์เซอร์ curl หรือ wget เพื่อตรวจสอบเนื้อหาได้ เส้นทางที่รองรับจำนวนมากรวมถึง Use Case ที่อธิบายไว้ข้างต้น ซึ่งมีคํากริยา GET ใน /node/dataset/active และคํากริยา PUT ใน /node/dataset/pending

3. การตั้งค่าเฟรมเวิร์กข้อมูลเข้าสู่ระบบใน Android

ข้อมูลเข้าสู่ระบบที่ต้องการ

บริการ Google Play ใน Android อนุญาตและคาดหวังให้มีการลงทะเบียนข้อมูลเข้าสู่ระบบสำหรับ TBR ทั้งหมดในเครือข่าย โดยแต่ละรายการจะระบุด้วยรหัสตัวแทน Border Router (BAID) คุณจะใช้เมธอด addCredentials() ของอินเทอร์เฟซ ThreadNetworkClient เพื่อทำงานนี้ TBR รายการแรกที่เพิ่มลงในพื้นที่เก็บข้อมูลบริการ Google Play จะกำหนดข้อมูลเข้าสู่ระบบที่ต้องการสำหรับอุปกรณ์เคลื่อนที่นี้

แอปที่เพิ่มชุดข้อมูลเข้าสู่ระบบเครือข่ายเทรดไปยัง BAID ของตนจะกลายเป็นเจ้าของข้อมูลเข้าสู่ระบบดังกล่าว และมีสิทธิ์เต็มรูปแบบในการเข้าถึงข้อมูลดังกล่าว หากพยายามเข้าถึงข้อมูลเข้าสู่ระบบที่แอปอื่นเพิ่มไว้ คุณจะได้รับข้อผิดพลาด PERMISSION_DENIED อย่างไรก็ตาม ข้อมูลเข้าสู่ระบบที่ต้องการจะพร้อมใช้งานสำหรับแอปใดก็ได้เมื่อผู้ใช้ให้ความยินยอม เราขอแนะนำให้คุณอัปเดตข้อมูลเข้าสู่ระบบที่จัดเก็บไว้ในบริการ Google Play อยู่เสมอเมื่อมีการอัปเดตเครือข่าย Border Router ของเทรด แม้ว่าปัจจุบันเราจะไม่ได้ใช้ข้อมูลดังกล่าว แต่เราอาจมอบเส้นทางที่ปรับปรุงแล้วในอนาคต

แม้ว่าจะมีการยกเว้น TBR รายการแรกในภายหลัง แต่ข้อมูลเข้าสู่ระบบที่ต้องการจะยังคงอยู่ในอุปกรณ์ Android เมื่อตั้งค่าแล้ว แอปอื่นๆ ที่จัดการข้อมูลเข้าสู่ระบบเทรดอาจรับข้อมูลเข้าสู่ระบบจากการเรียกใช้ getPreferredCredentials()

Google TBR Sync

อุปกรณ์ Android จะซิงค์กับ TBR ของ Google โดยอัตโนมัติ หากไม่มีข้อมูลเข้าสู่ระบบใน Android อุปกรณ์จะดึงข้อมูลเข้าสู่ระบบจาก TBR ของ Google ในเครือข่าย และข้อมูลเข้าสู่ระบบเหล่านั้นจะกลายเป็นข้อมูลเข้าสู่ระบบที่ต้องการ การซิงค์ระหว่าง TBR กับอุปกรณ์ Android จะดำเนินการก็ต่อเมื่อ TBR จับคู่กับผู้ใช้เพียงคนเดียว หรือจับคู่กับผู้ใช้ 2 รายที่อยู่ในสมาร์ทโฮม (โครงสร้าง) เดียวกัน

กระบวนการนี้จะเกิดขึ้นเมื่อผู้ใช้ Google รายอื่นใช้ GHA สําหรับ Android หรือ GHA สําหรับ iOS เมื่อผู้ใช้อยู่ในโครงสร้างเดียวกันด้วย ในกรณีของ GHA สำหรับ iOS ระบบจะตั้งค่าข้อมูลเข้าสู่ระบบที่ต้องการไว้ในพื้นที่เก็บข้อมูลของ iOS หากไม่มีข้อมูลเข้าสู่ระบบที่ต้องการ

หากมีอุปกรณ์ Android 2 เครื่อง (หรือ Android + iGHA) อยู่ในเครือข่ายเดียวกันโดยใช้ชุดข้อมูลเข้าสู่ระบบที่ต้องการต่างกัน อุปกรณ์ที่กําหนดค่า TBR ไว้ตั้งแต่แรกจะมีสิทธิ์ใช้ TBR นั้น

การเริ่มต้นใช้งาน TBR ของบุคคลที่สาม

ปัจจุบันพื้นที่เก็บข้อมูลของข้อมูลเข้าสู่ระบบไม่ได้อยู่ในขอบเขตของสมาร์ทโฮมของผู้ใช้ (โครงสร้าง) อุปกรณ์ Android แต่ละเครื่องจะมีพื้นที่เก็บข้อมูล BAID แต่เมื่อมี TBR ของ Google ในเครือข่าย อุปกรณ์ Android และอุปกรณ์ iOS เครื่องอื่นๆ ที่ใช้แอป Google Home สำหรับ iOS จะซิงค์กับ TBR นั้นและพยายามตั้งค่าข้อมูลเข้าสู่ระบบในเครื่องในพื้นที่เก็บข้อมูลของโทรศัพท์

ก่อนให้ TBR ใหม่แบบ OOB สร้างเครือข่าย คุณควรตรวจสอบว่าเครือข่ายที่ต้องการมีอยู่ในที่จัดเก็บของ Android อยู่แล้วหรือไม่

หากมีเครือข่ายที่ต้องการ ผู้ให้บริการควรใช้เครือข่ายนั้น วิธีนี้ช่วยให้อุปกรณ์ Thread เชื่อมต่อกับเครือข่าย Thread เดียวได้เมื่อเป็นไปได้
เมื่อไม่มีเครือข่ายที่ต้องการ ให้สร้างชุดข้อมูลเข้าสู่ระบบใหม่และกำหนดให้กับ TBR ในบริการ Google Play Android จะถือว่าข้อมูลเข้าสู่ระบบเหล่านั้นเป็นข้อมูลเข้าสู่ระบบมาตรฐานที่ตั้งค่าไว้ใน TBR ทั้งหมดที่อิงตาม Google และผู้ให้บริการรายอื่นๆ จะเพิ่มการเข้าถึงและความเสถียรของ Mesh ด้วยอุปกรณ์เพิ่มเติมได้

4. การโคลนและการแก้ไขแอป Android

เราได้สร้างแอป Android ที่แสดงการเรียก Thread API หลักที่เป็นไปได้ คุณสามารถใช้รูปแบบเหล่านี้ในแอปได้ ในโค้ดแล็บนี้ เราจะโคลนแอปตัวอย่าง Google Home สำหรับ Matter จาก GitHub

โค้ดต้นฉบับทั้งหมดที่แสดงที่นี่ได้รับการเขียนโค้ดในแอปตัวอย่างแล้ว เราขอเชิญให้คุณแก้ไขโค้ดตามความต้องการของคุณเอง แต่คุณก็โคลนแอปหรือเรียกใช้ไบนารีที่สร้างไว้ล่วงหน้าเพื่อตรวจสอบฟังก์ชันการทำงานได้

โคลนโดยใช้

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

ดาวน์โหลดและเปิด Android Studio
คลิก "ไฟล์" > "เปิด" แล้วชี้ไปที่ที่เก็บข้อมูลที่โคลน
เปิดใช้โหมดนักพัฒนาแอปในโทรศัพท์ Android
เชื่อมต่อกับคอมพิวเตอร์ผ่านสาย USB
เรียกใช้แอปจาก Android Studio ผ่าน <Cmd+R> (OS X) หรือ <Ctrl+R> (Win, Linux)
ไปที่ไอคอนรูปเฟือง -> ยูทิลิตีสำหรับนักพัฒนาซอฟต์แวร์ -> เครือข่ายเทรด
โต้ตอบกับตัวเลือกต่างๆ ที่มี ในส่วนด้านล่าง เราจะแตกโค้ดที่ดำเนินการกับปุ่มทุกปุ่ม

มีข้อมูลเข้าสู่ระบบที่ต้องการหรือไม่

คำถามแรกที่ผู้ผลิต TBR ควรถาม Google คือชุดข้อมูลเข้าสู่ระบบที่ต้องการมีอยู่ในอุปกรณ์อยู่แล้วหรือไม่ การดำเนินการนี้ควรเป็นจุดเริ่มต้นของขั้นตอน โค้ดด้านล่างจะค้นหา GPS เกี่ยวกับการมีอยู่ของข้อมูลเข้าสู่ระบบ และไม่แสดงข้อความแจ้งให้ผู้ใช้ให้ความยินยอมเนื่องจากไม่มีการแชร์ข้อมูลเข้าสู่ระบบ

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

รับข้อมูลเข้าสู่ระบบที่ต้องการสำหรับ GPS

ในกรณีที่มี คุณต้องอ่านข้อมูลเข้าสู่ระบบ ความแตกต่างเพียงอย่างเดียวจากโค้ดก่อนหน้าคือหลังจากได้รับ intentSenderResult แล้ว คุณต้องการสร้างและเปิดใช้งาน Intent โดยใช้ผลลัพธ์จากผู้ส่ง

ในโค้ดของเรา เราใช้ MutableLiveData<IntentSender?> เพื่อวัตถุประสงค์ด้านองค์กร/สถาปัตยกรรม เนื่องจากโค้ดต้นฉบับอยู่ใน ViewModel (ThreadViewModel.kt) และ Intent Observer อยู่ใน Activity Fragment (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?> ด้านล่าง

การตั้งค่าข้อมูลเข้าสู่ระบบ GPS

คุณควรลงทะเบียน TBR กับบริการ Google Play ไม่ว่าจะมีหรือไม่มี แอปของคุณจะเป็นแอปเดียวที่อ่านข้อมูลเข้าสู่ระบบที่เชื่อมโยงกับรหัสตัวแทนชายแดนของ 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 Rest Server หรือ HTTP Rest Server ดั้งเดิมจาก 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

ดังที่แสดงไว้ก่อนหน้านี้ ให้ใช้คําสั่ง HTTP GET เพื่อรับข้อมูลเข้าสู่ระบบจาก TBR ดูสคริปต์ Python ตัวอย่าง

การสร้างและการนําเข้า

เมื่อสร้างแอป Android คุณจะต้องทําการเปลี่ยนแปลงไฟล์ Manifest, บิลด์ และการนําเข้าเพื่อรองรับโมดูลเธรดของบริการ Google Play ตัวอย่างข้อมูล 3 รายการต่อไปนี้สรุปการเพิ่มส่วนใหญ่

โปรดทราบว่าแอปตัวอย่างของเราสร้างขึ้นเพื่อการจัดเตรียมอุปกรณ์ Matter เป็นหลัก ดังนั้นไฟล์ Manifest และ Gradle จึงมีความซับซ้อนกว่าส่วนเพิ่มเติมที่จำเป็นต่อการใช้ข้อมูลเข้าสู่ระบบเทรด

การเปลี่ยนแปลงไฟล์ Manifest

<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

แอปตัวอย่างของเราใช้การค้นพบ mDNS/SD เพื่อสร้างรายการ Border Router แบบเทรดที่ใช้ได้บนเครือข่าย รวมถึง BAID ที่เกี่ยวข้อง

ซึ่งมีประโยชน์อย่างยิ่งเมื่อป้อนข้อมูล TBR ลงในพื้นที่เก็บข้อมูลของข้อมูลเข้าสู่ระบบ GPS แต่การใช้งานอยู่นอกเหนือขอบเขตของโค้ดแล็บนี้ เราใช้ไลบรารีการค้นพบบริการ Android NSDManager และซอร์สโค้ดทั้งหมดมีอยู่ในตัวอย่างแอปใน ServiceDiscovery.kt

6. สรุป

เมื่อใช้การเรียกเหล่านี้หรือใช้แอปตัวอย่างแล้ว คุณจะเริ่มต้นใช้งาน RPi OTBR ได้อย่างเต็มที่ แอปตัวอย่างของเราแสดงปุ่ม 8 ปุ่ม ดังนี้

ลำดับขั้นตอนที่เป็นไปได้ในการเริ่มต้นใช้งาน TBR มีดังนี้

ค้นหาว่าข้อมูลเข้าสู่ระบบแบบมีสิทธิ์มีอยู่หรือไม่ (สีน้ำเงิน แถวที่ 1)
ขึ้นอยู่กับคำตอบ
รับข้อมูลเข้าสู่ระบบที่ต้องการสำหรับ GPS (สีน้ำเงิน แถวที่ 2)
ตั้งค่าข้อมูลเข้าสู่ระบบ TBR ใน GPS (สีน้ำเงิน แถวที่ 3) -> เลือก TBR -> สร้างแบบสุ่ม -> ป้อนชื่อเครือข่าย -> ตกลง
เมื่อคุณมีข้อมูลเข้าสู่ระบบที่ต้องการแล้ว ให้ตั้งค่าข้อมูลเข้าสู่ระบบนั้นใน OTBR โดยใช้ตั้งค่าข้อมูลเข้าสู่ระบบ RPi OTBR ซึ่งจะใช้ข้อมูลเข้าสู่ระบบเหล่านั้นกับชุดที่รอดำเนินการ

ค่าเริ่มต้นสําหรับแอปตัวอย่างคือใช้การหน่วงเวลา 10 วินาที ดังนั้นหลังจากระยะเวลานี้ ข้อมูลเข้าสู่ระบบของ RPi TBR (และโหนดอื่นๆ ที่อาจอยู่ในเครือข่าย) จะย้ายไปยังชุดข้อมูลใหม่

7. บทสรุป

ใน Codelab นี้ เราได้โคลนแอป Android ตัวอย่างและวิเคราะห์ข้อมูลโค้ดหลายรายการที่ใช้ Thread Storage API ของบริการ Google Play เราใช้ API เหล่านั้นเพื่อให้มีชุดข้อมูลทั่วไปที่เราสามารถนำไปใช้กับ TBR ของ RPi ซึ่งแสดง TBR ของผู้ให้บริการ

การมี TBR ทั้งหมดของผู้ใช้อยู่ในเครือข่ายเดียวกันจะช่วยเพิ่มความยืดหยุ่นและการเข้าถึงของเครือข่ายเทรด นอกจากนี้ยังป้องกันไม่ให้เส้นทางของผู้ใช้มีข้อบกพร่องเมื่อแอปไม่สามารถเริ่มต้นใช้งานอุปกรณ์เทรดได้เนื่องจากไม่มีสิทธิ์เข้าถึงข้อมูลเข้าสู่ระบบ

เราหวังว่า Codelab และแอปตัวอย่างนี้จะช่วยคุณออกแบบและพัฒนาแอปและผลิตภัณฑ์ Border Router เทรดของคุณเอง

8. ข้อมูลอ้างอิง

โปรเซสเซอร์ร่วม RCP

DBUS