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

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

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

ใน Codelab เกี่ยวกับ Thread Border Router (TBR) เราจะแสดงวิธีสร้าง Border Router แบบเทรดจาก Raspberry Pi ใน Codelab เรา

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

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

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

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

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

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

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

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

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

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

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

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

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

บน RPi ที่จะทำหน้าที่เป็น OTBR ให้ติดตั้งทรัพยากร Dependency ของ Python 3 ดังนี้

$ pip install dbus-python shlex json

เรียกใช้สคริปต์ในรูปแบบต่อไปนี้

$  sudo python credentials_server.py 8081
serving at port 8081

ตัวอย่างจะตั้งค่าเซิร์ฟเวอร์ HTTP บนพอร์ต 8081 และรับฟังในเส้นทางรูทสำหรับคำขอ GET เพื่อดึงข้อมูลเข้าสู่ระบบเทรด หรือคำขอ POST เพื่อตั้งค่าข้อมูลเข้าสู่ระบบเทรด เพย์โหลดจะเป็นโครงสร้าง 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 ช่วยให้ทราบถึงความสามารถของตน ซึ่งทำได้ดังนี้

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

คุณยังสามารถตรวจสอบความสามารถที่สนับสนุนได้ที่นี่

ตัวเลือกที่ 2: API การกู้คืน HTTP แบบเนทีฟของตัวแทน OTBR

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

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

คุณจะรีสตาร์ทเอเจนต์ OTBR ได้โดยการเรียกใช้

$ sudo systemctl restart otbr-agent.service

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

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

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

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

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

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

Google TBR Sync

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

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

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

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

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

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

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

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

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

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

โคลนโดยใช้

$ 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 จะอยู่ในส่วนย่อยกิจกรรม ( ThreadFragment.kt) ดังนั้น เมื่อโพสต์ Intent Sender Results ไปยังข้อมูลสดแล้ว เราจะดำเนินการกับเนื้อหาของผู้สังเกตการณ์นี้ ดังนี้

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 แอปของคุณจะเป็นคนเดียวที่อ่านข้อมูลเข้าสู่ระบบที่เชื่อมโยงกับรหัส Border Agent ของ 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

ส่วนนี้เป็นกรรมสิทธิ์ของผู้ให้บริการแต่ละราย และใน Codelab นี้ เราได้ติดตั้งใช้งานผ่านทาง DBUS+Python HTTP ReREST Server หรือเซิร์ฟเวอร์ HTTP REST แบบเนทีฟจาก 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

ตามที่แสดงก่อนหน้านี้ ให้ใช้ GET HTTP Verb เพื่อรับข้อมูลเข้าสู่ระบบจาก 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 อย่างไรก็ตาม การใช้งานจะอยู่นอกขอบเขตของ Codelab นี้ เราใช้ไลบรารี Android Service Discovery 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 เหล่านั้นเพื่อให้มีชุดข้อมูลทั่วไปที่เราสามารถเริ่มต้นใช้งานบน RPi TBR ซึ่งแสดง TBR ของผู้ให้บริการ

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

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

8. รายการอ้างอิง

ผู้ประมวลผลข้อมูลร่วม RCP

ฐานข้อมูล