Android Auto: implement filter profiles

fixes #72

app/src/main/java/net/vonforst/evmap/viewmodel/Common.kt

@@ -0,0 +1,81 @@
+package net.vonforst.evmap.viewmodel
+
+import android.content.Context
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MediatorLiveData
+import kotlinx.coroutines.CoroutineScope
+import net.vonforst.evmap.api.ChargepointApi
+import net.vonforst.evmap.api.StringProvider
+import net.vonforst.evmap.api.goingelectric.GoingElectricApiWrapper
+import net.vonforst.evmap.api.openchargemap.OpenChargeMapApiWrapper
+import net.vonforst.evmap.model.*
+import net.vonforst.evmap.storage.*
+import kotlin.reflect.full.cast
+
+fun ChargepointApi<ReferenceData>.getReferenceData(
+    scope: CoroutineScope,
+    ctx: Context
+): LiveData<out ReferenceData> {
+    val db = AppDatabase.getInstance(ctx)
+    val prefs = PreferenceDataSource(ctx)
+    return when (this) {
+        is GoingElectricApiWrapper -> {
+            GEReferenceDataRepository(
+                this,
+                scope,
+                db.geReferenceDataDao(),
+                prefs
+            ).getReferenceData()
+        }
+        is OpenChargeMapApiWrapper -> {
+            OCMReferenceDataRepository(
+                this,
+                scope,
+                db.ocmReferenceDataDao(),
+                prefs
+            ).getReferenceData()
+        }
+        else -> {
+            throw RuntimeException("no reference data implemented")
+        }
+    }
+}
+
+fun filtersWithValue(
+    filters: LiveData<List<Filter<FilterValue>>>,
+    filterValues: LiveData<List<FilterValue>>
+): MediatorLiveData<FilterValues> =
+    MediatorLiveData<FilterValues>().apply {
+        listOf(filters, filterValues).forEach {
+            addSource(it) {
+                val f = filters.value ?: return@addSource
+                val values = filterValues.value ?: return@addSource
+                value = f.map { filter ->
+                    val value =
+                        values.find { it.key == filter.key } ?: filter.defaultValue()
+                    FilterWithValue(filter, filter.valueClass.cast(value))
+                }
+            }
+        }
+    }
+
+fun ChargepointApi<ReferenceData>.getFilters(
+    referenceData: LiveData<out ReferenceData>,
+    stringProvider: StringProvider
+) = MediatorLiveData<List<Filter<FilterValue>>>().apply {
+    addSource(referenceData) { data ->
+        value = getFilters(data, stringProvider)
+    }
+}
+
+fun FilterValueDao.getFilterValues(filterStatus: LiveData<Long>, dataSource: String) =
+    MediatorLiveData<List<FilterValue>>().apply {
+        var source: LiveData<List<FilterValue>>? = null
+        addSource(filterStatus) { status ->
+            source?.let { removeSource(it) }
+            source = getFilterValues(status, dataSource)
+            addSource(source!!) { result ->
+                value = result
+            }
+        }
+    }

app/src/main/java/net/vonforst/evmap/viewmodel/FilterViewModel.kt

@@ -5,60 +5,19 @@ import androidx.lifecycle.*
 import kotlinx.coroutines.launch
 import net.vonforst.evmap.api.ChargepointApi
 import net.vonforst.evmap.api.createApi
-import net.vonforst.evmap.api.goingelectric.GoingElectricApiWrapper
-import net.vonforst.evmap.api.openchargemap.OpenChargeMapApiWrapper
 import net.vonforst.evmap.api.stringProvider
 import net.vonforst.evmap.model.*
-import net.vonforst.evmap.storage.*
-import kotlin.reflect.full.cast
+import net.vonforst.evmap.storage.AppDatabase
+import net.vonforst.evmap.storage.FilterProfile
+import net.vonforst.evmap.storage.PreferenceDataSource
 
