법적 사안용 Android 앱 빌드

1. 소개

IoT 표준을 통합한다는 목표로 구축된 Matter는 Google Home, Zigbee, 블루투스 메시, Z-Wave 등 다양한 생태계 전반에 걸쳐 스마트 홈 기기를 연결합니다.

휴대기기는 스마트 홈 기기와의 주요 상호작용 지점입니다. Matter 기기를 지원하는 자체 Android 앱을 빌드하려는 경우 빠르게 시작할 수 있도록 도와드리겠습니다.

Matter용 Google Home 샘플 앱 (Matter용 GHSA)에서는 사용자가 기기를 커미셔닝하고 공유할 수 있는 Home 모바일 SDK API를 보여줍니다. 또한 샘플 앱을 학습 도구로 사용하여 주요 Matter 개념을 더 잘 이해할 수 있을 뿐만 아니라 Matter 기기와의 상호작용을 디버깅하고 문제를 해결하는 도구로도 사용할 수 있습니다.

실습할 내용

이 Codelab에서는 샘플 앱의 소스 코드를 다운로드하고 Home 모바일 SDK를 사용하여 기기를 커미셔닝하고 공유하는 방법을 알아봅니다. Matter 저장소 (connectedhomeip)에서 커미셔닝 및 클러스터 라이브러리를 사용하는 방법도 알아봅니다.

샘플 앱을 다운로드한 후에는 Android 스튜디오에서 소스 코드를 검토하고 다음 Home Mobile SDK API를 구현합니다.

또한 커미셔닝 개념, Matter 패브릭, Matter 기기 제어 방법도 자세히 알아볼 수 있습니다.

필요한 항목

시작하기 전에 다음 단계를 완료해야 합니다.

샘플 앱으로 기기를 커미셔닝하고 제어하는 데 Google Nest Hub (2세대)와 같은 허브가 필요하지 않습니다.

2. 설정

Codelab 시작 앱은 codelab 브랜치에 있습니다. Codelab 소스 코드 작업을 시작하려면 ZIP 파일을 다운로드하면 됩니다.

이 codelab ZIP 파일을 사용하여 작동하는 샘플을 빌드합니다.

Codelab 버전

codelab 브랜치는 샘플 앱의 2.0.0 버전으로 태그가 지정됩니다. 각 단계를 진행하면서 업데이트를 비교하려면 이 버전의 완성된 소스 코드를 다운로드하세요.

GitHub 저장소를 클론하려면 샘플 앱 리드미의 안내를 따르세요.

종속 항목

기기를 공유하고 커미셔닝하는 데 필요한 소스 코드를 안내해 드리겠지만 시작하기 전에 다음 종속 항목을 알면 도움이 될 수 있습니다. 이러한 종속 항목은 libs.versions.toml 파일에서 선언되며 용도는 build.gradle.kts 파일에 지정되어 있습니다.

소스 코드

사용자 인터페이스와 대부분의 기능은 이미 준비되어 있습니다.

이 Codelab에서는 다음 파일에 Matter 기능을 추가합니다.

  • java/commissioning/AppCommissioningService: 기기를 개발 패브릭에 커미셔닝할 수 있습니다.
  • java/screens/home/HomeScreen 및 java/screens/home/HomeViewModel.kt: 홈 모바일 SDK 커미셔닝 기능 포함
  • java/screens/device/DeviceScreen 및 java/screens/device/DeviceViewModel: Share Device API 호출 포함

각 파일은 수정할 코드 블록으로 주석 처리됩니다. 예를 들면 다음과 같습니다.

// CODELAB: add commissioningFunction()

이렇게 하면 Codelab에서 상응하는 섹션을 빠르게 찾을 수 있습니다.

3. Google 수수료

기기를 제어하고 동일한 패브릭 내에서 서로 통신할 수 있도록 하려면 위원회에 의뢰해야 합니다. 이 경우에는 Matter용 Google Home 샘플 앱인 샘플 애플리케이션입니다.

