Android で Home API を使用して自動化を作成する

$ git clone -b codelab-branch-2 https://github.com/google-home/google-home-api-sample-app-android.git 

automation { name = "AutomationName"   description = "An example automation description."   isActive = true     sequential {     val onOffTrait = starter<_>(device1, OnOffLightDevice, OnOff)     condition() { expression = onOffTrait.onOff equals true }     action(device2, OnOffLightDevice) { command(OnOff.on()) }   } } 

   // List of operations available when creating automation starters: enum class Operation {   EQUALS,   NOT_EQUALS,   GREATER_THAN,   GREATER_THAN_OR_EQUALS,   LESS_THAN,   LESS_THAN_OR_EQUALS     } 

// List of operations available when comparing booleans:  object BooleanOperations : Operations(listOf(      Operation.EQUALS,      Operation.NOT_EQUALS  )) // List of operations available when comparing values: object LevelOperations : Operations(listOf(     Operation.GREATER_THAN,     Operation.GREATER_THAN_OR_EQUALS,     Operation.LESS_THAN,     Operation.LESS_THAN_OR_EQUALS )) 

enum class OnOffValue {    On,    Off, } enum class ThermostatValue {   Heat,   Cool,   Off, } 

val valuesOnOff: Map<OnOffValue, Boolean> = mapOf(   OnOffValue.On to true,   OnOffValue.Off to false, ) val valuesThermostat: Map<ThermostatValue, ThermostatTrait.SystemModeEnum> = mapOf(   ThermostatValue.Heat to ThermostatTrait.SystemModeEnum.Heat,   ThermostatValue.Cool to ThermostatTrait.SystemModeEnum.Cool,   ThermostatValue.Off to ThermostatTrait.SystemModeEnum.Off, ) 

