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

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

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

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

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

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

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

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

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

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

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

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

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

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

ทั้ง 2 วิธีนั้นไม่มีความปลอดภัย และไม่ควรใช้ตามที่มีอยู่ในสภาพแวดล้อมการใช้งานจริง อย่างไรก็ตาม ผู้ให้บริการสามารถสร้างการเข้ารหัสโดยใช้วิธีการใดก็ได้เพื่อใช้งานในสภาพแวดล้อมการใช้งานจริง หรือคุณจะขยายบริการการตรวจสอบของคุณเองเพื่อออก HTTP Loopback ของ HTTP หรือการเรียก 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>

สคริปต์เรียกใช้คำสั่ง DBUS R/W ไปยังเส้นทางรถประจำทาง 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: OTBR API สำหรับ HTTP REST แบบเนทีฟของตัวแทน

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

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

คุณสามารถรีสตาร์ท Agent 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 (BAID) คุณจะใช้เมธอด addCredentials() ของอินเทอร์เฟซ ThreadNetworkClient เพื่อทำงานนี้ TBR แรกที่เพิ่มลงในพื้นที่เก็บข้อมูลของบริการ Google Play จะเป็นตัวกำหนดข้อมูลเข้าสู่ระบบที่ต้องการสำหรับอุปกรณ์เคลื่อนที่เครื่องนี้

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

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

Google TBR Sync

อุปกรณ์ Android จะซิงค์กับ Google TBR โดยอัตโนมัติ หากไม่มีข้อมูลเข้าสู่ระบบใน Android อุปกรณ์จะดึงข้อมูลจาก TBR ของ Google ในเครือข่าย และข้อมูลเข้าสู่ระบบเหล่านั้นจะกลายเป็นข้อมูลเข้าสู่ระบบที่ต้องการ การซิงค์ระหว่าง 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 หลักที่เป็นไปได้ คุณใช้รูปแบบเหล่านี้ในแอปได้ ใน Codelab นี้ เราจะโคลนแอป 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> (ชนะ, Linux)
ไปที่วงล้อ -> ยูทิลิตีของนักพัฒนาซอฟต์แวร์ -> เครือข่าย Thread
โต้ตอบกับตัวเลือกต่างๆ ที่มีอยู่ ในส่วนด้านล่าง เราจะคลายโค้ดที่ทำงานบนปุ่มทุกปุ่ม

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

คำถามแรกที่ผู้ผลิต 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 อยู่ใน Activity Fragment ( ThreadFragment.kt) ดังนั้นเมื่อมีการโพสต์ IntentSenderSender ในข้อมูลสดแล้ว เราจะดำเนินการกับเนื้อหาของผู้สังเกตการณ์นี้

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

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

ตามที่ปรากฏก่อนหน้านี้ ให้ใช้ 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 เพื่อสร้างรายการ Thread 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 และวิเคราะห์ข้อมูลโค้ดหลายรายการที่ใช้ประโยชน์จากบริการ Google Play Thread Storage API เราใช้ API เหล่านี้เพื่อให้มีชุดข้อมูลร่วมกันที่เราสามารถเริ่มต้นใช้งานบน RPi TBR ซึ่งแสดงตัวอย่าง TBR ของผู้ให้บริการ

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

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

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

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

DBUS