Matter 커미셔닝에 관한 다음 개념을 이해하는 것이 중요합니다.

  • 패브릭은 기기가 서로 통신할 수 있게 해줍니다.
  • 패브릭은 고유한 사용자 인증 정보의 공유 집합을 유지합니다.
  • 생태계는 신뢰할 수 있는 루트 인증서 발급, 패브릭 ID 할당, 고유 노드 ID 할당을 담당합니다. 생태계는 위탁원의 백엔드 서비스입니다(예: Google Home 생태계의 Home Graph).
  • 기기를 두 개 이상의 패브릭에 커미셔닝할 수 있습니다 (멀티 관리자 기능).

기기를 커미셔닝하려면 CommissioningClient API를 사용해야 합니다. .commissionDevice()를 호출하면 IntentSender가 반환되어 Google Play 서비스에서 적절한 활동이 시작됩니다.

interface CommissioningClient {
  Task<IntentSender> commissionDevice(CommissioningRequest request);
}

다음 섹션에서는 기기를 Google 패브릭에 커미셔닝하는 데 필요한 최소한의 코드를 살펴봅니다.

1단계: 활동 런처

CommissioningClient에서 IntentSender를 처리하려면 ActivityResultLauncher를 사용하면 됩니다.

val 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 패브릭에 기기를 커미셔닝하는 기본 예시입니다.

  1. 커미셔닝 프로세스는 commissionDevice() 함수로 시작합니다. 먼저 CommissioningRequest가 정의됩니다. 이 기본 구성을 사용하면 기기가 로컬 Android 패브릭에만 커미셔닝됩니다.
  2. Matter는 홈 모바일 SDK의 진입점입니다. 다음 호출에서 .getCommissioningClient가 this (활동)의 CommissioningClient를 가져옵니다.
  3. .commissionDevice()는 CommissioningRequest를 허용합니다.
  4. 마지막으로 .addOnSuccessListener가 호출되어 CommissioningResult를 처리하고 Google Play 서비스 (GPS) Commission Device 활동을 실행합니다.
private fun commissionDevice() {
    val request: CommissioningRequest = CommissioningRequest.builder().build()
    Matter.getCommissioningClient(this)
        .commissionDevice(request)
        .addOnSuccessListener { result ->
            commissioningLauncher.launch(IntentSenderRequest.Builder(result).build())
        }
}

로컬 Android Fabric을 Android 설정을 통해 활용하여 다른 패브릭에 기기를 커미셔닝하는 프로세스를 간소화할 수 있습니다.

이제 개발 패브릭에 기기를 커미셔닝하는 방법을 알아봅니다.

커미셔닝 프로세스 중 사용자 인터페이스에 관한 개요는 Matter용 Google Home 샘플 앱 가이드를 참고하세요.

4. 개발 패브릭에 대한 수수료

기기를 두 개 이상의 패브릭에 커미셔닝할 수 있습니다. 신뢰할 수 있는 페어링을 관리하기 위해 기기는 다음과 같이 다양한 FabricInfo 멤버가 포함된 FabricTable를 저장합니다.

  • 패브릭 식별
  • 패브릭에서 기기에 할당한 노드 ID
  • 공급업체 ID
  • Fabric ID
  • 기기 작동 사용자 인증 정보

관리 도메인 관리자 (ADM)는 패브릭 크리덴셜을 정의합니다. 이전 시나리오에서 Google Play 서비스는 신뢰할 수 있는 루트 인증 기관 (CA) 역할을 하는 생태계입니다. 로컬 Android 패브릭에 기기를 커미셔닝하면 모든 기기에 동일한 패브릭 사용자 인증 정보 세트와 동일한 CA 세트가 포함됩니다.

맞춤 커미셔닝 서비스

로컬 Android 패브릭에 커미셔닝하기 위해 기본 매개변수를 사용하여 CommissioningClient API에서 CommissioningRequest를 빌드했습니다.

val request: CommissioningRequest = CommissioningRequest.builder().build()