val deviceVMs: List<DeviceViewModel> = structureVM.deviceVMs.collectAsState().value ... DropdownMenu(expanded = expandedDeviceSelection, onDismissRequest = { expandedDeviceSelection = false }) { // TODO: 4.1.1 - Starter device selection dropdown // for (deviceVM in deviceVMs) { //     DropdownMenuItem( //         text = { Text(deviceVM.name) }, //         onClick = { //             scope.launch { //                 starterDeviceVM.value = deviceVM //                 starterType.value = deviceVM.type.value //                 starterTrait.value = null //                 starterOperation.value = null //             } //             expandedDeviceSelection = false //         } //     ) // } } 

// Selected starter attributes for StarterView on screen: val starterDeviceVM: MutableState<DeviceViewModel?> = remember { mutableStateOf(starterVM.deviceVM.value) } ... DropdownMenu(expanded = expandedTraitSelection, onDismissRequest = { expandedTraitSelection = false }) { // TODO: 4.1.2 - Starter device traits selection dropdown // val deviceTraits = starterDeviceVM.value?.traits?.collectAsState()?.value!! // for (trait in deviceTraits) { //     DropdownMenuItem( //         text = { Text(trait.factory.toString()) }, //         onClick = { //             scope.launch { //                 starterTrait.value = trait.factory //                 starterOperation.value = null //             } //             expandedTraitSelection = false //         } //     ) } } 

val starterOperation: MutableState<StarterViewModel.Operation?> = remember {   mutableStateOf(starterVM.operation.value) }   ...   DropdownMenu(expanded = expandedOperationSelection, onDismissRequest = { expandedOperationSelection = false }) {     // ...     if (!StarterViewModel.starterOperations.containsKey(starterTrait.value))     return@DropdownMenu     // TODO: 4.1.3 - Starter device trait operations selection dropdown       // val operations: List<StarterViewModel.Operation> = StarterViewModel.starterOperations.get(starterTrait.value ?: OnOff)?.operations!!     //  for (operation in operations) {     //      DropdownMenuItem(     //          text = { Text(operation.toString()) },     //          onClick = {     //              scope.launch {     //                  starterOperation.value = operation     //              }     //              expandedOperationSelection = false     //          }     //      )     //  } }  

when (starterTrait.value) {   OnOff -> {         ...     DropdownMenu(expanded = expandedBooleanSelection, onDismissRequest = { expandedBooleanSelection = false }) { // TODO: 4.1.4 - Starter device trait values selection dropdown //             for (value in StarterViewModel.valuesOnOff.keys) { //                 DropdownMenuItem( //                     text = { Text(value.toString()) }, //                     onClick = { //                         scope.launch { //                             starterValueOnOff.value = StarterViewModel.valuesOnOff.get(value) //                         } //                         expandedBooleanSelection = false //                     } //                 ) //             }              }               ...           }            LevelControl -> {               ...       }    } 

val draftVM: DraftViewModel = homeAppVM.selectedDraftVM.collectAsState().value!! // Save starter button: Button( enabled = isOptionsSelected && isValueProvided, onClick = {   scope.launch {   // TODO: 4.1.5 - store all starter ViewModel variables into draft ViewModel   // starterVM.deviceVM.emit(starterDeviceVM.value)   // starterVM.trait.emit(starterTrait.value)   // starterVM.operation.emit(starterOperation.value)   // starterVM.valueOnOff.emit(starterValueOnOff.value!!)   // starterVM.valueLevel.emit(starterValueLevel.value!!)   // starterVM.valueBooleanState.emit(starterValueBooleanState.value!!)   // starterVM.valueOccupancy.emit(starterValueOccupancy.value!!)   // starterVM.valueThermostat.emit(starterValueThermostat.value!!)   //   // draftVM.starterVMs.value.add(starterVM)   // draftVM.selectedStarterVM.emit(null)   } }) { Text(stringResource(R.string.starter_button_create)) } 

   // List of operations available when creating automation starters: enum class Action {   ON,   OFF,   MOVE_TO_LEVEL,   MODE_HEAT,   MODE_COOL,   MODE_OFF, } 

 // List of operations available when comparing booleans: object OnOffActions : Actions(listOf(     Action.ON,     Action.OFF, )) // List of operations available when comparing booleans: object LevelActions : Actions(listOf(     Action.MOVE_TO_LEVEL )) // List of operations available when comparing booleans: object ThermostatActions : Actions(listOf(     Action.MODE_HEAT,     Action.MODE_COOL,     Action.MODE_OFF, )) // Map traits and the comparison operations they support: val actionActions: Map<TraitFactory<out Trait>, Actions> = mapOf(     OnOff to OnOffActions,     LevelControl to LevelActions,  // BooleanState - No Actions  // OccupancySensing - No Actions     Thermostat to ThermostatActions, ) 

   val valueLevel: MutableStateFlow<UByte?> 

val deviceVMs = structureVM.deviceVMs.collectAsState().value ... DropdownMenu(expanded = expandedDeviceSelection, onDismissRequest = { expandedDeviceSelection = false }) { // TODO: 4.2.1 - Action device selection dropdown // for (deviceVM in deviceVMs) { //     DropdownMenuItem( //         text = { Text(deviceVM.name) }, //         onClick = { //             scope.launch { //                 actionDeviceVM.value = deviceVM //                 actionTrait.value = null //                 actionAction.value = null //             } //             expandedDeviceSelection = false //         } //     ) // } }  

val actionDeviceVM: MutableState<DeviceViewModel?> = remember { mutableStateOf(actionVM.deviceVM.value) } ... DropdownMenu(expanded = expandedTraitSelection, onDismissRequest = { expandedTraitSelection = false }) { // TODO: 4.2.2 - Action device traits selection dropdown // val deviceTraits: List<Trait> = actionDeviceVM.value?.traits?.collectAsState()?.value!! // for (trait in deviceTraits) { //     DropdownMenuItem( //         text = { Text(trait.factory.toString()) }, //         onClick = { //             scope.launch { //                 actionTrait.value = trait //                 actionAction.value = null //             } //             expandedTraitSelection = false //         } //     ) // } }  

DropdownMenu(expanded = expandedActionSelection, onDismissRequest = { expandedActionSelection = false }) { // ... if (!ActionViewModel.actionActions.containsKey(actionTrait.value?.factory)) return@DropdownMenu // TODO: 4.2.3 - Action device trait actions (commands) selection dropdown // val actions: List<ActionViewModel.Action> = ActionViewModel.actionActions.get(actionTrait.value?.factory)?.actions!! // for (action in actions) { //     DropdownMenuItem( //         text = { Text(action.toString()) }, //         onClick = { //             scope.launch { //                 actionAction.value = action //             } //             expandedActionSelection = false //         } //     ) // } } 

when (actionTrait.value?.factory) { LevelControl -> { // TODO: 4.2.4 - Action device trait action(command) values selection widget // Column (Modifier.padding(horizontal = 16.dp, vertical = 8.dp).fillMaxWidth()) { //   Text(stringResource(R.string.action_title_value), fontSize = 16.sp, fontWeight = FontWeight.SemiBold) //  } // //  Box (Modifier.padding(horizontal = 24.dp, vertical = 8.dp)) { //      LevelSlider(value = actionValueLevel.value?.toFloat()!!, low = 0f, high = 254f, steps = 0, //          modifier = Modifier.padding(top = 16.dp), //          onValueChange = { value : Float -> actionValueLevel.value = value.toUInt().toUByte() } //          isEnabled = true //      ) //  } ... } 

val draftVM: DraftViewModel = homeAppVM.selectedDraftVM.collectAsState().value!! // Save action button: Button(   enabled = isOptionsSelected,   onClick = {   scope.launch {   // TODO: 4.2.5 - store all action ViewModel variables into draft ViewModel   // actionVM.deviceVM.emit(actionDeviceVM.value)   // actionVM.trait.emit(actionTrait.value)   // actionVM.action.emit(actionAction.value)   // actionVM.valueLevel.emit(actionValueLevel.value)   //   // draftVM.actionVMs.value.add(actionVM)   // draftVM.selectedActionVM.emit(null)   } }) { Text(stringResource(R.string.action_button_create)) }  

fun HomeAppView (homeAppVM: HomeAppViewModel) {   ...   // If a draft automation is selected, show the draft editor:   if (selectedDraftVM != null) {     DraftView(homeAppVM)   }   ... }  

fun DraftView (homeAppVM: HomeAppViewModel) {    val draftVM: DraftViewModel = homeAppVM.selectedDraftVM.collectAsState().value!!     ... // Draft Starters:    DraftStarterList(draftVM) // Draft Actions:    DraftActionList(draftVM) }  

val starterVMs: List<StarterViewModel> = starterVMs.value val actionVMs: List<ActionViewModel> = actionVMs.value     ... fun getDraftAutomation() : DraftAutomation {     ...   val starterVMs: List<StarterViewModel> = starterVMs.value     ...   return automation {     this.name = name     this.description = description     this.isActive = true     // The sequential block wrapping all nodes:     sequential {     // The select block wrapping all starters:       select {     // Iterate through the selected starters:         for (starterVM in starterVMs) {         // The sequential block for each starter (should wrap the Starter Expression!)           sequential {               ...               val starterTrait: TraitFactory<out Trait> = starterVM.trait.value!!               ...               when (starterTrait) {                   OnOff -> {         // TODO: 4.4.1 - Set starter expressions according to trait type         //   val onOffValue: Boolean = starterVM.valueOnOff.value         //   val onOffExpression: TypedExpression<out OnOff> =         //       starterExpression as TypedExpression<out OnOff>         //   when (starterOperation) {         //       StarterViewModel.Operation.EQUALS ->         //           condition { expression = onOffExpression.onOff equals onOffValue }         //       StarterViewModel.Operation.NOT_EQUALS ->         //           condition { expression = onOffExpression.onOff notEquals onOffValue }         //       else -> { MainActivity.showError(this, "Unexpected operation for OnOf         //   }         }    LevelControl -> {      ... // Function to allow manual execution of the automation: manualStarter()      ... }  

val starterVMs: List<StarterViewModel> = starterVMs.value val actionVMs: List<ActionViewModel> = actionVMs.value     ... fun getDraftAutomation() : DraftAutomation {       ...   return automation {     this.name = name     this.description = description     this.isActive = true     // The sequential block wrapping all nodes:     sequential {           ...     // Parallel block wrapping all actions:       parallel {         // Iterate through the selected actions:         for (actionVM in actionVMs) {           val actionDeviceVM: DeviceViewModel = actionVM.deviceVM.value!!         // Action Expression that the DSL will check for:           action(actionDeviceVM.device, actionDeviceVM.type.value.factory) {             val actionCommand: Command = when (actionVM.action.value) {                   ActionViewModel.Action.ON -> { OnOff.on() }                   ActionViewModel.Action.OFF -> { OnOff.off() }     // TODO: 4.4.2 - Set starter expressions according to trait type     // ActionViewModel.Action.MOVE_TO_LEVEL -> {     //     LevelControl.moveToLevelWithOnOff(     //         actionVM.valueLevel.value!!,     //         0u,     //         LevelControlTrait.OptionsBitmap(),     //         LevelControlTrait.OptionsBitmap()     //     )     // }       ActionViewModel.Action.MODE_HEAT -> { SimplifiedThermostat       .setSystemMode(SimplifiedThermostatTrait.SystemModeEnum.Heat) }           ... } 

fun createAutomation(isPending: MutableState<Boolean>) {   viewModelScope.launch {     val structure : Structure = selectedStructureVM.value?.structure!!     val draft : DraftAutomation = selectedDraftVM.value?.getDraftAutomation()!!     isPending.value = true     // TODO: 4.4.3 - Call the Home API to create automation and handle exceptions     // // Call Automation API to create an automation from a draft:     // try {     //     structure.createAutomation(draft)     // }     // catch (e: Exception) {     //     MainActivity.showError(this, e.toString())     //     isPending.value = false     //     return@launch     // }     // Scrap the draft and automation candidates used in the process:     selectedCandidateVMs.emit(null)     selectedDraftVM.emit(null)     isPending.value = false   } }  

   fun showCandidates() {     ... // TODO: 5.1.1 - Retrieve automation candidates, filtering to include CommandCandidate types only // // Retrieve a set of initial automation candidates from the device: // val candidates: Set<NodeCandidate> = deviceVM.device.candidates().first() // // for (candidate in candidates) { //     // Check whether the candidate trait is supported: //     if(candidate.trait !in HomeApp.supportedTraits) //         continue //     // Check whether the candidate type is supported: //     when (candidate) { //         // Command candidate type: //         is CommandCandidate -> { //             // Check whether the command candidate has a supported command: //             if (candidate.commandDescriptor !in ActionViewModel.commandMap) //                 continue //         } //         // Other candidate types are currently unsupported: //         else -> { continue } //     } // //     candidateVMList.add(CandidateViewModel(candidate, deviceVM)) // } ...            // Store the ViewModels: selectedCandidateVMs.emit(candidateVMList) }  

    // Map of supported commands from Discovery API: val commandMap: Map<CommandDescriptor, Action> = mapOf(     // TODO: 5.1.2 - Set current supported commands     // OnOffTrait.OnCommand to Action.ON,     // OnOffTrait.OffCommand to Action.OFF,     // LevelControlTrait.MoveToLevelWithOnOffCommand to Action.MOVE_TO_LEVEL )  

fun CandidateListItem (candidateVM: CandidateViewModel, homeAppVM: HomeAppViewModel) {     val scope: CoroutineScope = rememberCoroutineScope()     Box (Modifier.padding(horizontal = 24.dp, vertical = 8.dp)) {         Column (Modifier.fillMaxWidth().clickable {         // TODO: 5.2.1 - Set the selectedDraftVM to the selected candidate         // scope.launch { homeAppVM.selectedDraftVM.emit(DraftViewModel(candidateVM)) }         }) {             ...         }     } }  

fun HomeAppView (homeAppVM: HomeAppViewModel) {    ...   val selectedDraftVM: DraftViewModel? by homeAppVM.selectedDraftVM.collectAsState() ...   // If a draft automation is selected, show the draft editor:   if (selectedDraftVM != null) {   DraftView(homeAppVM)   }    ... } 

automation {   name = "AutomationName"   description = "An example automation description."   isActive = true   description = "Do ... actions when time is up."   sequential {     // starter     val starter = starter<_>(structure, Time.ScheduledTimeEvent) {       parameter(         Time.ScheduledTimeEvent.clockTime(           LocalTime.of(hour, min, sec, 0)         )       )     }         // action   ...   } }  

automation {   name = "AutomationName"   description = "An example automation description."   isActive = true   description = "Broadcast in Speaker when ..."   sequential {     // starter       ...     // action     action(structure) {       command(       AssistantBroadcast.broadcast("Time is up!!")       )     }   } }  

sequential {   val starterNode = starter<_>(device, OccupancySensorDevice, MotionDetection)   // only proceed if there is currently motion taking place   condition { starterNode.motionDetectionEventInProgress equals true }    // ignore the starter for one minute after it was last triggered     suppressFor(Duration.ofMinutes(1))        // make announcements three seconds apart     action(device, SpeakerDevice) {       command(AssistantBroadcast.broadcast("Intruder detected!"))     }     delayFor(Duration.ofSeconds(3))     action(device, SpeakerDevice) {     command(AssistantBroadcast.broadcast("Intruder detected!"))   }     ... }  

automation {   name = "Lock the doors when someone is home after 10pm"   description = "1 starter, 2 actions"   sequential {     val unused =       starter(structure, event = Time.ScheduledTimeEvent) {         parameter(Time.ScheduledTimeEvent.clockTime(LocalTime.of(22, 0, 0, 0)))       }     val stateReaderNode = stateReader<_>(structure, AreaPresenceState)     condition {       expression =         stateReaderNode.presenceState equals           AreaPresenceStateTrait.PresenceState.PresenceStateOccupied     }     action(structure) { command(AssistantBroadcast.broadcast("Locks are being applied")) }     for (lockDevice in lockDevices) {       action(lockDevice, DoorLockDevice) {         command(Command(DoorLock, DoorLockTrait.LockDoorCommand.requestId.toString(), mapOf()))       }     }   }