Feature/add favorite automotive

app/src/main/kotlin/io/homeassistant/companion/android/util/vehicle/TemplateComponents.kt

@@ -28,6 +28,7 @@ import io.homeassistant.companion.android.util.RegistriesDataHandler
 import io.homeassistant.companion.android.vehicle.ChangeServerScreen
 import io.homeassistant.companion.android.vehicle.DomainListScreen
 import io.homeassistant.companion.android.vehicle.EntityGridVehicleScreen
+import io.homeassistant.companion.android.vehicle.ManageFavoritesVehicleScreen
 import io.homeassistant.companion.android.vehicle.MapVehicleScreen
 import java.time.LocalDateTime
 import java.util.Locale
@@ -88,7 +89,6 @@ fun getChangeServerGridItem(
     }
 }
 
-@RequiresApi(Build.VERSION_CODES.O)
 fun getNavigationGridItem(
     carContext: CarContext,
     screenManager: ScreenManager,
@@ -131,7 +131,6 @@ fun getNavigationGridItem(
     }
 }
 
-@RequiresApi(Build.VERSION_CODES.O)
 fun getDomainList(
     domains: MutableSet<String>,
     carContext: CarContext,
@@ -217,7 +216,6 @@ fun getDomainList(
     return listBuilder
 }
 
-@RequiresApi(Build.VERSION_CODES.O)
 fun getDomainsGridItem(
     carContext: CarContext,
     screenManager: ScreenManager,
@@ -256,3 +254,31 @@ fun getDomainsGridItem(
         }
     }
 }
+
+/**
+ * Creates a header [Action] that opens the [ManageFavoritesVehicleScreen], allowing the user
+ * to add or remove entities from the automotive favorites list. Intended for use in the header
+ * of automotive screens when the vehicle is parked.
+ */
+fun getManageFavoritesAction(
+    carContext: CarContext,
+    screenManager: ScreenManager,
+    serverId: StateFlow<Int>,
+    allEntities: Flow<Map<String, Entity>>,
+    prefsRepository: PrefsRepository,
+): Action {
+    return Action.Builder()
+        .setTitle(carContext.getString(R.string.aa_manage_favorites))
+        .setOnClickListener {
+            Timber.i("Manage favorites clicked")
+            screenManager.push(
+                ManageFavoritesVehicleScreen(
+                    carContext,
+                    serverId,
+                    allEntities,
+                    prefsRepository,
+                ),
+            )
+        }
+        .build()
+}

app/src/main/kotlin/io/homeassistant/companion/android/vehicle/BaseVehicleScreen.kt

@@ -7,21 +7,15 @@ import androidx.car.app.Screen
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.LifecycleOwner
 import io.homeassistant.companion.android.common.util.isAutomotive