앱에서 새 기기를 제어하고 관리하려면 로컬 개발 패브릭을 만들고 기기를 커미셔닝하기 위한 작동 사용자 인증 정보를 가져와야 합니다. 이 시나리오에서 앱은 기기에 적절한 노드 사용자 인증 정보를 할당하는 고유하고 독립적인 생태계가 됩니다.

CommissioningRequest에 맞춤 서비스를 전달하여 기기를 자체 패브릭에 커미셔닝하려고 함을 Home 모바일 SDK에 알릴 수 있습니다.

class CommissioningRequest {
  static CommissioningRequest.Builder builder();

  class Builder {
    Builder setCommissioningService(@Nullable ComponentName commissioningService);

    CommissioningRequest build();
  }
}

다음 단계에서는 커스텀 서비스를 사용하도록 commissionDevice() 함수를 수정합니다. 또한 Home 프래그먼트에 활동 런처를 추가하고 LiveData 객체를 사용하여 API 흐름을 관리합니다.

1단계: GPS 활동 런처 만들기

먼저 CommissioningClient API에서 IntentSender를 처리할 활동 런처를 만들어 보겠습니다.

  1. java/screens/home/ 폴더에서 HomeScreen을 엽니다.
  2. // CODELAB: commissionDeviceLauncher definition 주석을 다음 코드로 대체하여 커미셔닝 활동 결과를 등록하고 처리합니다.
    val commissionDeviceLauncher =
  rememberLauncherForActivityResult(
    contract = ActivityResultContracts.StartIntentSenderForResult()
  ) { result ->
    // Commission Device Step 5.
    // The Commission Device activity in GPS (step 4) has completed.
    val resultCode = result.resultCode
    if (resultCode == Activity.RESULT_OK) {
      Timber.d("CommissionDevice: Success")
      // We let the ViewModel know that GPS commissioning has completed successfully.
      // The ViewModel knows that we still need to capture the device name and will\
      // update UI state to trigger the NewDeviceAlertDialog.
      homeViewModel.gpsCommissioningDeviceSucceeded(result)
    } else {
      homeViewModel.commissionDeviceFailed(resultCode)
    }
  }

2단계: 수수료 기기 작업 트리거

이 단계에서는 사용자가 홈 화면 오른쪽 하단의 '+' 버튼을 클릭하여 '수수료 기기' 작업을 트리거합니다. 그런 다음 commissionDevice()가 호출됩니다.

val onCommissionDevice = {
  ...
  commissionDevice(activity!!.applicationContext, commissionDeviceLauncher)
}

3단계: API 호출

  1. 아직 HomeScreen.kt의 java/screens/home/ 폴더에 있습니다.
  2. // CODELAB: commissionDevice 주석을 다음 commissionDeviceRequest로 바꿉니다. setCommissioningService는 AppCommissioningService를 콜백 함수에서 반환된 CommissioningService 인스턴스에 바인딩합니다. 맞춤 서비스를 전달하면 Home 모바일 SDK가 먼저 기기를 Android 로컬 패브릭에 커미션한 후 온보딩 페이로드를 다시 AppCommissioningService로 전송합니다.
    val commissionDeviceRequest =
    CommissioningRequest.builder()
        .setCommissioningService(ComponentName(
            context, AppCommissioningService::class.java))
        .build()
  3. .getCommissioningClient()를 호출한 다음 .commissionDevice()를 호출합니다.
Matter.getCommissioningClient(context)
    .commissionDevice(commissionDeviceRequest)

commissionDevice 함수를 완료하려면 addOnSuccessListener 및 addOnFailureListener를 추가합니다.

    .addOnSuccessListener { result ->
      commissionDeviceLauncher.launch(IntentSenderRequest.Builder(result).build())
    }
    .addOnFailureListener { error ->
      Timber.e(error)
    }

5. CommissioningService 만들기

