Changes for Home assistant support

README.md

@@ -41,6 +41,8 @@ Currently Dicio answers questions about:
 - **media**: play, pause, previous, next song
 - **translation**: translate from/to any language with **Lingva** - _How do I say Football in German?_
 - **wake word control**: turn on/off the wakeword - _Stop listening_
+- **home assistant**: query and control **Home Assistant** entities - _Turn living room light on_, _Turn kitchen radio to BBC Radio 2_
+  - Note: Media source selection with number homophones (e.g., "too" → "2") is currently English-only
 - **notifications**: reads all notifications currently in the status bar - _What are my notifications?_
 - **flashlight**: turn on/off the phone flashlight - _Turn on the flashlight_
 

app/src/main/kotlin/org/stypox/dicio/eval/SkillHandler.kt

@@ -32,6 +32,7 @@ import org.stypox.dicio.skills.translation.TranslationInfo
 import org.stypox.dicio.skills.weather.WeatherInfo
 import org.stypox.dicio.skills.joke.JokeInfo
 import org.stypox.dicio.skills.flashlight.FlashlightInfo
+import org.stypox.dicio.skills.homeassistant.HomeAssistantInfo
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -58,6 +59,7 @@ class SkillHandler @Inject constructor(
         TranslationInfo,
         NotifyInfo,
         FlashlightInfo,
+        HomeAssistantInfo,
     )
 
     private val fallbackSkillInfoList = listOf(

app/src/main/kotlin/org/stypox/dicio/skills/homeassistant/EntityMappingsEditor.kt

@@ -0,0 +1,322 @@
+package org.stypox.dicio.skills.homeassistant
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material3.Card
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TextField
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import org.stypox.dicio.R
+
+/**
+ * Editor UI for managing Home Assistant entity mappings (friendly name <-> entity ID).
+ * Supports adding, editing, and deleting mappings.
+ */
+@Composable
+fun EntityMappingsEditor(
+    mappings: List<EntityMapping>,
+    baseUrl: String,
+    accessToken: String,
+    onMappingsChange: (List<EntityMapping>) -> Unit,
+) {
+    var showDialog by remember { mutableStateOf(false) }
+    var editIndex by remember { mutableStateOf(-1) }
+
+    Column(modifier = Modifier.fillMaxWidth()) {
+        Row(
+            modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp),
+            horizontalArrangement = Arrangement.SpaceBetween,
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Text(
+                text = stringResource(R.string.pref_homeassistant_entity_mappings),
+                style = MaterialTheme.typography.titleMedium
+            )
+            IconButton(onClick = {
+                editIndex = -1
+                showDialog = true
+            }) {
+                Icon(Icons.Default.Add, contentDescription = stringResource(R.string.pref_homeassistant_add_mapping))
+            }
+        }
+
+        mappings.forEachIndexed { index, mapping ->
+            Card(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 16.dp, vertical = 4.dp)
+                    .clickable {
+                        editIndex = index
+                        showDialog = true
+                    }
+            ) {
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(12.dp),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Column(modifier = Modifier.weight(1f)) {
+                        Text(
+                            text = mapping.friendlyName,
+                            style = MaterialTheme.typography.bodyLarge
+                        )
+                        Text(
+                            text = mapping.entityId,
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                    IconButton(onClick = {
+                        onMappingsChange(mappings.filterIndexed { i, _ -> i != index })
+                    }) {
+                        Icon(Icons.Default.Delete, contentDescription = "Delete")
+                    }
+                }
+            }
+        }
+    }
+
+    if (showDialog) {
+        EntityMappingDialog(
+            baseUrl = baseUrl,
+            accessToken = accessToken,
+            initialMapping = if (editIndex >= 0) mappings[editIndex] else null,
+            onDismiss = { showDialog = false },
+            onSave = { friendlyName, entityId ->
+                val newMapping = EntityMapping.newBuilder()
+                    .setFriendlyName(friendlyName)
+                    .setEntityId(entityId)
+                    .build()
+
+                val newMappings = if (editIndex >= 0) {
+                    mappings.toMutableList().apply { set(editIndex, newMapping) }
+                } else {
+                    mappings + newMapping
+                }
+                onMappingsChange(newMappings)
+                showDialog = false
+            }
+        )
+    }
+}
+
+/**
+ * Dialog for adding or editing a single entity mapping.
+ * Includes a "Pick" button that fetches entities from Home Assistant for selection.
+ */
+@Composable
+fun EntityMappingDialog(
+    baseUrl: String,
+    accessToken: String,
+    initialMapping: EntityMapping?,
+    onDismiss: () -> Unit,
+    onSave: (String, String) -> Unit
+) {
+    var friendlyName by remember { mutableStateOf(initialMapping?.friendlyName ?: "") }
+    var entityId by remember { mutableStateOf(initialMapping?.entityId ?: "") }
+    var showEntityPicker by remember { mutableStateOf(false) }
+    var entities by remember { mutableStateOf<List<Pair<String, String>>>(emptyList()) }
+    var isLoading by remember { mutableStateOf(false) }
+    val scope = rememberCoroutineScope()
+
+    Dialog(onDismissRequest = onDismiss) {
+        Card(
+            modifier = Modifier.fillMaxWidth(),
+            shape = MaterialTheme.shapes.extraLarge
+        ) {
+            Column(modifier = Modifier.padding(16.dp)) {
+                Text(
+                    text = if (initialMapping == null)
+                        stringResource(R.string.pref_homeassistant_add_mapping)
+                    else
+                        "Edit Mapping",
+                    style = MaterialTheme.typography.titleLarge,
+                    textAlign = TextAlign.Center,
+                    modifier = Modifier.fillMaxWidth().padding(bottom = 16.dp)
+                )
+
+                TextField(
+                    value = friendlyName,
+                    onValueChange = { friendlyName = it },
+                    label = { Text(stringResource(R.string.pref_homeassistant_friendly_name)) },
+                    modifier = Modifier.fillMaxWidth().padding(bottom = 8.dp)
+                )
+
+                Row(
+                    modifier = Modifier.fillMaxWidth().padding(bottom = 16.dp),
+                    horizontalArrangement = Arrangement.spacedBy(8.dp)
+                ) {
+                    TextField(
+                        value = entityId,
+                        onValueChange = { entityId = it },
+                        label = { Text(stringResource(R.string.pref_homeassistant_entity_id)) },
+                        modifier = Modifier.weight(1f)
+                    )
+                    TextButton(
+                        onClick = {
+                            if (baseUrl.isNotBlank() && accessToken.isNotBlank()) {
+                                isLoading = true
+                                scope.launch {
+                                    try {
+                                        val states = withContext(Dispatchers.IO) {
+                                            HomeAssistantApi.getAllStates(baseUrl, accessToken)
+                                        }
+                                        entities = (0 until states.length()).map { i ->
+                                            val entity = states.getJSONObject(i)
+                                            val id = entity.getString("entity_id")
+                                            val name = entity.getJSONObject("attributes")
+                                                .optString("friendly_name", id)
+                                            id to name
+                                        }.sortedBy { it.first }
+                                        showEntityPicker = true
+                                    } catch (e: Exception) {
+                                        e.printStackTrace()
+                                    } finally {
+                                        isLoading = false
+                                    }
+                                }
+                            }
+                        },
+                        enabled = !isLoading && baseUrl.isNotBlank() && accessToken.isNotBlank()
+                    ) {
+                        Text("Pick")
+                    }
+                }
+
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.End
+                ) {
+                    TextButton(onClick = onDismiss) {
+                        Text(stringResource(android.R.string.cancel))
+                    }
+                    TextButton(
+                        onClick = { onSave(friendlyName, entityId) },
+                        enabled = friendlyName.isNotBlank() && entityId.isNotBlank()
+                    ) {
+                        Text(stringResource(android.R.string.ok))
+                    }
+                }
+            }
+        }
+    }
+
+    if (showEntityPicker) {
+        EntityPickerDialog(
+            entities = entities,
+            onDismiss = { showEntityPicker = false },
+            onSelect = { selectedId, selectedName ->
+                entityId = selectedId
+                if (friendlyName.isBlank()) {
+                    friendlyName = selectedName
+                }
+                showEntityPicker = false
+            }
+        )
+    }
+}
+
+/**
+ * Dialog that lists all Home Assistant entities with search/filter,
+ * allowing the user to pick one for an entity mapping.
+ */
+@Composable
+fun EntityPickerDialog(
+    entities: List<Pair<String, String>>,
+    onDismiss: () -> Unit,
+    onSelect: (String, String) -> Unit
+) {
+    var searchQuery by remember { mutableStateOf("") }
+    val filteredEntities = remember(entities, searchQuery) {
+        if (searchQuery.isBlank()) {
+            entities
+        } else {
+            entities.filter { (id, name) ->
+                id.contains(searchQuery, ignoreCase = true) ||
+                name.contains(searchQuery, ignoreCase = true)
+            }
+        }
+    }
+
+    Dialog(onDismissRequest = onDismiss) {
+        Card(
+            modifier = Modifier.fillMaxWidth(),
+            shape = MaterialTheme.shapes.extraLarge
+        ) {
+            Column(modifier = Modifier.padding(16.dp)) {
+                Text(
+                    text = "Select Entity",
+                    style = MaterialTheme.typography.titleLarge,
+                    modifier = Modifier.fillMaxWidth().padding(bottom = 8.dp)
+                )
+
+                TextField(
+                    value = searchQuery,
+                    onValueChange = { searchQuery = it },
+                    label = { Text("Search") },
+                    modifier = Modifier.fillMaxWidth().padding(bottom = 8.dp),
+                    singleLine = true
+                )
+
+                LazyColumn(
+                    modifier = Modifier.fillMaxWidth().weight(1f, false)
+                ) {
+                    items(filteredEntities) { (id, name) ->
+                        Card(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .padding(vertical = 4.dp)
+                                .clickable { onSelect(id, name) }
+                        ) {
+                            Column(modifier = Modifier.padding(12.dp)) {
+                                Text(text = name, style = MaterialTheme.typography.bodyLarge)
+                                Text(
+                                    text = id,
+                                    style = MaterialTheme.typography.bodySmall,
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                                )
+                            }
+                        }
+                    }
+                }
+
+                TextButton(
+                    onClick = onDismiss,
+                    modifier = Modifier.align(Alignment.End).padding(top = 8.dp)
+                ) {
+                    Text(stringResource(android.R.string.cancel))
+                }
+            }
+        }
+    }
+}