1. ยินดีต้อนรับ
Matter สร้างโดยมีเป้าหมายเป็นการรวมมาตรฐาน IoT เพื่อเชื่อมต่ออุปกรณ์ในบ้านอัจฉริยะผ่านระบบนิเวศต่างๆ เช่น Google Home, Zigbee, Bluetooth Mesh, Z-Wave และอีกมากมาย
อุปกรณ์เคลื่อนที่เป็นจุดศูนย์กลางของการโต้ตอบด้วยอุปกรณ์ในบ้านอัจฉริยะ หากต้องการสร้างแอป Android ของตนเองเพื่อรองรับอุปกรณ์ Matter เราช่วยคุณเริ่มต้นใช้งานได้อย่างรวดเร็ว
แอป Google Home Sample สําหรับ Matter (GHSA สําหรับ Matter) จะแสดง Home Mobile SDK API ซึ่งช่วยให้ผู้ใช้ค่าคอมมิชชันและแชร์อุปกรณ์ได้ คุณยังสามารถใช้แอปตัวอย่างเป็นเครื่องมือการเรียนรู้เพื่อทําความเข้าใจแนวคิดหลักของ Matter และเครื่องมือแก้ไขข้อบกพร่องและแก้ปัญหาการโต้ตอบกับอุปกรณ์ Matter ได้ดีขึ้น
สิ่งที่ต้องทํา
ใน Codelab นี้ คุณจะดาวน์โหลดซอร์สโค้ดสําหรับแอปตัวอย่างและเรียนรู้วิธีใช้ Home Mobile SDK เพื่อว่าจ้างและแชร์อุปกรณ์ นอกจากนี้ คุณจะยังดูวิธีใช้ไลบรารีค่าคอมมิชชันและคลัสเตอร์จากที่เก็บข้อมูล Matter (connectedhomeip
) อีกด้วย
หลังจากที่คุณดาวน์โหลดแอปตัวอย่างแล้ว เราจะตรวจสอบซอร์สโค้ดใน Android Studio และใช้ Home Mobile SDK API ต่อไปนี้
รวมถึงข้อมูลเพิ่มเติมเกี่ยวกับแนวคิดการว่าจ้าง ผ้า Matter และวิธีควบคุมอุปกรณ์ Matter
สิ่งที่ต้องมี
ก่อนเริ่มต้น โปรดทําตามขั้นตอนต่อไปนี้
- อ่านแอปตัวอย่าง Google Home สําหรับกรณี
- ดาวน์โหลด Android Studio
- มี Android O (8.1, API ระดับ 27) ขึ้นไปสําหรับอุปกรณ์สําหรับการทดสอบ อ่านคู่มือยืนยันโมดูลและบริการ Matter เพื่อให้แน่ใจว่าอุปกรณ์มีการรองรับ Matter ล่าสุด
- สร้างอุปกรณ์ Matter ที่มีความสามารถในการเปิด/ปิด แอปตัวอย่างนี้ใช้งานได้กับอุปกรณ์เสมือนจริงและ ESP32
- สร้างอุปกรณ์เสมือนจริง Matter ด้วยแอป
rootnode_dimmablelight_bCwGYSDpoe
เมื่อคุณสร้างการผสานรวม Matter ในคอนโซลของนักพัฒนาซอฟต์แวร์ Home ให้ใช้0xFFF1
เป็นรหัสผู้ให้บริการและ0x8000
เป็นรหัสผลิตภัณฑ์ - สร้างอุปกรณ์เอสเปรสโซด้วย
all-clusters-app
เมื่อคุณสร้างการผสานรวมกรณีในคอนโซลนักพัฒนาซอฟต์แวร์หน้าแรก ให้ใช้0xFFF1
เป็นรหัสผู้ให้บริการและใช้0x8001
เป็นรหัสผลิตภัณฑ์
- สร้างอุปกรณ์เสมือนจริง Matter ด้วยแอป
- ดูวิธีตั้งค่าบริการ Google Play
คุณไม่จําเป็นต้องมีฮับ เช่น Google Nest Hub (รุ่นที่ 2) เพื่อค่าคอมมิชชันและควบคุมอุปกรณ์ด้วยแอปตัวอย่าง
2. ตั้งค่า
ที่เก็บ GitHub ของแอปตัวอย่างมีไลบรารีของบุคคลที่สามจากที่เก็บข้อมูล Matter (connectedhomeip
) ไลบรารีแบบเนทีฟเหล่านี้มีขนาดมากกว่า 50 MB และต้องใช้ Git Large File Storage (LFS)
แอป Codelab เริ่มต้นจะอยู่ในสาขา codelab
หากต้องการเริ่มทํางานกับซอร์สโค้ด Codelab คุณสามารถดาวน์โหลดไฟล์ ZIP ได้ ไฟล์ ZIP นี้มีไลบรารีเนทีฟ Matter SDK โดยไม่ต้องใช้ Git LFS
คุณจะใช้ไฟล์ ZIP codelab
นี้เพื่อสร้างตัวอย่างที่ใช้งานได้
เวอร์ชัน Codelab
สาขา codelab
ติดแท็กด้วยรุ่น 1.2.2 ของแอปตัวอย่าง หากต้องการเปรียบเทียบการอัปเดตขณะทําตามขั้นตอนต่างๆ คุณสามารถดาวน์โหลดซอร์สโค้ดที่สมบูรณ์สําหรับรุ่นนี้ได้
หากต้องการโคลนที่เก็บ GitHub ให้ทําตามวิธีการในตัวอย่างแอป README
การอ้างอิง
เราจะแนะนําซอร์สโค้ดที่จําเป็นสําหรับการแชร์และค่าคอมมิชชันอุปกรณ์ แต่คุณควรคํานึงถึงทรัพยากร Dependency ต่อไปนี้ก่อนเริ่มต้นใช้งาน
- SDK อุปกรณ์เคลื่อนที่สําหรับบ้าน
implementation 'com.google.android.gms:play-services-home:16.0.0'
- ไลบรารี SDK ของ Matter
// Native libs implementation fileTree(dir: "third_party/connectedhomeip/libs", include: ["*.jar", "*.so"])
- การออกแบบ Material ดูข้อมูลเพิ่มเติมได้ที่ MDC-103 Android: Material Themming with Color, Elevation and Type (Kotlin) และ Material Theme Builder
implementation 'com.google.android.material:material:1.5.0'
- Proto DataStore ที่ใช้ในการเก็บข้อมูลแอปไว้ ที่เก็บ Datastore และซีเรียลไลเซอร์จะจัดเก็บอยู่ใน
java/data
ซึ่งรวมถึงสคีมาสําหรับอุปกรณ์และค่ากําหนดของผู้ใช้ ดูข้อมูลเพิ่มเติมเกี่ยวกับ DataStore ได้ที่การทํางานกับ Proto DataStoreimplementation "androidx.datastore:datastore:$dataStoreVersion" implementation 'androidx.datastore:datastore-core:1.0.0' implementation 'com.google.protobuf:protobuf-javalite:3.18.0'
- Hit เพื่อเก็บข้อมูลและรองรับการแทรกทรัพยากร Dependency
kapt 'com.google.dagger:hilt-compiler:2.41' implementation 'com.google.dagger:hilt-android:2.41'
ซอร์สโค้ด
ระบบสร้างอินเทอร์เฟซผู้ใช้และฟังก์ชันการทํางานส่วนใหญ่ให้คุณแล้ว
สําหรับ Codelab นี้ เราจะเพิ่มฟังก์ชัน Matter ในไฟล์ต่อไปนี้
java/commissioning/AppCommissioningService
: ให้คุณกําหนดอุปกรณ์ให้ผ้าสําหรับการพัฒนาjava/screens/HomeFragment
และjava/screens/HomeViewModel.kt
: มีฟังก์ชันค่าคอมมิชชัน SDK บนอุปกรณ์เคลื่อนที่java/screens/DeviceViewModel
: รวมการเรียก Share Device API
แต่ละไฟล์แสดงความคิดเห็นด้วยโค้ดบล็อกที่จะแก้ไข เช่น
// CODELAB: add commissioningFunction()
ซึ่งจะช่วยให้คุณค้นหาส่วนที่เกี่ยวข้องใน Codelab ได้อย่างรวดเร็ว
3. ค่าคอมมิชชันสําหรับ Google
ก่อนที่จะควบคุมอุปกรณ์และอนุญาตให้สื่อสารกันได้บนผ้าเดียวกัน อุปกรณ์เหล่านั้นต้องว่าจ้างโดย Commissioner ซึ่งในกรณีนี้ เป็นแอปพลิเคชันตัวอย่างของแอป Google Home Sample สําหรับ Matter
คุณควรทําความเข้าใจแนวคิดต่อไปนี้เกี่ยวกับการว่าจ้าง Matter
- ผ้าจะช่วยให้อุปกรณ์สื่อสารกันได้
- ผ้าจะเป็นการรักษาข้อมูลเข้าสู่ระบบที่ใช้ร่วมกันแบบไม่ซ้ํา
- ระบบนิเวศจะรับผิดชอบในการออกใบรับรองรูทที่เชื่อถือได้ กําหนดรหัสผ้า และกําหนดรหัสโหนดที่ไม่ซ้ํากัน ระบบนิเวศคือบริการแบ็กเอนด์ของค่าคอมมิชชัน เช่น กราฟบ้านสําหรับระบบนิเวศของ Google Home
- อาจมีการกําหนดให้อุปกรณ์ใช้ผ้ามากกว่า 1 ผืน (ฟีเจอร์สําหรับหลายผู้ดูแลระบบ)
คุณจะต้องใช้ CommissioningClient API เพื่อตั้งค่าอุปกรณ์ การเรียก .commissionDevice()
จะแสดง IntentSender ซึ่งจะเปิดใช้กิจกรรมที่เหมาะสมในบริการ Google Play
interface CommissioningClient { Task<IntentSender> commissionDevice(CommissioningRequest request); }
ในส่วนถัดไป เราจะกล่าวถึงโค้ดขั้นต่ําที่จําเป็นในการกําหนดให้อุปกรณ์ทํางานกับผ้า Google
ขั้นตอนที่ 1: ตัวเปิดใช้งานกิจกรรม
หากต้องการจัดการ IntentSender
จาก CommissioningClient
คุณสามารถใช้ ActivityResultLauncher ได้โดยทําดังนี้
private lateinit var commissioningLauncher: ActivityResultLauncher<IntentSenderRequest>
commissioningLauncher = registerForActivityResult( StartIntentSenderForResult() ) { result: ActivityResult -> if (result.resultCode == RESULT_OK) { Timber.d(TAG, "Commissioning succeeded.") } else { Timber.d(TAG, "Commissioning failed. " + result.resultCode) } }
ขั้นตอนที่ 2: การว่าจ้างฟังก์ชัน
ตัวอย่างพื้นฐานที่ใช้ CommissioningClient API เพื่อกําหนดให้อุปกรณ์ทํางานกับผ้า Google
- ขั้นตอนการว่าจ้างจะเริ่มต้นด้วยฟังก์ชัน
commissionDevice()
ก่อนอื่นให้กําหนดCommissioningRequest
การกําหนดค่าเริ่มต้นนี้กําหนดให้อุปกรณ์ดําเนินการกับผ้า Android ในพื้นที่เท่านั้น Matter
เป็นจุดเริ่มต้นสําหรับ Home Mobile SDK ในการโทรครั้งถัดไป.getCommissioningClient
จะได้รับค่าคอมมิชชันจากthis
(กิจกรรม).commissionDevice()
ยอมรับCommissioningRequest
- และสุดท้าย ระบบจะเรียก
.addOnSuccessListener
ให้ประมวลผลCommissioningResult
และเปิดตัวกิจกรรมอุปกรณ์ค่าคอมมิชชันของบริการ Google Play (GPS)
private fun commissionDevice() { val request: CommissioningRequest = CommissioningRequest.builder().build() Matter.getCommissioningClient(this) .commissionDevice(request) .addOnSuccessListener { result -> commissioningLauncher.launch(IntentSenderRequest.Builder(result).build()) } }
คุณสามารถใช้ประโยชน์จากผ้า Android ในพื้นที่ได้ผ่านการตั้งค่า Android เพื่อลดความซับซ้อนของค่าคอมมิชชันในอุปกรณ์ด้วยผ้าอื่นๆ
ถัดไป คุณจะได้ดูวิธีค่าคอมมิชชันอุปกรณ์ให้กับผ้าสําหรับการพัฒนา
สําหรับภาพรวมของอินเทอร์เฟซผู้ใช้ระหว่างขั้นตอนการว่าจ้าง โปรดอ่านคู่มือตัวอย่างแอป Google Home สําหรับกรณี
4. ค่าคอมมิชชันของการพัฒนาผลิตภัณฑ์
อุปกรณ์นี้ใช้ผ้ามากกว่า 1 ผืนได้ หากต้องการจัดการการจับคู่ที่เชื่อถือได้ อุปกรณ์จะจัดเก็บ FabricTable
ที่มีสมาชิก FabricInfo
หลายคน เช่น
- การระบุผ้า
- รหัสโหนดที่ผ้ากําหนดให้อุปกรณ์
- รหัสผู้ให้บริการ
- รหัสผ้า
- ข้อมูลเข้าสู่ระบบการทํางานของอุปกรณ์
เครื่องมือจัดการการดูแลระบบ (ADM) จะกําหนดข้อมูลเข้าสู่ระบบของผ้า ในสถานการณ์ก่อนหน้านี้ บริการ Google Play คือระบบนิเวศที่ทําหน้าที่เป็นผู้ออกใบรับรองรูท (CA) ที่เชื่อถือได้ เมื่อคุณกําหนดอุปกรณ์ให้ทํางานกับผ้า Android ท้องถิ่น อุปกรณ์ทุกเครื่องจะมีข้อมูลเข้าสู่ระบบผ้าเดียวกันและ CA ชุดเดียวกัน
บริการรับทําตามสั่ง
เรานําพารามิเตอร์เริ่มต้นมาใช้ในการสร้าง CommissioningRequest
ใน CommissioningClient API ดังนี้เพื่อเปลี่ยนไปใช้ผ้า Android ในพื้นที่
val request: CommissioningRequest = CommissioningRequest.builder().build()
หากต้องการควบคุมและจัดการอุปกรณ์ใหม่จากแอปของคุณ คุณต้องสร้างผ้าสําหรับการพัฒนาในท้องถิ่นและรับข้อมูลรับรองการดําเนินการเพื่อค่าคอมมิชชันอุปกรณ์ ในสถานการณ์นี้ แอปของคุณจะกลายเป็นระบบนิเวศที่เป็นเอกลักษณ์และไม่ซ้ํากันซึ่งจะกําหนดข้อมูลเข้าสู่ระบบโหนดที่เหมาะสมให้กับอุปกรณ์
คุณอาจแจ้ง Home Mobile SDK ที่ต้องการกําหนดอุปกรณ์ให้ทอผ้าของคุณเองโดยการส่งบริการที่กําหนดเองไปยัง CommissioningRequest ดังนี้
class CommissioningRequest { static CommissioningRequest.Builder builder(); class Builder { Builder setCommissioningService(@Nullable ComponentName commissioningService); CommissioningRequest build(); } }
ในขั้นตอนต่อไป เราจะแก้ไขฟังก์ชัน commissionDevice()
เพื่อใช้บริการที่กําหนดเอง เราจะเพิ่ม Launcher กิจกรรมไปยังส่วนย่อยของหน้าแรกและใช้ออบเจ็กต์ LiveData เพื่อจัดการโฟลว์ API ด้วย
ขั้นตอนที่ 1: สร้าง Launcher กิจกรรม GPS
ก่อนอื่น ให้สร้าง Launcher กิจกรรมเพื่อจัดการ IntentSender
จาก CommissioningClient API
- เปิด
HomeFragment
ในโฟลเดอร์java/screens/home/
- แทนที่ความคิดเห็น
// CODELAB: commissionDeviceLauncher declaration
ด้วยการประกาศต่อไปนี้// The ActivityResult launcher that launches the "commissionDevice" activity in Google Play // Services. private lateinit var commissionDeviceLauncher: ActivityResultLauncher<IntentSenderRequest>
- แทนที่
// CODELAB: commissionDeviceLauncher definition
ความคิดเห็นด้วยโค้ดต่อไปนี้เพื่อลงทะเบียนและจัดการผลลัพธ์ของกิจกรรมค่าคอมมิชชันcommissionDeviceLauncher = registerForActivityResult(ActivityResultContracts.StartIntentSenderForResult()) { result -> // Commission Device Step 5. // The Commission Device activity in GPS has completed. val resultCode = result.resultCode if (resultCode == Activity.RESULT_OK) { Timber.d("CommissionDevice: Success") // We now need to capture the device information for the app's fabric. // Once this completes, a call is made to the viewModel to persist the information // about that device in the app. showNewDeviceAlertDialog(result) } else { viewModel.commissionDeviceFailed(resultCode) } } ```
ขั้นตอนที่ 2: สร้างออบเจ็กต์ LiveData
การเรียกกลับของ .commissionDevice()
API ที่สําเร็จจะรวม IntentSender
เพื่อใช้เปิดกิจกรรมอุปกรณ์ค่าคอมมิชชันในบริการของ Google Play ใน HomeViewModel
เราจะสร้างออบเจ็กต์ LiveData 2 รายการเพื่อรายงานผลลัพธ์ของการเรียก API นี้
commissionDeviceStatus
เพื่อติดตามTaskStatus
commissionDeviceIntentSender
เพื่อจัดการผลลัพธ์ของการโทร.commissionDevice()
ออบเจ็กต์ LiveData นี้จะเปิดตัวActivityLauncher
ที่เราเพิ่งสร้างและแสดงกิจกรรมบนอุปกรณ์ค่าคอมมิชชัน GPS แก่ผู้ใช้
- ใน
private fun setupObservers()
ให้แทนที่ความคิดเห็น// CODELAB: commissionDeviceStatus
ด้วยการสังเกตการณ์ต่อไปนี้// The current status of the share device action. viewModel.commissionDeviceStatus.observe(viewLifecycleOwner) { status -> Timber.d("commissionDeviceStatus.observe: status [${status}]") }
- จากนั้นแทนที่ความคิดเห็น
// CODELAB: commissionDeviceIntentSender
ด้วยผู้สังเกตการณ์ต่อไปนี้viewModel.commissionDeviceIntentSender.observe(viewLifecycleOwner) { sender -> Timber.d( "commissionDeviceIntentSender.observe is called with [${intentSenderToString(sender)}]") if (sender != null) { // Commission Device Step 4: Launch the activity described in the IntentSender that // was returned in Step 3 (where the viewModel calls the GPS API to commission // the device). Timber.d("CommissionDevice: Launch GPS activity to commission device") commissionDeviceLauncher.launch(IntentSenderRequest.Builder(sender).build()) viewModel.consumeCommissionDeviceIntentSender() } }
ขั้นตอนที่ 3: เรียก API
เมื่อเราเขียนโค้ดเพื่อจัดการกับ API แล้ว ก็ถึงเวลาเรียก API ส่งผ่านบริการที่กําหนดเอง (ซึ่งเราจะกําหนดในขั้นตอนถัดไป) และโพสต์ไปยังออบเจ็กต์ LiveData
- เปิด
HomeViewModel.kt
ในโฟลเดอร์java/screens/home/
- แทนที่ความคิดเห็น
// CODELAB: commissionDevice
ด้วยcommissionDeviceRequest
ต่อไปนี้setCommissioningService
เชื่อมโยงAppCommissioningService
กับอินสแตนซ์CommissioningService
โดยแสดงผลในฟังก์ชันเรียกกลับ เมื่อคุณส่งบริการที่กําหนดเอง Home Mobile SDK จะค่าคอมมิชชันอุปกรณ์ให้กับผ้า Google ก่อน จากนั้นจึงส่งเพย์โหลดการเริ่มต้นใช้งานกลับไปยังAppCommissioningService
fun commissionDevice(context: Context) { _commissionDeviceStatus.postValue(TaskStatus.InProgress) val commissionDeviceRequest = CommissioningRequest.builder() .setCommissioningService(ComponentName(context, AppCommissioningService::class.java)) .build()
- โทรหา
.getCommissioningClient()
แล้วโทร.commissionDevice()
Matter.getCommissioningClient(context) .commissionDevice(commissionDeviceRequest)
หากต้องการเพิ่มฟังก์ชัน commissionDevice
ให้เสร็จสิ้น ให้เพิ่ม addOnSuccessListener
และ addOnFailureListener
และโพสต์ลงในออบเจ็กต์ LiveData:
.addOnSuccessListener { result -> // Communication with fragment is via livedata _commissionDeviceIntentSender.postValue(result) } .addOnFailureListener { error -> Timber.e(error) _commissionDeviceStatus.postValue( TaskStatus.Failed("Failed to to get the IntentSender.", error) } }
หลังจากใช้ผู้ส่งแล้ว ควรเรียกใช้ consumeCommissionDeviceIntentSender()
เพื่อหลีกเลี่ยงการรับผู้ส่งอีกครั้งหลังจากเปลี่ยนการกําหนดค่า
/** * Consumes the value in [_commissionDeviceIntentSender] and sets it back to null. Needs to be * called to avoid re-processing the IntentSender after a configuration change (where the LiveData * is re-posted). */ fun consumeCommissionDeviceIntentSender() { _commissionDeviceIntentSender.postValue(null) }
5. สร้างค่าคอมมิชชัน
ในฟังก์ชัน commissionDevice()
เราได้ส่งคําขอรับ CommissioningService จาก CommissioningClient API ในขั้นนี้ CommissioningClient API จะกําหนดให้อุปกรณ์เปลี่ยนไปใช้ผ้า Android ในพื้นที่ก่อน จากนั้นจึงส่งคืนการเรียกกลับที่มีออบเจ็กต์ CommissioningRequestMetadata ดังนี้
public interface CommissioningService { interface Callback { void onCommissioningRequested(CommissioningRequestMetadata metadata); } }
ปัจจุบันเราต้องรับช่วงค่า CommissioningService.Callback และให้ฟังก์ชันที่จําเป็นสําหรับค่าคอมมิชชันอุปกรณ์ไปยังแอปตัวอย่างของเรา ตัวอย่างการติดตั้งใช้งาน CommissioningService พื้นฐานมีดังนี้
class MatterCommissioningService : Service(), CommissioningService.Callback { private val commissioningServiceDelegate = CommissioningService.Builder(this) .setCallback(this) .build() override fun onBind(intent: Intent) = commissioningServiceDelegate.asBinder() override fun onCommissioningRequested(metadata: CommissioningRequestMetadata) { // perform commissioning commissioningServiceDelegate .sendCommissioningComplete(CommissioningCompleteMetadata.builder().build()) } }
ขั้นตอนที่ 1: สํารวจ AppCommissioningService ที่กําหนดเอง
เราได้กําหนดโครงสร้างพื้นฐานสําหรับ CommissioningService ที่กําหนดเองแล้วเพื่อช่วยคุณเริ่มต้นใช้งาน ภาพรวมคร่าวๆ เกี่ยวกับฟังก์ชันของบริการมีดังนี้ หากต้องการดําเนินการต่อ ให้เปิด AppCommissioningService
ใน java/commissioning
เราได้เพิ่มการนําเข้าต่อไปนี้สําหรับ Home Mobile SDK API
import com.google.android.gms.home.matter.commissioning.CommissioningCompleteMetadata import com.google.android.gms.home.matter.commissioning.CommissioningRequestMetadata import com.google.android.gms.home.matter.commissioning.CommissioningService
AppCommissioningService
ยังมีไลบรารีจากที่เก็บ Matter (connectedhomeip
) ด้วย
import com.google.home_sample_app_for_matter.chip.ChipClient
สุดท้าย บริการจะมีการนําเข้าเพื่อรองรับ Hilt และ Corineine ของ Kotlin
ต่อไป เราจะสร้างเครื่องมือสร้างและตั้งค่าบางอย่าง รวมถึง commissioningServiceDelegate
ซึ่งเราจะใช้เพื่อแจ้งให้บริการ Google Play ทราบเมื่อค่าคอมมิชชันเสร็จสมบูรณ์
private lateinit var commissioningServiceDelegate: CommissioningService ... commissioningServiceDelegate = CommissioningService.Builder(this).setCallback(this).build()
ได้เวลาเพิ่มฟังก์ชันค่าคอมมิชชันแล้ว
ขั้นตอนที่ 2: ลบล้าง onCommissioningRequest
ทําตามขั้นตอนต่อไปนี้เพื่อเข้าร่วมอุปกรณ์กับการพัฒนาแอป
- เปิด
AppCommissioningService
ในjava/commissioning
- ค้นหาฟังก์ชัน
onCommissioningRequested()
เราได้ส่งข้อความบันทึกที่พิมพ์ไปยังCommissioningRequestMetadata
แทนที่ความคิดเห็น// CODELAB: onCommissioningRequested()
เพื่อเริ่ม Coroutine ของserviceScope
และรับdeviceId
// Perform commissioning on custom fabric for the sample app. serviceScope.launch { val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
- ดําเนินการว่าจ้าง ในขั้นตอนนี้ เราสามารถส่งข้อมูลอุปกรณ์ที่แสดงในออบเจ็กต์ CommissioningRequestMetadata
ChipClient
ใช้ข้อมูลข้อมูลเมตานี้เพื่อสร้างช่องทางที่ปลอดภัยระหว่างแอป GHSA สําหรับ Matter กับอุปกรณ์ของคุณTimber.d("Commissioning: App fabric -> ChipClient.establishPaseConnection(): deviceId [${deviceId}]") chipClient.awaitEstablishPaseConnection( deviceId, metadata.networkLocation.ipAddress.hostAddress!!, metadata.networkLocation.port, metadata.passcode) Timber.d("Commissioning: App fabric -> ChipClient.commissionDevice(): deviceId [${deviceId}]") chipClient.awaitCommissionDevice(deviceId, null)
- ใช้
commissioningServiceDelegate
เพื่อแจ้งให้บริการ Google Play ทราบว่าค่าคอมมิชชันเสร็จสมบูรณ์แล้ว ใน.sendCommissioningComplete()
ให้ส่งผ่าน CommissioningCompleteMetadataTimber.d("Commissioning: Calling commissioningServiceDelegate.sendCommissioningComplete()") commissioningServiceDelegate .sendCommissioningComplete( CommissioningCompleteMetadata.builder().setToken(deviceId.toString()).build()) .addOnSuccessListener { Timber.d("Commissioning: OnSuccess for commissioningServiceDelegate.sendCommissioningComplete()") } .addOnFailureListener { ex -> Timber.e(ex, "Commissioning: Failed to send commissioning complete.", ex) } }
เรียกใช้แอป
เมื่อรหัสที่จําเป็นทั้งหมดพร้อมสําหรับโครงสร้างในเครื่องแล้ว ก็ถึงเวลาทดสอบแล้ว เลือกอุปกรณ์ Android แล้วเรียกใช้แอป แตะเพิ่มอุปกรณ์จากหน้าจอหลักแล้วทําตามขั้นตอนเพื่อค่าคอมมิชชันอุปกรณ์
เมื่อค่าคอมมิชชันเสร็จสมบูรณ์แล้ว อุปกรณ์จะเข้าร่วมในผ้า 2 ผ้า ได้แก่ ผ้า Android ในพื้นที่และผ้าสําหรับการพัฒนาในท้องถิ่น ผ้าแต่ละรายการมีชุดข้อมูลเข้าสู่ระบบของตัวเองและรหัสผ้า 64 บิตที่ไม่ซ้ํากัน
6. ควบคุมอุปกรณ์
ค่าคอมมิชชันสําหรับการพัฒนาผลิตภัณฑ์ช่วยให้คุณใช้ไลบรารีจากที่เก็บข้อมูล Matter (connectedhomeip
) เพื่อควบคุมอุปกรณ์จากแอปตัวอย่างได้
เราได้สร้างคลาสตัวช่วยบางอย่างเพื่อให้เข้าถึงคลัสเตอร์อุปกรณ์และส่งคําสั่งได้ง่ายขึ้น หากต้องการดูข้อมูลเพิ่มเติม ให้เปิด ClustersHelper
ใน java/clusters
ผู้ช่วย Singleton นี้จะนําเข้าไลบรารีต่อไปนี้เพื่อเข้าถึงข้อมูลอุปกรณ์
import chip.devicecontroller.ChipClusters import chip.devicecontroller.ChipStructs
เราใช้ชั้นเรียนนี้เพื่อรับคลัสเตอร์เปิด/ปิดสําหรับอุปกรณ์ได้ จากนั้นโทรหา .toggle
suspend fun toggleDeviceStateOnOffCluster(deviceId: Long, endpoint: Int) { Timber.d("toggleDeviceStateOnOffCluster())") val connectedDevicePtr = try { chipClient.getConnectedDevicePointer(deviceId) } catch (e: IllegalStateException) { Timber.e("Can't get connectedDevicePointer.") return } return suspendCoroutine { continuation -> getOnOffClusterForDevice(connectedDevicePtr, endpoint) .toggle( object : ChipClusters.DefaultClusterCallback { override fun onSuccess() { continuation.resume(Unit) } override fun onError(ex: Exception) { Timber.e("readOnOffAttribute command failure: $ex") continuation.resumeWithException(ex) } }) } }
สลับอุปกรณ์
หลังจากค่าคอมมิชชันอุปกรณ์แล้ว ระบบจะเพิ่มเพย์โหลดที่แสดงผลใน CommissioningResult ไปยัง DataStore ซึ่งจะทําให้แอปของเราเข้าถึงข้อมูลอุปกรณ์ที่เราใช้ส่งคําสั่งได้
แอป Matter เป็นไปตามเหตุการณ์ เมื่อเริ่มต้นกลุ่ม Matter บริการคลัสเตอร์จะฟังข้อความขาเข้า เมื่ออุปกรณ์ได้รับค่าคอมมิชชัน ไคลเอ็นต์ Matter จะส่งคําสั่งผ่านช่องการดําเนินการที่ปลอดภัยซึ่งสร้างขึ้นระหว่างการกําหนดอุปกรณ์
ในอุปกรณ์ แพ็กเก็ตจะได้รับการตรวจสอบ ถอดรหัส และจัดส่งด้วยโค้ดเรียกกลับ ฟังก์ชันเรียกกลับประกอบด้วย EndpointId, ClusterId และ AttributeId ซึ่งเข้าถึงได้จาก attributePath
เช่น นําโค้ดนี้ไปใช้กับอุปกรณ์ Matter ได้
void MatterPostAttributeChangeCallback(const chip::app::ConcreteAttributePath & attributePath, uint8_t mask, uint8_t type, uint16_t size, uint8_t * value) { // handle callback ClusterId clusterId = attributePath.mClusterId; AttributeId attributeId = attributePath.mAttributeId; }
ในขั้นตอนถัดไป คุณจะต้องใช้ Matter SDK และ ClustersHelper
เพื่อสลับอุปกรณ์
- ไปที่
DeviceViewModel
ในjava/screens/device
- ค้นหาฟังก์ชัน
updateDeviceStateOn
- แทนที่
// CODELAB: toggle
ความคิดเห็นด้วยรหัสเพื่อเรียกใช้clustersHelper
จากนั้นอัปเดตที่เก็บอุปกรณ์:Timber.d("Handling real device") try { clustersHelper.setOnOffDeviceStateOnOffCluster(deviceUiModel.device.deviceId, isOn, 1) devicesStateRepository.updateDeviceState(deviceUiModel.device.deviceId, true, isOn) } catch (e: Throwable) { Timber.e("Failed setting on/off state") }
ฟังก์ชันนี้ถูกเรียกจาก DeviceFragment
:
// Change the on/off state of the device binding.onoffSwitch.setOnClickListener { val isOn = binding.onoffSwitch.isChecked viewModel.updateDeviceStateOn(selectedDeviceViewModel.selectedDeviceLiveData.value!!, isOn) }
เรียกใช้แอป
เรียกใช้แอปเพื่อโหลดการอัปเดตซ้ํา เปิดและปิดหน้าจอหลักของอุปกรณ์
7. แชร์อุปกรณ์กับระบบนิเวศอื่นๆ
การแชร์อุปกรณ์จะเรียกว่าขั้นตอนสําหรับผู้ดูแลระบบหลายคนในข้อมูลจําเพาะของ Matter
ในขั้นตอนก่อนหน้า เราได้เรียนรู้ว่า Home Mobile SDK ทําให้ค่าคอมมิชชันอุปกรณ์กับผ้า Android ในเครื่องและยังผ้าสําหรับการพัฒนาแอปตัวอย่างได้ ด้านล่างนี้เป็นตัวอย่างขั้นตอนสําหรับผู้ดูแลระบบหลายรายซึ่งอุปกรณ์ต่างๆ สามารถกําหนดให้ผ้ามากกว่า 1 ผ้าได้
ตอนนี้คุณอาจต้องการแชร์อุปกรณ์กับสิ่งทอเพิ่มเติม โดยเฉพาะอย่างยิ่งหากเป็นครอบครัวที่ผู้คนชื่นชอบการตั้งค่าแอปพลิเคชันและแพลตฟอร์ม
Home Mobile SDK มีฟังก์ชันการทํางานนี้ใน ShareDeviceRequest API ซึ่งช่วยให้คุณทําสิ่งต่อไปนี้ได้
- เปิดหน้าต่างค่าคอมมิชชันชั่วคราวสําหรับอุปกรณ์
- เปลี่ยนสถานะของอุปกรณ์เพื่อให้ค่าคอมมิชชันใช้กับผ้าอื่นได้
- ควบคุมอุปกรณ์จากแอปและระบบนิเวศอื่นๆ
ในขั้นตอนถัดไป คุณจะต้องใช้ Home Mobile SDK เพื่อแชร์อุปกรณ์
ขั้นตอนที่ 1: สร้าง Launcher กิจกรรม GPS
คล้ายกับ Launcher กิจกรรมค่าคอมมิชชันที่เราสร้างขึ้นเมื่อได้รับค่าคอมมิชชันสําหรับการพัฒนาพร็อพเพอร์ตี้ เราได้สร้าง Launcher กิจกรรมการแชร์อุปกรณ์เพื่อจัดการ IntentSender
จาก CommissioningClient API
- เปิด
DeviceFragment
ในโฟลเดอร์java/screens/device/
- แทนที่
// CODELAB: shareDeviceLauncher definition
ความคิดเห็นด้วยโค้ดต่อไปนี้เพื่อลงทะเบียนและจัดการผลลัพธ์ของกิจกรรม.shareDevice()
shareDeviceLauncher = registerForActivityResult(ActivityResultContracts.StartIntentSenderForResult()) { result -> // Share Device Step 5. // The Share Device activity in GPS (step 4) has completed. val resultCode = result.resultCode if (resultCode == RESULT_OK) { Timber.d("ShareDevice: Success") viewModel.shareDeviceSucceeded(selectedDeviceViewModel.selectedDeviceLiveData.value!!) } else { viewModel.shareDeviceFailed( selectedDeviceViewModel.selectedDeviceLiveData.value!!, resultCode) } }
ขั้นตอนที่ 2: ตรวจสอบออบเจ็กต์ LiveData
การเรียกกลับของ .shareDevice()
API ที่สําเร็จจะรวม IntentSender
เพื่อใช้เปิดกิจกรรมการแชร์อุปกรณ์ในบริการ Google Play ใน DeviceViewModel
เราได้สร้างออบเจ็กต์ LiveData 2 รายการเพื่อรายงานผลลัพธ์ของการเรียก API นี้
_shareDeviceStatus
เพื่อติดตามTaskStatus
// The current status of the share device action. viewModel.shareDeviceStatus.observe(viewLifecycleOwner) { status -> val isButtonEnabled = status !is InProgress updateShareDeviceButton(isButtonEnabled) if (status is TaskStatus.Failed) { showAlertDialog(errorAlertDialog, status.message, status.cause!!.toString()) } }
_shareDeviceIntentSender
เพื่อจัดการผลลัพธ์ของการโทร.sharedevice()
viewModel.shareDeviceIntentSender.observe(viewLifecycleOwner) {Sender -> Timber.d("shareDeviceIntentSender.observing จะเรียกใช้ด้วย [${intentSenderToString(sender)}]") หาก (sender != null) { // Share Device ขั้นตอนที่ 4: เปิดใช้กิจกรรมที่อธิบายไว้ใน IntentSender ว่า // ส่งคืนในขั้นตอนที่ 3 (โดยที่ API เรียกการเรียกค่าคอมมิชชัน // ให้ API เรียกใช้ขั้นตอนที่ 3) Timber.d("ShareDevice: เปิดใช้งานกิจกรรม GPS เพื่อแชร์อุปกรณ์") shareDeviceLauncher.launch(IntentSenderRequest.Builder(sender).build()) viewModel.consumeShareDeviceIntentSender() } } ```
ในขั้นตอนถัดไป เราจะใช้ออบเจ็กต์ LiveData เหล่านี้ในการเรียก API ของ .shareDevice()
ขั้นตอนที่ 3: เรียก API
ถึงเวลาเริ่มแชร์อุปกรณ์แล้ว
- เปิด
DeviceViewModel.kt
ในโฟลเดอร์java/screens/device/
- ค้นหาฟังก์ชัน
shareDevice()
แทนที่ความคิดเห็น// CODELAB: shareDevice
ด้วย ShareDeviceRequestDeviceDescriptor
ระบุข้อมูลที่เจาะจงเกี่ยวกับอุปกรณ์ เช่น รหัสผู้ให้บริการ รหัสผลิตภัณฑ์ และประเภทอุปกรณ์ ในตัวอย่างนี้ เราฮาร์ดโค้ดค่าไว้Timber.d("ShareDevice: Setting up the IntentSender") val shareDeviceRequest = ShareDeviceRequest.builder() .setDeviceDescriptor(DeviceDescriptor.builder().build()) .setDeviceName("temp device name")
- ตั้งค่า CommissioningWindow และพารามิเตอร์ ในขั้นนี้ หน้าต่างค่าคอมมิชชันชั่วคราวจะเปิดขึ้นในอุปกรณ์
.setCommissioningWindow( CommissioningWindow.builder() .setDiscriminator(Discriminator.forLongValue(DISCRIMINATOR)) .setPasscode(SETUP_PIN_CODE) .setWindowOpenMillis(SystemClock.elapsedRealtime()) .setDurationSeconds(OPEN_COMMISSIONING_WINDOW_DURATION_SECONDS.toLong()) .build()) .build()
- เรียกใช้
.getCommissioningClient()
เฉพาะครั้งนี้เท่านั้น ให้ใช้.shareDevice()
API การเรียกกลับของcommissioningClient.shareDevice()
API ที่สําเร็จจะทําให้ IntentSender สามารถใช้เพื่อเปิดกิจกรรมการแชร์อุปกรณ์ในบริการ Google PlayMatter.getCommissioningClient(activity) .shareDevice(shareDeviceRequest)
- หากต้องการเพิ่มฟังก์ชัน
shareDevice
ให้เสร็จสิ้น ให้เพิ่มaddOnSuccessListener
และaddOnFailureListener
และโพสต์ลงในออบเจ็กต์ LiveData:.addOnSuccessListener { result -> Timber.d("ShareDevice: Success getting the IntentSender: result [${result}]") // Communication with fragment is via livedata _backgroundWorkAlertDialogAction.postValue(BackgroundWorkAlertDialogAction.Hide) _shareDeviceIntentSender.postValue(result) } .addOnFailureListener { error -> Timber.e(error) _backgroundWorkAlertDialogAction.postValue(BackgroundWorkAlertDialogAction.Hide) _shareDeviceStatus.postValue( TaskStatus.Failed("Setting up the IntentSender failed", error)) }
หลังจากใช้ผู้ส่งแล้ว ควรเรียกใช้ consumeShareDeviceIntentSender
เพื่อหลีกเลี่ยงการรับผู้ส่งอีกครั้งหลังจากเปลี่ยนการกําหนดค่า
/** * Consumes the value in [_shareDeviceIntentSender] and sets it back to null. Needs to be called * to avoid re-processing an IntentSender after a configuration change where the LiveData is * re-posted. */ fun consumeShareDeviceIntentSender() { _shareDeviceIntentSender.postValue(null) }
เรียกใช้แอป
หากต้องการแชร์อุปกรณ์ Matter กับระบบนิเวศอื่นๆ คุณจะต้องติดตั้งแพลตฟอร์มอื่นในอุปกรณ์ Android เราได้สร้างอินสแตนซ์แอปตัวอย่างอีกรายการที่คุณสามารถใช้เป็นค่าคอมมิชชันเป้าหมาย
เมื่อติดตั้งค่าคอมมิชชันเป้าหมายในอุปกรณ์ Android แล้ว ให้ยืนยันว่าคุณแชร์อุปกรณ์ Matter ได้ แอปค่าคอมมิชชันเป้าหมายจะมีป้ายกํากับ GHSAFM-TC
ตอนนี้อุปกรณ์ของคุณเข้าร่วมผ้า 3 เส้นได้แล้ว
- ผ้า Android ในพื้นที่
- กลุ่มการพัฒนาของคุณ (แอปนี้)
- ผ้าที่สามที่คุณเพิ่งแชร์อุปกรณ์ไป
8. ขั้นตอนถัดไป
ขอแสดงความยินดี
ขอแสดงความยินดี คุณติดตั้งใช้งาน Codelab นี้เสร็จสมบูรณ์แล้ว และเรียนรู้วิธีค่าคอมมิชชันและแชร์อุปกรณ์โดยใช้ Home Mobile SDK
หากพบปัญหาเกี่ยวกับแอปตัวอย่าง ให้ลองทําตามขั้นตอนเพื่อยืนยันสภาพแวดล้อมให้เสร็จสมบูรณ์
หากมีข้อสงสัยเกี่ยวกับการใช้แอปตัวอย่างหรือค้นพบข้อบกพร่องของโค้ด คุณส่งปัญหาไปยังเครื่องมือติดตามปัญหาในที่เก็บ GitHub ได้โดยทําดังนี้
หากต้องการคําแนะนําอย่างเป็นทางการจาก Google สําหรับคําถามทางเทคนิค ให้ใช้ฟอรัมนักพัฒนาซอฟต์แวร์สมาร์ทโฮม โดยทําดังนี้
หากต้องการรับการสนับสนุนด้านเทคนิคจากชุมชน ให้ใช้แท็ก google-smart-home
ใน Stack Overflow