commissionDevice() 함수에서 CommissioningClient API에서 CommissioningService를 가져오도록 요청했습니다. 이 흐름에서 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의 기본 클래스 구조를 이미 정의했습니다. 다음은 서비스 기능에 대한 간략한 개요입니다. 확인하려면 java/commissioning에서 AppCommissioningService을(를) 여세요.

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 및 Kotlin 코루틴을 지원하는 가져오기가 포함됩니다.

다음으로 생성자를 만들고 commissioningServiceDelegate를 비롯한 몇 가지 항목을 설정합니다. 이 생성자는 커미셔닝이 완료되면 Google Play 서비스에 알리는 데 사용됩니다.

private lateinit var commissioningServiceDelegate: CommissioningService
...
commissioningServiceDelegate = CommissioningService.Builder(this).setCallback(this).build()

이제 커미셔닝 기능을 추가할 차례입니다.

2단계: onCommissioningRequested 재정의

앱의 개발 패브릭에 기기를 커미셔닝하려면 다음 단계를 완료하세요.

  1. java/commissioning에서 AppCommissioningService 앱을 엽니다.
  2. onCommissioningRequested() 함수를 찾습니다. CommissioningRequestMetadata를 출력하는 로그 메시지가 제공됩니다. // CODELAB: onCommissioningRequested() 주석을 바꿔 serviceScope 코루틴을 시작하고 deviceId를 가져옵니다.
    // Perform commissioning on custom fabric for the sample app.
serviceScope.launch {
  val deviceId = devicesRepository.incrementAndReturnLastDeviceId()
  3. 커미셔닝을 수행합니다. 이 단계에서는 CommissioningRequestMetadata 객체에 반환된 기기 정보를 전달할 수 있습니다. ChipClient는 이 메타데이터 정보를 사용하여 Matter용 GHSA 앱과 기기 간에 보안 채널을 만듭니다.
    try {
  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)
} catch (e: Exception) {
  Timber.e(e, "onCommissioningRequested() failed")
  // No way to determine whether this was ATTESTATION_FAILED or DEVICE_UNREACHABLE.
  commissioningServiceDelegate
      .sendCommissioningError(CommissioningError.OTHER)
      .addOnSuccessListener {
        Timber.d(
            "Commissioning: commissioningServiceDelegate.sendCommissioningError() succeeded")
      }
      .addOnFailureListener { e2 ->
        Timber.e(e2, "Commissioning: commissioningServiceDelegate.sendCommissioningError() failed")
      }
  return@launch
}
  4. commissioningServiceDelegate를 사용하여 Google Play 서비스에 커미셔닝이 완료되었음을 알립니다. .sendCommissioningComplete()에서 CommissioningCompleteMetadata를 전달합니다.
    commissioningServiceDelegate
    .sendCommissioningComplete(
        CommissioningCompleteMetadata.builder().setToken(deviceId.toString()).build())
    .addOnSuccessListener {
      Timber.d("Commissioning: commissioningServiceDelegate.sendCommissioningComplete() succeeded")
    }
    .addOnFailureListener { e ->
      Timber.e(e, "Commissioning: commissioningServiceDelegate.sendCommissioningComplete() failed")
    }

앱 실행

이제 현지 패브릭에 커미셔닝하는 데 필요한 모든 코드가 준비되었으므로 테스트할 차례입니다. Android 기기를 선택하고 앱을 실행합니다. 홈 화면에서 기기 추가를 탭하고 기기 커미셔닝 단계를 완료합니다.

커미셔닝이 완료되면 기기가 로컬 Android 패브릭과 로컬 개발 패브릭의 두 가지 패브릭에 참여합니다. 각 패브릭에는 고유한 사용자 인증 정보 세트와 고유한 64비트 패브릭 ID가 있습니다.

6. 기기 제어

개발 패브릭을 커미셔닝하면 Matter 저장소 (connectedhomeip)의 라이브러리를 사용하여 샘플 앱에서 기기를 제어할 수 있습니다.