-import timber.log.Timber
 
 abstract class BaseVehicleScreen(carContext: CarContext) : Screen(carContext) {
     private var car: Car? = null
     private var carRestrictionManager: CarUxRestrictionsManager? = null
     protected val isDrivingOptimized
-        get() = try {
-            (car?.getCarManager(Car.CAR_UX_RESTRICTION_SERVICE) as? CarUxRestrictionsManager)
-                ?.currentCarUxRestrictions
-                ?.isRequiresDistractionOptimization
-                ?: false
-        } catch (e: Exception) {
-            Timber.e(e, "Error getting UX Restrictions")
-            false
-        }
+        get() = carRestrictionManager
+            ?.currentCarUxRestrictions
+            ?.isRequiresDistractionOptimization
+            ?: false
 
     init {
         lifecycle.addObserver(object : DefaultLifecycleObserver {
@@ -42,7 +36,6 @@ abstract class BaseVehicleScreen(carContext: CarContext) : Screen(carContext) {
 
     private fun registerAutomotiveRestrictionListener() {
         if (carContext.isAutomotive()) {
-            Timber.i("Register for Automotive Restrictions")
             car = Car.createCar(carContext)
             carRestrictionManager =
                 car?.getCarManager(Car.CAR_UX_RESTRICTION_SERVICE) as? CarUxRestrictionsManager
@@ -51,6 +44,7 @@ abstract class BaseVehicleScreen(carContext: CarContext) : Screen(carContext) {
                     onDrivingOptimizedChanged(restrictions.isRequiresDistractionOptimization)
                 }
             carRestrictionManager?.registerListener(listener)
+            invalidate()
         }
     }
 }

app/src/main/kotlin/io/homeassistant/companion/android/vehicle/DomainListScreen.kt

@@ -16,6 +16,7 @@ import io.homeassistant.companion.android.common.util.isAutomotive
 import io.homeassistant.companion.android.util.vehicle.SUPPORTED_DOMAINS
 import io.homeassistant.companion.android.util.vehicle.getDomainList
 import io.homeassistant.companion.android.util.vehicle.getHeaderBuilder
+import io.homeassistant.companion.android.util.vehicle.getManageFavoritesAction
 import io.homeassistant.companion.android.util.vehicle.nativeModeAction
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.StateFlow
@@ -71,8 +72,20 @@ class DomainListScreen(
 
         return GridTemplate.Builder().apply {
             val headerBuilder = carContext.getHeaderBuilder(R.string.all_entities)
-            if (isAutomotive && !isDrivingOptimized && BuildConfig.FLAVOR != "full") {
-                headerBuilder.addEndHeaderAction(nativeModeAction(carContext))
+            if (isAutomotive && !isDrivingOptimized) {
+                if (BuildConfig.FLAVOR != "full") {
+                    headerBuilder.addEndHeaderAction(nativeModeAction(carContext))
+                } else {
+                    headerBuilder.addEndHeaderAction(
+                        getManageFavoritesAction(
+                            carContext,
+                            screenManager,
+                            serverId,
+                            allEntities,
+                            prefsRepository,
+                        ),
+                    )
+                }
             }
             setHeader(headerBuilder.build())
             val domainBuild = domainList.build()

app/src/main/kotlin/io/homeassistant/companion/android/vehicle/MainVehicleScreen.kt

@@ -30,6 +30,7 @@ import io.homeassistant.companion.android.util.vehicle.SUPPORTED_DOMAINS
 import io.homeassistant.companion.android.util.vehicle.getChangeServerGridItem
 import io.homeassistant.companion.android.util.vehicle.getDomainList
 import io.homeassistant.companion.android.util.vehicle.getHeaderBuilder
+import io.homeassistant.companion.android.util.vehicle.getManageFavoritesAction
 import io.homeassistant.companion.android.util.vehicle.getNavigationGridItem
 import io.homeassistant.companion.android.util.vehicle.nativeModeAction
 import kotlinx.coroutines.CancellationException
@@ -217,8 +218,20 @@ class MainVehicleScreen(
             }.build()
 
         val headerBuilder = carContext.getHeaderBuilder(commonR.string.app_name, Action.APP_ICON)
-        if (isAutomotive && !isDrivingOptimized && BuildConfig.FLAVOR != "full") {
-            headerBuilder.addEndHeaderAction(nativeModeAction(carContext))
+        if (isAutomotive && !isDrivingOptimized) {
+            if (BuildConfig.FLAVOR != "full") {
+                headerBuilder.addEndHeaderAction(nativeModeAction(carContext))
+            } else {
+                headerBuilder.addEndHeaderAction(
+                    getManageFavoritesAction(
+                        carContext,
+                        screenManager,
+                        serverId,
+                        allEntities,
+                        prefsRepository,
+                    ),
+                )
+            }
         }
         headerBuilder.addEndHeaderAction(refreshAction)
 

app/src/main/kotlin/io/homeassistant/companion/android/vehicle/ManageFavoritesVehicleScreen.kt

@@ -0,0 +1,181 @@
+package io.homeassistant.companion.android.vehicle
+
+import android.os.Build
+import androidx.annotation.RequiresApi
+import androidx.car.app.CarContext
+import androidx.car.app.constraints.ConstraintManager
+import androidx.car.app.model.ItemList
+import androidx.car.app.model.ListTemplate
+import androidx.car.app.model.Row
+import androidx.car.app.model.Template
+import androidx.car.app.model.Toggle
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import io.homeassistant.companion.android.common.R as commonR
+import io.homeassistant.companion.android.common.data.integration.Entity
+import io.homeassistant.companion.android.common.data.prefs.AutoFavorite
+import io.homeassistant.companion.android.common.data.prefs.PrefsRepository
+import io.homeassistant.companion.android.util.vehicle.SUPPORTED_DOMAINS_WITH_STRING
+import io.homeassistant.companion.android.util.vehicle.getHeaderBuilder
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+
+/**
+ * A Car App screen that allows users to manage their automotive favorites when the vehicle is
+ * parked. Each entity from the supported domains is displayed with a toggle to add or remove
+ * it from the favorites list. Current favorites are sorted to the top.
+ *
+ * This screen stays fully within the Car App API, making it compliant with Play Store
+ * automotive distribution policies.
+ */
+class ManageFavoritesVehicleScreen(
+    carContext: CarContext,
+    private val serverId: StateFlow<Int>,
+    private val allEntities: Flow<Map<String, Entity>>,
+    private val prefsRepository: PrefsRepository,
+) : BaseVehicleScreen(carContext) {
+
+    private var entities: List<Entity> = emptyList()
+    private var favoritesList: List<AutoFavorite> = emptyList()
+    private var isLoaded = false
+    private var page = 0
+
+    init {
+        lifecycleScope.launch {
+            lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                favoritesList = prefsRepository.getAutoFavorites()
+                allEntities.collect { entityMap ->
+                    val currentServerId = serverId.value
+                    val favoriteEntityIds = favoritesList
+                        .asSequence()
+                        .filter { it.serverId == currentServerId }
+                        .map { it.entityId }
+                        .toSet()
+
+                    val newEntities = entityMap.values
+                        .filter { it.domain in SUPPORTED_DOMAINS_WITH_STRING }
+                        .sortedWith(
+                            compareByDescending<Entity> { entity ->
+                                favoriteEntityIds.contains(entity.entityId)
+                            }.thenBy { it.attributes["friendly_name"]?.toString() ?: it.entityId },
+                        )
+                    if (newEntities.map { it.entityId } != entities.map { it.entityId }) {
+                        page = 0
+                    }
+                    entities = newEntities
+                    isLoaded = true
+                    invalidate()
+                }
+            }
+        }
+    }
+
+    override fun onDrivingOptimizedChanged(newState: Boolean) {
+        if (newState) {
+            lifecycleScope.launch {
+                screenManager.pop()
+            }
+        }
+        invalidate()
+    }
+
+    override fun onGetTemplate(): Template {
+        val listLimit = carContext.getCarService(ConstraintManager::class.java)
+            .getContentLimit(ConstraintManager.CONTENT_LIMIT_TYPE_LIST)
+
+        val hasPreviousPage = page > 0
+        val reservedRowsWithoutNextPage = if (hasPreviousPage) 1 else 0
+        val maxItemsWithoutNextPage = (listLimit - reservedRowsWithoutNextPage).coerceAtLeast(1)
+        val fromIndex = page * maxItemsWithoutNextPage
+        val hasNextPage = fromIndex + maxItemsWithoutNextPage < entities.size
+        val reservedRows = reservedRowsWithoutNextPage + if (hasNextPage) 1 else 0
+        val itemsPerPage = (listLimit - reservedRows).coerceAtLeast(1)
+        val toIndex = minOf(fromIndex + itemsPerPage, entities.size)
+        val pageEntities = if (isLoaded) entities.subList(fromIndex, toIndex) else emptyList()
+
+        val listBuilder = ItemList.Builder()
+
+        if (hasPreviousPage) {
+            listBuilder.addItem(
+                Row.Builder()
+                    .setTitle(carContext.getString(commonR.string.aa_previous_page))
+                    .setOnClickListener {
+                        page--
+                        invalidate()
+                    }
+                    .build(),
+            )
+        }
+
+        pageEntities.forEach { entity ->
+            val isFavorite = favoritesList.any {
+                it.serverId == serverId.value && it.entityId == entity.entityId
+            }
+            val friendlyName = entity.attributes["friendly_name"]?.toString() ?: entity.entityId
+            val domainLabel = SUPPORTED_DOMAINS_WITH_STRING[entity.domain]
+                ?.let { carContext.getString(it) }
+                ?: entity.domain
+
+            listBuilder.addItem(
+                Row.Builder()
+                    .setTitle(friendlyName)
+                    .addText(domainLabel)
+                    .setEnabled(!isDrivingOptimized)
+                    .setToggle(
+                        Toggle.Builder { isChecked ->
+                            lifecycleScope.launch {
+                                val favorite = AutoFavorite(
+                                    serverId = serverId.value,
+                                    entityId = entity.entityId,
+                                )
+                                if (isChecked) {
+                                    prefsRepository.addAutoFavorite(favorite)
+                                } else {
+                                    val updated = favoritesList.filterNot { it == favorite }
+                                    prefsRepository.setAutoFavorites(updated)
+                                }
+                                favoritesList = prefsRepository.getAutoFavorites()
+                                val favoriteEntityIds = favoritesList
+                                    .filter { it.serverId == serverId.value }
+                                    .map { it.entityId }
+                                    .toSet()
+                                entities = entities.sortedByDescending { updatedEntity ->
+                                    updatedEntity.entityId in favoriteEntityIds
+                                }
+                                val maxPage = if (entities.isEmpty()) 0 else (entities.size - 1) / listLimit
+                                page = page.coerceIn(minimumValue = 0, maximumValue = maxPage)
+                                invalidate()
+                            }
+                        }
+                            .setChecked(isFavorite)
+                            .build(),
+                    )
+                    .build(),
+            )
+        }
+
+        if (hasNextPage) {
+            listBuilder.addItem(
+                Row.Builder()
+                    .setTitle(carContext.getString(commonR.string.aa_next_page))
+                    .setOnClickListener {
+                        page++
+                        invalidate()
+                    }
+                    .build(),
+            )
+        }
+
+        if (isLoaded && entities.isEmpty()) {
+            listBuilder.setNoItemsMessage(carContext.getString(commonR.string.no_supported_entities))
+        }
+
+        return ListTemplate.Builder()
+            .setHeader(carContext.getHeaderBuilder(commonR.string.android_automotive_favorites).build())
+            .setLoading(!isLoaded)
+            .apply { if (isLoaded) setSingleList(listBuilder.build()) }
+            .build()
+    }
+}

common/src/main/res/values/strings.xml

@@ -1235,6 +1235,9 @@
     <string name="aa_favorites_summary">Select your favorite entities to be shown in the app while viewing the Home Assistant driving interface</string>
     <string name="android_automotive">Android Automotive</string>
     <string name="android_automotive_favorites">Driving favorites</string>
+    <string name="aa_manage_favorites">Manage favorites</string>
+    <string name="aa_previous_page">← Previous page</string>
+    <string name="aa_next_page">Next page →</string>
     <string name="alarm_control_panels">Alarm Control Panels</string>
     <string name="state_triggered">Triggered</string>
     <string name="state_disarmed">Disarmed</string>