-internal fun filtersWithValue(
-    filters: LiveData<List<Filter<FilterValue>>>,
-    filterValues: LiveData<List<FilterValue>>
-): MediatorLiveData<FilterValues> =
-    MediatorLiveData<FilterValues>().apply {
-        listOf(filters, filterValues).forEach {
-            addSource(it) {
-                val f = filters.value ?: return@addSource
-                val values = filterValues.value ?: return@addSource
-                value = f.map { filter ->
-                    val value =
-                        values.find { it.key == filter.key } ?: filter.defaultValue()
-                    FilterWithValue(filter, filter.valueClass.cast(value))
-                }
-            }
-        }
-    }
 
 class FilterViewModel(application: Application) : AndroidViewModel(application) {
     private var db = AppDatabase.getInstance(application)
     private var prefs = PreferenceDataSource(application)
     private var api: ChargepointApi<ReferenceData> = createApi(prefs.dataSource, application)
 
-    private val referenceData: LiveData<out ReferenceData> by lazy {
-        val api = api
-        when (api) {
-            is GoingElectricApiWrapper -> {
-                GEReferenceDataRepository(
-                    api,
-                    viewModelScope,
-                    db.geReferenceDataDao(),
-                    prefs
-                ).getReferenceData()
-            }
-            is OpenChargeMapApiWrapper -> {
-                OCMReferenceDataRepository(
-                    api,
-                    viewModelScope,
-                    db.ocmReferenceDataDao(),
-                    prefs
-                ).getReferenceData()
-            }
-            else -> {
-                throw RuntimeException("no reference data implemented")
-            }
-        }
-    }
+    private val referenceData = api.getReferenceData(viewModelScope, application)
     private val filters = MediatorLiveData<List<Filter<FilterValue>>>().apply {
         addSource(referenceData) { data ->
             value = api.getFilters(data, application.stringProvider())

app/src/main/java/net/vonforst/evmap/viewmodel/MapViewModel.kt

@@ -19,7 +19,9 @@ import net.vonforst.evmap.api.openchargemap.OCMReferenceData
 import net.vonforst.evmap.api.openchargemap.OpenChargeMapApiWrapper
 import net.vonforst.evmap.api.stringProvider
 import net.vonforst.evmap.model.*
-import net.vonforst.evmap.storage.*
+import net.vonforst.evmap.storage.AppDatabase
+import net.vonforst.evmap.storage.FilterProfile
+import net.vonforst.evmap.storage.PreferenceDataSource
 import net.vonforst.evmap.utils.distanceBetween
 import java.io.IOException
 
@@ -54,48 +56,19 @@ class MapViewModel(application: Application) : AndroidViewModel(application) {
     val mapPosition: MutableLiveData<MapPosition> by lazy {
         MutableLiveData<MapPosition>()
     }
-    private val filterValues: LiveData<List<FilterValue>> by lazy {
-        MediatorLiveData<List<FilterValue>>().apply {
-            var source: LiveData<List<FilterValue>>? = null
-            addSource(filterStatus) { status ->
-                source?.let { removeSource(it) }
-                source = db.filterValueDao().getFilterValues(status, prefs.dataSource)
-                addSource(source!!) { result ->
-                    value = result
-                }
+    val filterStatus: MutableLiveData<Long> by lazy {
+        MutableLiveData<Long>().apply {
+            value = prefs.filterStatus
+            observeForever {
+                prefs.filterStatus = it
+                if (it != FILTERS_DISABLED) prefs.lastFilterProfile = it
             }
         }
     }
-    private val referenceData: LiveData<out ReferenceData> by lazy {
-        val api = api
-        when (api) {
-            is GoingElectricApiWrapper -> {
-                GEReferenceDataRepository(
-                    api,
-                    viewModelScope,
-                    db.geReferenceDataDao(),
-                    prefs
-                ).getReferenceData()
-            }
-            is OpenChargeMapApiWrapper -> {
-                OCMReferenceDataRepository(
-                    api,
-                    viewModelScope,
-                    db.ocmReferenceDataDao(),
-                    prefs
-                ).getReferenceData()
-            }
-            else -> {
-                throw RuntimeException("no reference data implemented")
-            }
-        }
-    }
-    private val filters = MediatorLiveData<List<Filter<FilterValue>>>().apply {
-        addSource(referenceData) { data ->
-            val api = api
-            value = api.getFilters(data, application.stringProvider())
-        }
-    }
+    private val filterValues: LiveData<List<FilterValue>> =
+        db.filterValueDao().getFilterValues(filterStatus, prefs.dataSource)
+    private val referenceData = api.getReferenceData(viewModelScope, application)
+    private val filters = api.getFilters(referenceData, application.stringProvider())
 
     private val filtersWithValue: LiveData<FilterValues> by lazy {
         filtersWithValue(filters, filterValues)
@@ -271,16 +244,6 @@ class MapViewModel(application: Application) : AndroidViewModel(application) {
         }
     }
 
-    val filterStatus: MutableLiveData<Long> by lazy {
-        MutableLiveData<Long>().apply {
-            value = prefs.filterStatus
-            observeForever {
-                prefs.filterStatus = it
-                if (it != FILTERS_DISABLED) prefs.lastFilterProfile = it
-            }
-        }
-    }
-
     fun reloadPrefs() {
         filterStatus.value = prefs.filterStatus
     }