기기 클러스터에 더 쉽게 액세스하고 명령어를 전송할 수 있도록 몇 가지 도우미 클래스를 만들었습니다. 자세히 알아보려면 java/clusters에서 ClustersHelper을(를) 여세요. 이 싱글톤 도우미는 다음 라이브러리를 가져와 기기 정보에 액세스합니다.

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 클라이언트는 기기 커미셔닝 중에 설정된 보안 운영 채널을 통해 명령어를 전송합니다.

장치에서 패킷을 검사하고 복호화한 후 콜백과 함께 전달합니다. 콜백 함수에는 attributePath에서 액세스할 수 있는 EndpointId, ClusterId, AttributeId가 포함됩니다. 예를 들어 다음 코드를 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를 사용하여 기기를 전환합니다.

  1. java/screens/device의 DeviceViewModel(으)로 이동하세요.
  2. updateDeviceStateOn 함수를 찾습니다.
  3. // 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")
    }

이 함수는 DeviceScreen에서 호출됩니다.

// On/Off Switch click.
val onOnOffClick: (value: Boolean) -> Unit = { value ->
  deviceViewModel.updateDeviceStateOn(deviceUiModel!!, value)
}

앱 실행

앱을 실행하여 업데이트를 새로고침합니다. 홈 화면에서 기기를 켜거나 끕니다.

7. 다른 생태계와 기기 공유

Matter 사양에서는 기기 공유를 다중 관리자 흐름이라고 합니다.

이전 단계에서 홈 모바일 SDK를 사용하면 기기를 로컬 Android 패브릭과 샘플 앱용 개발 패브릭에 커미셔닝할 수 있다는 것을 배웠습니다. 이는 기기를 두 개 이상의 패브릭에 커미셔닝할 수 있는 다중 관리자 흐름의 예입니다.

특히 사람들이 애플리케이션과 플랫폼에 관한 선호가 있는 가정에서 기기를 더 많은 패브릭으로 공유해야 할 수 있습니다.

Home 모바일 SDK는 ShareDeviceRequest API에서 이 기능을 제공하므로 다음을 수행할 수 있습니다.

  1. 기기의 임시 커미셔닝 창을 엽니다.
  2. 기기의 상태를 변경하여 다른 패브릭에 커미셔닝할 수 있도록 합니다.
  3. 다른 앱과 생태계에서 기기를 제어하세요.

다음 단계에서는 Home 모바일 SDK를 사용하여 기기를 공유합니다.

1단계: GPS 활동 런처 만들기

개발 패브릭에 위탁할 때 만든 커미셔닝 활동 런처와 유사하게, CommissioningClient API의 IntentSender를 처리하기 위한 공유 기기 활동 런처를 만들었습니다.

  1. java/screens/device/ 폴더에서 DeviceScreen을 엽니다.
  2. // CODELAB: shareDeviceLauncher definition 주석을 다음 코드로 대체하여 .shareDevice() 활동 결과를 등록하고 처리합니다.
    val shareDeviceLauncher = rememberLauncherForActivityResult(
  contract = ActivityResultContracts.StartIntentSenderForResult()
) { result ->
  // Commission Device Step 5.
  // The Share Device activity in GPS (step 4) has completed.
  val resultCode = result.resultCode
  if (resultCode == Activity.RESULT_OK) {
    deviceViewModel.shareDeviceSucceeded()
  } else {
    deviceViewModel.shareDeviceFailed(resultCode)
  }
}

2단계: 기기 공유 작업 트리거

이 단계에서는 사용자가 기기 화면에서 '공유' 버튼을 클릭하여 '기기 공유' 작업을 트리거합니다. 그런 다음 deviceViewModel가 호출되어 기기 공유를 위한 페어링 창이 열립니다.

// Share Device button click.
val onShareDevice: () -> Unit = {
 deviceViewModel.openPairingWindow(deviceUiModel!!.device.deviceId)
}

페어링 창을 성공적으로 열면 deviceViewModel는 이 사실을 UI에 전달합니다. ViewModel와 UI 간의 통신은 StateFlow 객체를 통해 이루어집니다.

// Communicate to the UI that the pairing window is open.
// UI can then launch the GPS activity for device sharing.
_pairingWindowOpenForDeviceSharing.value = true

StateFlow 객체의 변경사항을 확인하면 DeviceScreen은 다음 호출을 실행합니다.

shareDevice(activity!!.applicationContext, shareDeviceLauncher, deviceViewModel)

3단계: API 호출

이제 기기 공유 작업을 시작해 보겠습니다.

  1. java/screens/device/ 폴더에서 DeviceScreen.kt을 엽니다.
  2. shareDevice() 함수를 찾습니다. // CODELAB: shareDevice 주석을 ShareDeviceRequest로 바꿉니다. DeviceDescriptor는 공급업체 ID, 제품 ID, deviceType과 같은 기기에 관한 구체적인 정보를 제공합니다. 이 예시에서는 값을 하드 코딩합니다.
    val shareDeviceRequest =
  ShareDeviceRequest.builder()
    .setDeviceDescriptor(DeviceDescriptor.builder().build())
    .setDeviceName("GHSAFM temp device name")
  3. CommissioningWindow 및 매개변수를 설정합니다.
        .setCommissioningWindow(
        CommissioningWindow.builder()
            .setDiscriminator(Discriminator.forLongValue(DISCRIMINATOR))
            .setPasscode(SETUP_PIN_CODE)
            .setWindowOpenMillis(SystemClock.elapsedRealtime())
            .setDurationSeconds(OPEN_COMMISSIONING_WINDOW_DURATION_SECONDS.toLong())
            .build())
    .build()
  4. .getCommissioningClient()를 호출합니다. 이번에는 .shareDevice() API를 사용합니다.
    Matter.getCommissioningClient(context)
    .shareDevice(shareDeviceRequest)

commissioningClient.shareDevice() API의 성공 콜백은 Google Play 서비스에서 기기 공유 활동을 시작하는 데 사용되는 IntentSender를 제공합니다.

  1. shareDevice 함수를 완료하려면 addOnSuccessListener 및 addOnFailureListener를 추가합니다. 성공하면 launch가 shareDeviceLauncher에서 호출되어 기기 공유를 위한 GPS 활동을 시작합니다.
        .addOnSuccessListener { result ->
      Timber.d("ShareDevice: Success getting the IntentSender: result [${result}]")
      shareDeviceLauncher.launch(IntentSenderRequest.Builder(result).build())
    }
    .addOnFailureListener { error ->
      Timber.e(error)
      deviceViewModel.showMsgDialog("Share device failed", error.toString())
    }

앱 실행

Matter 기기를 다른 생태계와 공유하려면 Android 기기에 다른 플랫폼을 설치해야 합니다. 타겟 커미셔닝자로 사용할 수 있는 샘플 앱 인스턴스를 하나 더 만들었습니다.

Android 기기에 타겟 커미셔너를 설치한 후 Matter 기기를 공유할 수 있는지 확인합니다. 타겟 커미셔너 앱에는 GHSAFM-TC라는 라벨이 지정됩니다.

이제 기기가 다음 세 가지 패브릭에 참여할 수 있습니다.

  1. 로컬 Android 패브릭
  2. 개발 패브릭 (이 앱)
  3. 방금 기기를 공유한 세 번째 패브릭입니다.

8. 다음 단계

축하합니다

축하합니다. 이 Codelab을 완료하고 Home 모바일 SDK를 사용하여 기기를 커미셔닝하고 공유하는 방법을 배웠습니다.

샘플 앱에 문제가 있는 경우 다음 단계를 완료하여 환경을 확인해 보세요.

샘플 앱 사용에 관한 질문이 있거나 코드 버그를 발견한 경우 GitHub 저장소의 Issue Tracker에 문제를 제출할 수 있습니다.

기술적인 질문에 관해 Google로부터 공식 안내를 받으려면 스마트 홈 개발자 포럼을 이용하세요.

커뮤니티에서 기술 지원을 받으려면 Stack Overflow에서 google-smart-home 태그를 사용하세요.