Release 0.6.0

Android Auto support

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Johan von Forstner
+Copyright (c) 2020-2021 Johan von Forstner
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -20,6 +20,7 @@ Features
 - Favorites list, also with availability information
 - No ads, fully open source
 - Compatible with Android 5.0 and above
+- Can use Google Maps or Mapbox (OpenStreetMap) as map backends - the version available on F-Droid only uses Mapbox.
 
 Screenshots
 -----------
@@ -31,10 +32,10 @@ Development setup
 
 The App is developed using Android Studio.
 
-For testing the app, you need to obtain API Keys for the 
+For testing the app, you need to obtain free API Keys for the 
 [GoingElectric API](https://www.goingelectric.de/stromtankstellen/api/)
 as well as for [Google APIs](https://console.developers.google.com/)
-("Maps SDK for Android" and "Places API" need to be activated). These APIs need to be put into the
+("Maps SDK for Android" and "Places API" need to be activated) and/or [Mapbox](https://www.mapbox.com/). These APIs need to be put into the
 app in the form of a resource file called `apikeys.xml` under `app/src/main/res/values`, with the
 following content:
 
@@ -43,6 +44,9 @@ following content:
     <string name="google_maps_key" templateMergeStrategy="preserve" translatable="false">
         insert your Google Maps key here
     </string>
+    <string name="mapbox_key" translatable="false">
+        insert your Mapbox key here
+    </string>
     <string name="goingelectric_key" translatable="false">
         insert your GoingElectric key here
     </string>

app/build.gradle

@@ -13,8 +13,8 @@ android {
         applicationId "net.vonforst.evmap"
         minSdkVersion 21
         targetSdkVersion 30
-        versionCode 34
-        versionName "0.4.2"
+        versionCode 42
+        versionName "0.6.0"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -119,8 +119,11 @@ dependencies {
     implementation 'com.google.guava:guava:29.0-android'
     implementation 'com.github.pengrad:mapscaleview:1.6.0'
 
+    // Android Auto
+    googleImplementation 'androidx.car.app:app:1.0.0-rc01'
+
     // AnyMaps
-    def anyMapsVersion = '7753eeb7b0'
+    def anyMapsVersion = '1f050d860f'
     implementation "com.github.johan12345.AnyMaps:anymaps-base:$anyMapsVersion"
     googleImplementation "com.github.johan12345.AnyMaps:anymaps-google:$anyMapsVersion"
     implementation "com.github.johan12345.AnyMaps:anymaps-mapbox:$anyMapsVersion"

app/src/google/AndroidManifest.xml

@@ -1,10 +1,43 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
     package="net.vonforst.evmap">
 
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="androidx.car.app.MAP_TEMPLATES" />
+
+    <uses-sdk tools:overrideLibrary="androidx.car.app" />
+
     <application>
-    <meta-data
-        android:name="com.google.android.geo.API_KEY"
-        android:value="@string/google_maps_key" />
+        <meta-data
+            android:name="com.google.android.geo.API_KEY"
+            android:value="@string/google_maps_key" />
+
+        <meta-data
+            android:name="com.google.android.gms.car.application"
+            android:resource="@xml/automotive_app_desc" />
+
+        <meta-data
+            android:name="androidx.car.app.theme"
+            android:resource="@style/CarAppTheme" />
+
+        <service
+            android:name=".auto.CarAppService"
+            android:label="@string/app_name"
+            android:icon="@mipmap/ic_launcher"
+            android:exported="true">
+            <intent-filter>
+                <action
+                    android:name="androidx.car.app.CarAppService"
+                    android:category="androidx.car.app.category.CHARGING" />
+            </intent-filter>
+        </service>
+
+        <service
+            android:name=".auto.CarLocationService"
+            android:foregroundServiceType="location"
+            android:enabled="true" />
+
+        <activity android:name=".auto.PermissionActivity" />
     </application>
 </manifest>

app/src/google/java/net/vonforst/evmap/auto/CarAppService.kt

@@ -0,0 +1,632 @@
+package net.vonforst.evmap.auto
+
+import android.Manifest
+import android.content.*
+import android.content.pm.ApplicationInfo
+import android.content.pm.PackageManager
+import android.graphics.Bitmap
+import android.graphics.drawable.BitmapDrawable
+import android.location.Location
+import android.net.Uri
+import android.os.Bundle
+import android.os.IBinder
+import android.os.ResultReceiver
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import androidx.car.app.CarContext
+import androidx.car.app.CarToast
+import androidx.car.app.Screen
+import androidx.car.app.Session
+import androidx.car.app.model.*
+import androidx.car.app.model.Distance.UNIT_KILOMETERS
+import androidx.car.app.validation.HostValidator
+import androidx.core.content.ContextCompat
+import androidx.core.graphics.drawable.IconCompat
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleObserver
+import androidx.lifecycle.OnLifecycleEvent
+import androidx.lifecycle.lifecycleScope
+import androidx.localbroadcastmanager.content.LocalBroadcastManager
+import coil.imageLoader
+import coil.request.ImageRequest
+import kotlinx.coroutines.*
+import net.vonforst.evmap.*
+import net.vonforst.evmap.api.availability.ChargeLocationStatus
+import net.vonforst.evmap.api.availability.ChargepointStatus
+import net.vonforst.evmap.api.availability.getAvailability
+import net.vonforst.evmap.api.goingelectric.ChargeLocation
+import net.vonforst.evmap.api.goingelectric.GoingElectricApi
+import net.vonforst.evmap.api.nameForPlugType
+import net.vonforst.evmap.storage.AppDatabase
+import net.vonforst.evmap.ui.ChargerIconGenerator
+import net.vonforst.evmap.ui.availabilityText
+import net.vonforst.evmap.ui.getMarkerTint
+import net.vonforst.evmap.utils.distanceBetween
+import java.time.Duration
+import java.time.ZoneId
+import java.time.ZonedDateTime
+import java.time.format.DateTimeFormatter
+import java.time.format.FormatStyle
+import kotlin.math.roundToInt
+
+
+interface LocationAwareScreen {
+    fun updateLocation(location: Location)
+}
+
+class CarAppService : androidx.car.app.CarAppService() {
+    override fun createHostValidator(): HostValidator {
+        return if (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE != 0) {
+            HostValidator.ALLOW_ALL_HOSTS_VALIDATOR
+        } else {
+            HostValidator.Builder(applicationContext)
+                .addAllowedHosts(androidx.car.app.R.array.hosts_allowlist_sample)
+                .build()
+        }
+    }
+
+    override fun onCreateSession(): Session {
+        return EVMapSession(this)
+    }
+}
+
+class EVMapSession(val cas: CarAppService) : Session(), LifecycleObserver {
+    var mapScreen: LocationAwareScreen? = null
+        set(value) {
+            field = value
+            location?.let { value?.updateLocation(it) }
+        }
+    private var location: Location? = null
+    private var locationService: CarLocationService? = null
+
+    private val serviceConnection = object : ServiceConnection {
+        override fun onServiceConnected(name: ComponentName, ibinder: IBinder) {
+            val binder: CarLocationService.LocalBinder = ibinder as CarLocationService.LocalBinder
+            locationService = binder.service
+            // TODO: check for location permission
+            locationService?.requestLocationUpdates()
+        }
+
+        override fun onServiceDisconnected(name: ComponentName?) {
+            locationService = null
+        }
+    }
+
+    init {
+        lifecycle.addObserver(this)
+    }
+
+    override fun onCreateScreen(intent: Intent): Screen {
+        return if (locationPermissionGranted()) {
+            WelcomeScreen(carContext, this)
+        } else {
+            PermissionScreen(carContext, this)
+        }
+    }
+
+    private fun locationPermissionGranted() =
+        ContextCompat.checkSelfPermission(
+            carContext,
+            Manifest.permission.ACCESS_FINE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+
+    private val locationReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            val location = intent.getParcelableExtra(CarLocationService.EXTRA_LOCATION) as Location?
+            val mapScreen = this@EVMapSession.mapScreen
+            if (location != null && mapScreen != null) {
+                mapScreen.updateLocation(location)
+            }
+            this@EVMapSession.location = location
+        }
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_START)
+    fun bindLocationService() {
+        if (!locationPermissionGranted()) return
+        cas.bindService(
+            Intent(cas, CarLocationService::class.java),
+            serviceConnection,
+            Context.BIND_AUTO_CREATE
+        )
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
+    private fun unbindLocationService() {
+        locationService?.removeLocationUpdates()
+        cas.unbindService(serviceConnection)
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
+    private fun registerBroadcastReceiver() {
+        LocalBroadcastManager.getInstance(cas).registerReceiver(
+            locationReceiver,
+            IntentFilter(CarLocationService.ACTION_BROADCAST)
+        );
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
+    private fun unregisterBroadcastReceiver() {
+        LocalBroadcastManager.getInstance(cas).unregisterReceiver(locationReceiver)
+    }
+}
+
+/**
+ * Welcome screen with selection between favorites and nearby chargers
+ */
+class WelcomeScreen(ctx: CarContext, val session: EVMapSession) : Screen(ctx), LocationAwareScreen {
+    private var location: Location? = null
+
+    override fun onGetTemplate(): Template {
+        session.mapScreen = this
+        return PlaceListMapTemplate.Builder().apply {
+            setTitle(carContext.getString(R.string.app_name))
+            location?.let {
+                setAnchor(Place.Builder(CarLocation.create(it)).build())
+            }
+            setItemList(ItemList.Builder().apply {
+                addItem(Row.Builder()
+                    .setTitle(carContext.getString(R.string.auto_chargers_closeby))
+                    .setImage(
+                        CarIcon.Builder(
+                            IconCompat.createWithResource(
+                                carContext,
+                                R.drawable.ic_address
+                            )
+                        )
+                            .setTint(CarColor.DEFAULT).build()
+                    )
+                    .setBrowsable(true)
+                    .setOnClickListener {
+                        screenManager.push(MapScreen(carContext, session, favorites = false))
+                    }
+                    .build())
+                addItem(
+                    Row.Builder()
+                        .setTitle(carContext.getString(R.string.auto_favorites))
+                        .setImage(
+                            CarIcon.Builder(
+                                IconCompat.createWithResource(
+                                    carContext,
+                                    R.drawable.ic_fav
+                                )
+                            )
+                                .setTint(CarColor.DEFAULT).build()
+                        )
+                        .setBrowsable(true)
+                        .setOnClickListener {
+                            screenManager.push(MapScreen(carContext, session, favorites = true))
+                        }
+                        .build())
+            }.build())
+            setCurrentLocationEnabled(true)
+            setHeaderAction(Action.APP_ICON)
+            build()
+        }.build()
+    }
+
+    override fun updateLocation(location: Location) {
+        this.location = location
+        invalidate()
+    }
+}
+
+/**
+ * Screen to grant location permission
+ */
+class PermissionScreen(ctx: CarContext, val session: EVMapSession) : Screen(ctx) {
+    override fun onGetTemplate(): Template {
+        return MessageTemplate.Builder(carContext.getString(R.string.auto_location_permission_needed))
+            .setTitle(carContext.getString(R.string.app_name))
+            .setHeaderAction(Action.APP_ICON)
+            .addAction(
+                Action.Builder()
+                    .setTitle(carContext.getString(R.string.grant_on_phone))
+                    .setBackgroundColor(CarColor.PRIMARY)
+                    .setOnClickListener(ParkedOnlyOnClickListener.create {
+                        val intent = Intent(carContext, PermissionActivity::class.java)
+                            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                            .putExtra(
+                                PermissionActivity.EXTRA_RESULT_RECEIVER,
+                                object : ResultReceiver(null) {
+                                    override fun onReceiveResult(
+                                        resultCode: Int,
+                                        resultData: Bundle?
+                                    ) {
+                                        if (resultData!!.getBoolean(PermissionActivity.RESULT_GRANTED)) {
+                                            session.bindLocationService()
+                                            screenManager.push(
+                                                WelcomeScreen(
+                                                    carContext,
+                                                    session
+                                                )
+                                            )
+                                        }
+                                    }
+                                })
+                        carContext.startActivity(intent)
+                        CarToast.makeText(
+                            carContext,
+                            R.string.opened_on_phone,
+                            CarToast.LENGTH_LONG
+                        ).show()
+                    })
+                    .build()
+            )
+            .addAction(
+                Action.Builder()
+                    .setTitle(carContext.getString(R.string.cancel))
+                    .setOnClickListener {
+                        carContext.finishCarApp()
+                    }
+                    .build(),
+            )
+            .build()
+    }
+}
+
+/**
+ * Main map screen showing either nearby chargers or favorites
+ */
+class MapScreen(ctx: CarContext, val session: EVMapSession, val favorites: Boolean = false) :
+    Screen(ctx), LocationAwareScreen {
+    private var updateCoroutine: Job? = null
+    private var numUpdates = 0
+    private val maxNumUpdates = 3
+
+    private var location: Location? = null
+    private var lastUpdateLocation: Location? = null
+    private var chargers: List<ChargeLocation>? = null
+    private val api by lazy {
+        GoingElectricApi.create(ctx.getString(R.string.goingelectric_key), context = ctx)
+    }
+    private val searchRadius = 5 // kilometers
+    private val updateThreshold = 2000 // meters
+    private val availabilityUpdateThreshold = Duration.ofMinutes(1)
+    private var availabilities: MutableMap<Long, Pair<ZonedDateTime, ChargeLocationStatus>> =
+        HashMap()
+    private val maxRows = 6
+
+    override fun onGetTemplate(): Template {
+        session.mapScreen = this
+        return PlaceListMapTemplate.Builder().apply {
+            setTitle(
+                carContext.getString(
+                    if (favorites) {
+                        R.string.auto_favorites
+                    } else {
+                        R.string.auto_chargers_closeby
+                    }
+                )
+            )
+            location?.let {
+                setAnchor(Place.Builder(CarLocation.create(it)).build())
+            } ?: setLoading(true)
+            chargers?.take(maxRows)?.let { chargerList ->
+                val builder = ItemList.Builder()
+                chargerList.forEach { charger ->
+                    builder.addItem(formatCharger(charger))
+                }
+                builder.setNoItemsMessage(
+                    carContext.getString(
+                        if (favorites) {
+                            R.string.auto_no_favorites_found
+                        } else {
+                            R.string.auto_no_chargers_found
+                        }
+                    )
+                )
+                setItemList(builder.build())
+            } ?: setLoading(true)
+            setCurrentLocationEnabled(true)
+            setHeaderAction(Action.BACK)
+            build()
+        }.build()
+    }
+
+    private fun formatCharger(charger: ChargeLocation): Row {
+        val color = ContextCompat.getColor(carContext, getMarkerTint(charger))
+        val place =
+            Place.Builder(CarLocation.create(charger.coordinates.lat, charger.coordinates.lng))
+                .setMarker(
+                    PlaceMarker.Builder()
+                        .setColor(CarColor.createCustom(color, color))
+                        .build()
+                )
+                .build()
+
+        return Row.Builder().apply {
+            setTitle(charger.name)
+            val text = SpannableStringBuilder()
+
+            // distance
+            location?.let {
+                val distance = distanceBetween(
+                    it.latitude, it.longitude,
+                    charger.coordinates.lat, charger.coordinates.lng
+                ) / 1000
+                text.append(
+                    "distance",
+                    DistanceSpan.create(Distance.create(distance, UNIT_KILOMETERS)),
+                    Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+                )
+            }
+
+            // power
+            if (text.isNotEmpty()) text.append(" · ")
+            text.append("${charger.maxPower.roundToInt()} kW")
+
+            // availability
+            availabilities[charger.id]?.second?.let { av ->
+                val status = av.status.values.flatten()
+                val available = availabilityText(status)
+                val total = charger.chargepoints.sumBy { it.count }
+
+                if (text.isNotEmpty()) text.append(" · ")
+                text.append(
+                    "$available/$total",
+                    ForegroundCarColorSpan.create(carAvailabilityColor(status)),
+                    Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+                )
+            }
+
+            addText(text)
+            setMetadata(
+                Metadata.Builder()
+                    .setPlace(place)
+                    .build()
+            )
+
+            setOnClickListener {
+                screenManager.push(ChargerDetailScreen(carContext, charger))
+            }
+        }.build()
+    }
+
+    override fun updateLocation(location: Location) {
+        this.location = location
+        if (updateCoroutine != null) {
+            // don't update while still loading last update
+            return
+        }
+
+        invalidate()
+
+        if (lastUpdateLocation == null ||
+            location.distanceTo(lastUpdateLocation) > updateThreshold
+        ) {
+            lastUpdateLocation = location
+            // update displayed chargers
+            loadChargers(location)
+        }
+    }
+
+    private val db = AppDatabase.getInstance(carContext)
+
+    private fun loadChargers(location: Location) {
+        numUpdates++
+        println(numUpdates)
+        if (numUpdates > maxNumUpdates) {
+            CarToast.makeText(carContext, R.string.auto_no_refresh_possible, CarToast.LENGTH_LONG)
+                .show()
+            return
+        }
+        updateCoroutine = lifecycleScope.launch {
+            // load chargers
+            if (favorites) {
+                chargers = db.chargeLocationsDao().getAllChargeLocationsAsync().sortedBy {
+                    distanceBetween(
+                        location.latitude, location.longitude,
+                        it.coordinates.lat, it.coordinates.lng
+                    )
+                }
+            } else {
+                val response = api.getChargepointsRadius(
+                    location.latitude,
+                    location.longitude,
+                    searchRadius,
+                    zoom = 16f
+                )
+                chargers =
+                    response.body()?.chargelocations?.filterIsInstance(ChargeLocation::class.java)
+            }
+
+            // remove outdated availabilities
+            availabilities = availabilities.filter {
+                Duration.between(
+                    it.value.first,
+                    ZonedDateTime.now()
+                ) > availabilityUpdateThreshold
+            }.toMutableMap()
+
+            // update availabilities
+            chargers?.take(maxRows)?.map {
+                lifecycleScope.async {
+                    // update only if not yet stored
+                    if (!availabilities.containsKey(it.id)) {
+                        val date = ZonedDateTime.now()
+                        val availability = getAvailability(it).data
+                        if (availability != null) {
+                            availabilities[it.id] = date to availability
+                        }
+                    }
+                }
+            }?.awaitAll()
+
+            updateCoroutine = null
+            invalidate()
+        }
+    }
+}
+
+class ChargerDetailScreen(ctx: CarContext, val chargerSparse: ChargeLocation) : Screen(ctx) {
+    var charger: ChargeLocation? = null
+    var photo: Bitmap? = null
+    private var availability: ChargeLocationStatus? = null
+
+    val apikey = ctx.getString(R.string.goingelectric_key)
+    private val api by lazy {
+        GoingElectricApi.create(apikey, context = ctx)
+    }
+
+    private val iconGen = ChargerIconGenerator(carContext, null, oversize = 1.4f, height = 64)
+
+    override fun onGetTemplate(): Template {
+        if (charger == null) loadCharger()
+
+        return PaneTemplate.Builder(
+            Pane.Builder().apply {
+                charger?.let { charger ->
+                    addRow(Row.Builder().apply {
+                        setTitle(charger.address.toString())
+
+                        val icon = iconGen.getBitmap(
+                            tint = getMarkerTint(charger),
+                            fault = charger.faultReport != null,
+                            multi = charger.isMulti()
+                        )
+                        setImage(
+                            CarIcon.Builder(IconCompat.createWithBitmap(icon)).build(),
+                            Row.IMAGE_TYPE_LARGE
+                        )
+
+                        val chargepointsText = SpannableStringBuilder()
+                        charger.chargepointsMerged.forEachIndexed { i, cp ->
+                            if (i > 0) chargepointsText.append(" · ")
+                            chargepointsText.append(
+                                "${cp.count}× ${
+                                    nameForPlugType(
+                                        carContext,
+                                        cp.type
+                                    )
+                                } ${cp.formatPower()}"
+                            )
+                            availability?.status?.get(cp)?.let { status ->
+                                chargepointsText.append(
+                                    " (${availabilityText(status)}/${cp.count})",
+                                    ForegroundCarColorSpan.create(carAvailabilityColor(status)),
+                                    Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+                                )
+                            }
+                        }
+                        addText(chargepointsText)
+                    }.build())
+                    addRow(Row.Builder().apply {
+                        photo?.let {
+                            setImage(
+                                CarIcon.Builder(IconCompat.createWithBitmap(photo)).build(),
+                                Row.IMAGE_TYPE_LARGE
+                            )
+                        }
+                        val operatorText = StringBuilder().apply {
+                            charger.operator?.let { append(it) }
+                            charger.network?.let {
+                                if (isNotEmpty()) append(" · ")
+                                append(it)
+                            }
+                        }
+                        setTitle(operatorText)
+
+                        charger.cost?.let { addText(it.getStatusText(carContext, emoji = true)) }
+                        charger.faultReport?.created?.let {
+                            addText(
+                                carContext.getString(
+                                    R.string.auto_fault_report_date,
+                                    it.atZone(ZoneId.systemDefault())
+                                        .format(DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT))
+                                )
+                            )
+                        }
+
+                        /*val types = charger.chargepoints.map { it.type }.distinct()
+                        if (types.size == 1) {
+                            setImage(
+                                CarIcon.of(IconCompat.createWithResource(carContext, iconForPlugType(types[0]))),
+                                Row.IMAGE_TYPE_ICON)
+                        }*/
+                    }.build())
+                    addAction(Action.Builder()
+                        .setIcon(
+                            CarIcon.Builder(
+                                IconCompat.createWithResource(
+                                    carContext,
+                                    R.drawable.ic_navigation
+                                )
+                            ).build()
+                        )
+                        .setTitle(carContext.getString(R.string.navigate))
+                        .setBackgroundColor(CarColor.PRIMARY)
+                        .setOnClickListener {
+                            navigateToCharger(charger)
+                        }
+                        .build())
+                    addAction(
+                        Action.Builder()
+                            .setTitle(carContext.getString(R.string.open_in_app))
+                            .setOnClickListener(ParkedOnlyOnClickListener.create {
+                                val intent = Intent(carContext, MapsActivity::class.java)
+                                    .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                                    .putExtra(EXTRA_CHARGER_ID, charger.id)
+                                    .putExtra(EXTRA_LAT, charger.coordinates.lat)
+                                    .putExtra(EXTRA_LON, charger.coordinates.lng)
+                                carContext.startActivity(intent)
+                                CarToast.makeText(
+                                    carContext,
+                                    R.string.opened_on_phone,
+                                    CarToast.LENGTH_LONG
+                                ).show()
+                            })
+                            .build()
+                    )
+                } ?: setLoading(true)
+            }.build()
+        ).apply {
+            setTitle(chargerSparse.name)
+            setHeaderAction(Action.BACK)
+        }.build()
+    }
+
+    private fun navigateToCharger(charger: ChargeLocation) {
+        val coord = charger.coordinates
+        val intent =
+            Intent(
+                CarContext.ACTION_NAVIGATE,
+                Uri.parse("geo:0,0?q=${coord.lat},${coord.lng}(${charger.name})")
+            )
+        carContext.startCarApp(intent)
+    }
+
+    private fun loadCharger() {
+        lifecycleScope.launch {
+            val response = api.getChargepointDetail(chargerSparse.id)
+            charger = response.body()?.chargelocations?.get(0) as ChargeLocation
+
+            val photo = charger?.photos?.get(0)
+            photo?.let {
+                val size = (carContext.resources.displayMetrics.density * 64).roundToInt()
+                val url = "https://api.goingelectric.de/chargepoints/photo/?key=${apikey}" +
+                        "&id=${photo.id}&size=${size}"
+                val request = ImageRequest.Builder(carContext).data(url).build()
+                this@ChargerDetailScreen.photo =
+                    (carContext.imageLoader.execute(request).drawable as BitmapDrawable).bitmap
+            }
+
+            availability = charger?.let { getAvailability(it).data }
+
+            invalidate()
+        }
+    }
+}
+
+fun carAvailabilityColor(status: List<ChargepointStatus>): CarColor {
+    val unknown = status.any { it == ChargepointStatus.UNKNOWN }
+    val available = status.count { it == ChargepointStatus.AVAILABLE }
+
+    return if (unknown) {
+        CarColor.DEFAULT
+    } else if (available > 0) {
+        CarColor.GREEN
+    } else {
+        CarColor.RED
+    }
+}

app/src/google/java/net/vonforst/evmap/auto/CarLocationService.kt

@@ -0,0 +1,163 @@
+package net.vonforst.evmap.auto
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.Service
+import android.content.Intent
+import android.location.Location
+import android.os.*
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.localbroadcastmanager.content.LocalBroadcastManager
+import com.google.android.gms.location.*
+import net.vonforst.evmap.BuildConfig
+import net.vonforst.evmap.R
+
+
+class CarLocationService : Service() {
+    private lateinit var serviceHandler: Handler
+    private lateinit var locationRequest: LocationRequest
+    private lateinit var notificationManager: NotificationManager
+    private lateinit var locationCallback: LocationCallback
+    private lateinit var fusedLocationClient: FusedLocationProviderClient
+    private val binder: IBinder = LocalBinder(this)
+    private var location: Location? = null
+
+    private val UPDATE_INTERVAL_IN_MILLISECONDS = 10000L
+    private val FASTEST_UPDATE_INTERVAL_IN_MILLISECONDS = UPDATE_INTERVAL_IN_MILLISECONDS / 2
+
+    private val CHANNEL_ID = "car_location"
+    private val NOTIFICATION_ID = 1000
+    private val TAG = "CarLocationService"
+
+    companion object {
+        const val ACTION_BROADCAST: String = BuildConfig.APPLICATION_ID + ".car_location_broadcast"
+        const val EXTRA_LOCATION: String = BuildConfig.APPLICATION_ID + ".location"
+    }
+
+    override fun onCreate() {
+        fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)
+        locationCallback = object : LocationCallback() {
+            override fun onLocationResult(locationResult: LocationResult) {
+                super.onLocationResult(locationResult)
+                onNewLocation(locationResult.lastLocation)
+            }
+        }
+        createLocationRequest()
+        getLastLocation()
+        val handlerThread = HandlerThread(TAG)
+        handlerThread.start()
+        serviceHandler = Handler(handlerThread.looper)
+        notificationManager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
+
+        // Android O requires a Notification Channel.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val name: CharSequence = getString(R.string.app_name)
+            // Create the channel for the notification
+            val mChannel =
+                NotificationChannel(CHANNEL_ID, name, NotificationManager.IMPORTANCE_DEFAULT)
+
+            // Set the Notification Channel for the Notification Manager.
+            notificationManager.createNotificationChannel(mChannel)
+        }
+
+        startForeground(NOTIFICATION_ID, getNotification())
+    }
+
+    /**
+     * Returns the [NotificationCompat] used as part of the foreground service.
+     */
+    private fun getNotification(): Notification {
+        val builder: NotificationCompat.Builder = NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentText(getString(R.string.auto_location_service))
+            .setContentTitle(getString(R.string.app_name))
+            .setOngoing(true)
+            .setPriority(NotificationManagerCompat.IMPORTANCE_HIGH)
+            .setSmallIcon(R.mipmap.ic_launcher)
+            .setTicker(getString(R.string.auto_location_service))
+            .setWhen(System.currentTimeMillis())
+
+        return builder.build()
+    }
+
+    override fun onBind(intent: Intent?): IBinder {
+        return binder
+    }
+
+    private fun createLocationRequest() {
+        locationRequest = LocationRequest()
+        locationRequest.interval = UPDATE_INTERVAL_IN_MILLISECONDS
+        locationRequest.fastestInterval = FASTEST_UPDATE_INTERVAL_IN_MILLISECONDS
+        locationRequest.priority = LocationRequest.PRIORITY_HIGH_ACCURACY
+    }
+
+    private fun onNewLocation(location: Location) {
+        Log.i(TAG, "New location: $location")
+        this.location = location
+
+        // Notify anyone listening for broadcasts about the new location.
+        val intent = Intent(ACTION_BROADCAST)
+        intent.putExtra(EXTRA_LOCATION, location)
+        LocalBroadcastManager.getInstance(applicationContext).sendBroadcast(intent)
+    }
+
+    private fun getLastLocation() {
+        try {
+            fusedLocationClient.lastLocation
+                .addOnCompleteListener { task ->
+                    if (task.isSuccessful && task.result != null) {
+                        location = task.result
+                    } else {
+                        Log.w(TAG, "Failed to get location.")
+                    }
+                }
+        } catch (unlikely: SecurityException) {
+            Log.e(TAG, "Lost location permission.$unlikely")
+        }
+    }
+
+    /**
+     * Makes a request for location updates. Note that in this sample we merely log the
+     * [SecurityException].
+     */
+    fun requestLocationUpdates() {
+        Log.i(TAG, "Requesting location updates")
+        startService(Intent(applicationContext, CarLocationService::class.java))
+        try {
+            fusedLocationClient.requestLocationUpdates(
+                locationRequest,
+                locationCallback, Looper.myLooper()
+            )
+        } catch (unlikely: SecurityException) {
+            Log.e(TAG, "Lost location permission. Could not request updates. $unlikely")
+        }
+    }
+
+    /**
+     * Removes location updates. Note that in this sample we merely log the
+     * [SecurityException].
+     */
+    fun removeLocationUpdates() {
+        Log.i(TAG, "Removing location updates")
+        try {
+            fusedLocationClient.removeLocationUpdates(locationCallback)
+            stopSelf()
+        } catch (unlikely: SecurityException) {
+            Log.e(TAG, "Lost location permission. Could not remove updates. $unlikely")
+        }
+    }
+
+    override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
+        Log.i(TAG, "Service started")
+        // Tells the system to not try to recreate the service after it has been killed.
+        return START_NOT_STICKY
+    }
+
+    override fun onDestroy() {
+        serviceHandler.removeCallbacksAndMessages(null)
+    }
+
+    class LocalBinder(val service: CarLocationService) : Binder()
+}

app/src/google/java/net/vonforst/evmap/auto/PermissionActivity.kt

@@ -0,0 +1,72 @@
+package net.vonforst.evmap.auto
+
+import android.Manifest
+import android.app.Activity
+import android.content.pm.PackageManager
+import android.os.Bundle
+import android.os.ResultReceiver
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+
+
+class PermissionActivity : Activity() {
+    companion object {
+        const val EXTRA_RESULT_RECEIVER = "result_receiver";
+        const val RESULT_GRANTED = "granted"
+    }
+
+    private lateinit var resultReceiver: ResultReceiver
+    private val permissions = arrayOf(Manifest.permission.ACCESS_FINE_LOCATION)
+    private val requestCode = 1
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        if (intent != null) {
+            resultReceiver = intent.getParcelableExtra(EXTRA_RESULT_RECEIVER)!!
+            if (!hasPermissions(permissions)) {
+                ActivityCompat.requestPermissions(this, permissions, requestCode)
+            } else {
+                onComplete(
+                    requestCode,
+                    permissions,
+                    intArrayOf(PackageManager.PERMISSION_GRANTED)
+                )
+            }
+        } else {
+            finish()
+        }
+    }
+
+    private fun onComplete(requestCode: Int, permissions: Array<String>?, grantResults: IntArray) {
+        val bundle = Bundle()
+        bundle.putBoolean(
+            RESULT_GRANTED,
+            grantResults.all { it == PackageManager.PERMISSION_GRANTED })
+        resultReceiver.send(requestCode, bundle)
+        finish()
+    }
+
+    private fun hasPermissions(permissions: Array<String>): Boolean {
+        var result = true
+        for (permission in permissions) {
+            if (ContextCompat.checkSelfPermission(
+                    this,
+                    permission
+                ) != PackageManager.PERMISSION_GRANTED
+            ) {
+                result = false
+                break
+            }
+        }
+        return result
+    }
+
+    override fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<String>,
+        grantResults: IntArray
+    ) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+        onComplete(requestCode, permissions, grantResults)
+    }
+}

app/src/google/res/values-de/values.xml

@@ -5,4 +5,15 @@
         <item>OpenStreetMap (Mapbox)</item>
     </string-array>
     <string name="donations_info" formatted="false">Findest du EVMap nützlich? Unterstütze die Weiterentwicklung der App mit einer Spende an den Entwickler.\n\nGoogle zieht von der Spende 30% Gebühren ab.</string>
+    <string name="auto_location_service">EVMap läuft unter Android Auto und nutzt dafür deinen Standort.</string>
+    <string name="auto_no_chargers_found">Keine Ladestationen in der Nähe gefunden</string>
+    <string name="auto_no_favorites_found">Keine Favoriten gefunden</string>
+    <string name="open_in_app">In App öffnen</string>
+    <string name="opened_on_phone">Auf dem Telefon geöffnet</string>
+    <string name="auto_location_permission_needed">Um EVMap auf Android Auto zu nutzen, braucht die App Zugriff auf deinen Standort.</string>
+    <string name="grant_on_phone">Auf Telefon zulassen</string>
+    <string name="auto_chargers_closeby">In der Nähe</string>
+    <string name="auto_favorites">Favoriten</string>
+    <string name="auto_fault_report_date">⚠️ Störungsmeldung (%s)</string>
+    <string name="auto_no_refresh_possible">Weitere Aktualisierung nicht möglich. Bitte zurück gehen und neu starten.</string>
 </resources>

app/src/google/res/values/styles.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <style name="CarAppTheme">
+        <item name="carColorPrimary">@color/colorPrimary</item>
+        <item name="carColorPrimaryDark">@color/colorPrimaryVariant</item>
+        <item name="carColorSecondary">@color/colorSecondary</item>
+        <item name="carColorSecondaryDark">@color/colorSecondaryVariant</item>
+    </style>
+</resources>

app/src/google/res/values/values.xml

@@ -10,4 +10,15 @@
     </string-array>
     <string name="pref_map_provider_default" translatable="false">google</string>
     <string name="donations_info" formatted="false">Do you find EVMap useful? Support its development by sending a donation to the developer.\n\nGoogle takes 30% off every donation.</string>
+    <string name="auto_location_service">EVMap is running on Android Auto and using your location.</string>
+    <string name="auto_no_chargers_found">No nearby chargers found</string>
+    <string name="auto_no_favorites_found">No favorites found</string>
+    <string name="open_in_app">Open in app</string>
+    <string name="opened_on_phone">Opened on phone</string>
+    <string name="auto_location_permission_needed">To run EVMap on Android Auto, you need to grant access to your location.</string>
+    <string name="grant_on_phone">Grant on phone</string>
+    <string name="auto_chargers_closeby">Nearby chargers</string>
+    <string name="auto_favorites">Favorites</string>
+    <string name="auto_fault_report_date">⚠️ Fault report (%s)</string>
+    <string name="auto_no_refresh_possible">Further updates not possible. Please go back and restart.</string>
 </resources>

app/src/google/res/xml/automotive_app_desc.xml

@@ -0,0 +1,5 @@
+<automotiveApp xmlns:tools="http://schemas.android.com/tools">
+    <uses
+        name="template"
+        tools:ignore="InvalidUsesTagAttribute" />
+</automotiveApp>

app/src/main/AndroidManifest.xml

@@ -38,7 +38,23 @@
 
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <data android:scheme="geo" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <data
+                    android:scheme="https"
+                    android:host="www.goingelectric.de"
+                    android:pathPattern="/stromtankstellen/..*/..*/..*/..*/" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+            </intent-filter>
         </activity>
+
     </application>
 
 </manifest>

app/src/main/java/net/vonforst/evmap/MapsActivity.kt

@@ -17,11 +17,15 @@ import androidx.navigation.ui.setupWithNavController
 import com.google.android.material.navigation.NavigationView
 import com.google.android.material.snackbar.Snackbar
 import net.vonforst.evmap.api.goingelectric.ChargeLocation
+import net.vonforst.evmap.fragment.MapFragment
 import net.vonforst.evmap.storage.PreferenceDataSource
 import net.vonforst.evmap.utils.LocaleContextWrapper
 
 
 const val REQUEST_LOCATION_PERMISSION = 1
+const val EXTRA_CHARGER_ID = "chargerId"
+const val EXTRA_LAT = "lat"
+const val EXTRA_LON = "lon"
 
 class MapsActivity : AppCompatActivity() {
     interface FragmentCallback {
@@ -64,6 +68,46 @@ class MapsActivity : AppCompatActivity() {
         prefs = PreferenceDataSource(this)
 
         checkPlayServices(this)
+
+        if (intent?.scheme == "geo") {
+            val pos = intent.data?.schemeSpecificPart?.split("?")?.get(0)
+            val coords = pos?.split(",")?.map { it.toDoubleOrNull() }
+
+            if (coords != null && coords.size == 2) {
+                val lat = coords[0]
+                val lon = coords[1]
+                if (lat != null && lon != null) {
+                    val deepLink = navController.createDeepLink()
+                        .setGraph(R.navigation.nav_graph)
+                        .setDestination(R.id.map)
+                        .setArguments(MapFragment.showLocation(lat, lon))
+                        .createPendingIntent()
+                    deepLink.send()
+                }
+            }
+        } else if (intent?.scheme == "https" && intent?.data?.host == "www.goingelectric.de") {
+            val id = intent.data?.pathSegments?.last()?.toLongOrNull()
+            if (id != null) {
+                val deepLink = navController.createDeepLink()
+                    .setGraph(R.navigation.nav_graph)
+                    .setDestination(R.id.map)
+                    .setArguments(MapFragment.showChargerById(id))
+                    .createPendingIntent()
+                deepLink.send()
+            }
+        } else if (intent.hasExtra(EXTRA_CHARGER_ID)) {
+            navController.createDeepLink()
+                .setDestination(R.id.map)
+                .setArguments(
+                    MapFragment.showCharger(
+                        intent.getLongExtra(EXTRA_CHARGER_ID, 0),
+                        intent.getDoubleExtra(EXTRA_LAT, 0.0),
+                        intent.getDoubleExtra(EXTRA_LON, 0.0)
+                    )
+                )
+                .createPendingIntent()
+                .send()
+        }
     }
 
     fun navigateTo(charger: ChargeLocation) {

app/src/main/java/net/vonforst/evmap/api/Utils.kt

@@ -1,7 +1,11 @@
 package net.vonforst.evmap.api
 
+import android.content.Context
+import androidx.annotation.DrawableRes
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.suspendCancellableCoroutine
+import net.vonforst.evmap.R
+import net.vonforst.evmap.api.goingelectric.Chargepoint
 import okhttp3.Call
 import okhttp3.Callback
 import okhttp3.Response
@@ -39,26 +43,35 @@ suspend fun Call.await(): Response {
     }
 }
 
-const val earthRadiusKm: Double = 6372.8
+private val plugNames = mapOf(
+    Chargepoint.TYPE_1 to R.string.plug_type_1,
+    Chargepoint.TYPE_2 to R.string.plug_type_2,
+    Chargepoint.TYPE_3 to R.string.plug_type_3,
+    Chargepoint.CCS to R.string.plug_ccs,
+    Chargepoint.SCHUKO to R.string.plug_schuko,
+    Chargepoint.CHADEMO to R.string.plug_chademo,
+    Chargepoint.SUPERCHARGER to R.string.plug_supercharger,
+    Chargepoint.CEE_BLAU to R.string.plug_cee_blau,
+    Chargepoint.CEE_ROT to R.string.plug_cee_rot,
+    Chargepoint.TESLA_ROADSTER_HPC to R.string.plug_roadster_hpc
+)
 
-/**
- * Calculates the distance between two points on Earth in meters.
- * Latitude and longitude should be given in degrees.
- */
-fun distanceBetween(
-    startLatitude: Double, startLongitude: Double,
-    endLatitude: Double, endLongitude: Double
-): Double {
-    // see https://rosettacode.org/wiki/Haversine_formula#Java
-    val dLat = Math.toRadians(endLatitude - startLatitude);
-    val dLon = Math.toRadians(endLongitude - startLongitude);
-    val originLat = Math.toRadians(startLatitude);
-    val destinationLat = Math.toRadians(endLatitude);
+fun nameForPlugType(ctx: Context, type: String): String =
+    plugNames[type]?.let {
+        ctx.getString(it)
+    } ?: type
 
-    val a = Math.pow(Math.sin(dLat / 2), 2.toDouble()) + Math.pow(
-        Math.sin(dLon / 2),
-        2.toDouble()
-    ) * Math.cos(originLat) * Math.cos(destinationLat);
-    val c = 2 * Math.asin(Math.sqrt(a));
-    return earthRadiusKm * c * 1000;
-}
+@DrawableRes
+fun iconForPlugType(type: String): Int =
+    when (type) {
+        Chargepoint.CCS -> R.drawable.ic_connector_ccs
+        Chargepoint.CHADEMO -> R.drawable.ic_connector_chademo
+        Chargepoint.SCHUKO -> R.drawable.ic_connector_schuko
+        Chargepoint.SUPERCHARGER -> R.drawable.ic_connector_supercharger
+        Chargepoint.TYPE_2 -> R.drawable.ic_connector_typ2
+        Chargepoint.CEE_BLAU -> R.drawable.ic_connector_cee_blau
+        Chargepoint.CEE_ROT -> R.drawable.ic_connector_cee_rot
+        Chargepoint.TYPE_1 -> R.drawable.ic_connector_typ1
+        // TODO: add other connectors
+        else -> 0
+    }

app/src/main/java/net/vonforst/evmap/api/availability/AvailabilityDetector.kt

@@ -8,7 +8,10 @@ import net.vonforst.evmap.api.RateLimitInterceptor
 import net.vonforst.evmap.api.await
 import net.vonforst.evmap.api.goingelectric.ChargeLocation
 import net.vonforst.evmap.api.goingelectric.Chargepoint
+import net.vonforst.evmap.viewmodel.FilterValues
 import net.vonforst.evmap.viewmodel.Resource
+import net.vonforst.evmap.viewmodel.getMultipleChoiceValue
+import net.vonforst.evmap.viewmodel.getSliderValue
 import okhttp3.JavaNetCookieJar
 import okhttp3.OkHttpClient
 import okhttp3.Request
@@ -113,7 +116,21 @@ abstract class BaseAvailabilityDetector(private val client: OkHttpClient) : Avai
 data class ChargeLocationStatus(
     val status: Map<Chargepoint, List<ChargepointStatus>>,
     val source: String
-)
+) {
+    fun applyFilters(filters: FilterValues?): ChargeLocationStatus {
+        if (filters == null) return this
+
+        val connectorsVal = filters.getMultipleChoiceValue("connectors")
+        val minPower = filters.getSliderValue("min_power")
+
+        val statusFiltered = status.filterKeys {
+            (connectorsVal.all || it.type in connectorsVal.values) && it.power > minPower
+        }
+        return this.copy(status = statusFiltered)
+    }
+
+    val totalChargepoints = status.map { it.key.count }.sum()
+}
 
 enum class ChargepointStatus {
     AVAILABLE, UNKNOWN, CHARGING, OCCUPIED, FAULTED

app/src/main/java/net/vonforst/evmap/api/availability/NewMotionAvailabilityDetector.kt

@@ -1,9 +1,9 @@
 package net.vonforst.evmap.api.availability
 
 import com.squareup.moshi.JsonClass
-import net.vonforst.evmap.api.distanceBetween
 import net.vonforst.evmap.api.goingelectric.ChargeLocation
 import net.vonforst.evmap.api.goingelectric.Chargepoint
+import net.vonforst.evmap.utils.distanceBetween
 import okhttp3.OkHttpClient
 import retrofit2.Retrofit
 import retrofit2.converter.moshi.MoshiConverterFactory
@@ -150,7 +150,7 @@ class NewMotionAvailabilityDetector(client: OkHttpClient, baseUrl: String? = nul
                 "unspecified" -> "unknown"
                 "unknown" -> "unknown"
                 "saej1772" -> "unknown"
-                else -> throw IllegalArgumentException("unrecognized type ${connector.connectorType}")
+                else -> "unknown"
             }
             val status = when (statusStr) {
                 "Unavailable" -> ChargepointStatus.FAULTED

app/src/main/java/net/vonforst/evmap/api/goingelectric/GoingElectricApi.kt

@@ -6,7 +6,6 @@ import com.squareup.moshi.Moshi
 import net.vonforst.evmap.BuildConfig
 import okhttp3.Cache
 import okhttp3.OkHttpClient
-import retrofit2.Call
 import retrofit2.Response
 import retrofit2.Retrofit
 import retrofit2.converter.moshi.MoshiConverterFactory
@@ -16,7 +15,7 @@ import retrofit2.http.Query
 interface GoingElectricApi {
     @GET("chargepoints/")
     suspend fun getChargepoints(
-        @Query("sw_lat") swlat: Double, @Query("sw_lng") sw_lng: Double,
+        @Query("sw_lat") sw_lat: Double, @Query("sw_lng") sw_lng: Double,
         @Query("ne_lat") ne_lat: Double, @Query("ne_lng") ne_lng: Double,
         @Query("zoom") zoom: Float,
         @Query("clustering") clustering: Boolean = false,
@@ -35,7 +34,28 @@ interface GoingElectricApi {
     ): Response<ChargepointList>
 
     @GET("chargepoints/")
-    fun getChargepointDetail(@Query("ge_id") id: Long): Call<ChargepointList>
+    suspend fun getChargepointsRadius(
+        @Query("lat") lat: Double, @Query("lng") lng: Double,
+        @Query("radius") radius: Int,
+        @Query("zoom") zoom: Float,
+        @Query("orderby") orderby: String = "distance",
+        @Query("clustering") clustering: Boolean = false,
+        @Query("cluster_distance") clusterDistance: Int? = null,
+        @Query("freecharging") freecharging: Boolean = false,
+        @Query("freeparking") freeparking: Boolean = false,
+        @Query("min_power") minPower: Int = 0,
+        @Query("plugs") plugs: String? = null,
+        @Query("chargecards") chargecards: String? = null,
+        @Query("networks") networks: String? = null,
+        @Query("categories") categories: String? = null,
+        @Query("startkey") startkey: Int? = null,
+        @Query("open_twentyfourseven") open247: Boolean = false,
+        @Query("barrierfree") barrierfree: Boolean = false,
+        @Query("exclude_faults") excludeFaults: Boolean = false
+    ): Response<ChargepointList>
+
+    @GET("chargepoints/")
+    suspend fun getChargepointDetail(@Query("ge_id") id: Long): Response<ChargepointList>
 
     @GET("chargepoints/pluglist/")
     suspend fun getPlugs(): Response<StringList>

app/src/main/java/net/vonforst/evmap/api/goingelectric/GoingElectricModel.kt

@@ -80,6 +80,21 @@ data class ChargeLocation(
             .map { it.power }.maxOrNull() ?: 0.0
     }
 
+    fun isMulti(filteredConnectors: Set<String>? = null): Boolean {
+        var chargepoints = chargepointsMerged
+            .filter { filteredConnectors?.contains(it.type) ?: true }
+        if (maxPower(filteredConnectors) >= 43) {
+            // fast charger -> only count fast chargers
+            chargepoints = chargepoints.filter { it.power >= 43 }
+        }
+        val connectors = chargepoints.map { it.type }.distinct().toSet()
+
+        // check if there is more than one plug for any connector type
+        val chargepointsPerConnector =
+            connectors.map { conn -> chargepoints.filter { it.type == conn }.sumBy { it.count } }
+        return chargepointsPerConnector.any { it > 1 }
+    }
+
     /**
      * Merges chargepoints if they have the same plug and power
      *
@@ -114,14 +129,16 @@ data class Cost(
     @JsonObjectOrFalse @Json(name = "description_short") val descriptionShort: String?,
     @JsonObjectOrFalse @Json(name = "description_long") val descriptionLong: String?
 ) {
-    fun getStatusText(ctx: Context): CharSequence {
-        return HtmlCompat.fromHtml(
-            ctx.getString(
-                R.string.cost_detail,
-                if (freecharging) ctx.getString(R.string.free) else ctx.getString(R.string.paid),
-                if (freeparking) ctx.getString(R.string.free) else ctx.getString(R.string.paid)
-            ), 0
-        )
+    fun getStatusText(ctx: Context, emoji: Boolean = false): CharSequence {
+        val charging =
+            if (freecharging) ctx.getString(R.string.free) else ctx.getString(R.string.paid)
+        val parking =
+            if (freeparking) ctx.getString(R.string.free) else ctx.getString(R.string.paid)
+        return if (emoji) {
+            "⚡ $charging · \uD83C\uDD7F️ $parking"
+        } else {
+            HtmlCompat.fromHtml(ctx.getString(R.string.cost_detail, charging, parking), 0)
+        }
     }
 }
 

app/src/main/java/net/vonforst/evmap/fragment/FavoritesFragment.kt

@@ -86,8 +86,9 @@ class FavoritesFragment : Fragment(), LostApiClient.ConnectionCallbacks {
     }
 
     override fun onConnected() {
+        val context = this.context ?: return
         if (ContextCompat.checkSelfPermission(
-                requireContext(),
+                context,
                 Manifest.permission.ACCESS_FINE_LOCATION
             ) == PackageManager.PERMISSION_GRANTED
         ) {

app/src/main/java/net/vonforst/evmap/fragment/FilterProfilesFragment.kt

@@ -33,6 +33,8 @@ import net.vonforst.evmap.viewmodel.viewModelFactory
 
 
 class FilterProfilesFragment : Fragment() {
+    private lateinit var touchHelper: ItemTouchHelper
+    private lateinit var adapter: FilterProfilesAdapter
     private lateinit var binding: FragmentFilterProfilesBinding
     private val vm: FilterProfilesViewModel by viewModels(factoryProducer = {
         viewModelFactory {
@@ -40,6 +42,7 @@ class FilterProfilesFragment : Fragment() {
         }
     })
     private var deleteSnackbar: Snackbar? = null
+    private var toDelete: FilterProfile? = null
 
     override fun onCreateView(
         inflater: LayoutInflater,
@@ -64,7 +67,7 @@ class FilterProfilesFragment : Fragment() {
         )
 
 
-        val touchHelper = ItemTouchHelper(object : ItemTouchHelper.SimpleCallback(
+        touchHelper = ItemTouchHelper(object : ItemTouchHelper.SimpleCallback(
             ItemTouchHelper.UP or ItemTouchHelper.DOWN,
             ItemTouchHelper.RIGHT or ItemTouchHelper.LEFT
         ) {
@@ -173,7 +176,7 @@ class FilterProfilesFragment : Fragment() {
             }
         })
 
-        val adapter = FilterProfilesAdapter(touchHelper, onDelete = { fp ->
+        adapter = FilterProfilesAdapter(touchHelper, onDelete = { fp ->
             delete(fp)
         }, onRename = { fp ->
             showEditTextDialog(requireContext()) { dialog, input ->
@@ -183,7 +186,7 @@ class FilterProfilesFragment : Fragment() {
                     .setMessage(R.string.save_profile_enter_name)
                     .setPositiveButton(R.string.ok) { di, button ->
                         lifecycleScope.launch {
-                            vm.insert(fp.copy(name = input.text.toString()))
+                            vm.update(fp.copy(name = input.text.toString()))
                         }
                     }
                     .setNegativeButton(R.string.cancel) { di, button ->
@@ -192,7 +195,7 @@ class FilterProfilesFragment : Fragment() {
             }
         })
         binding.filterProfilesList.apply {
-            this.adapter = adapter
+            this.adapter = this@FilterProfilesFragment.adapter
             layoutManager =
                 LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
             addItemDecoration(
@@ -210,19 +213,43 @@ class FilterProfilesFragment : Fragment() {
     }
 
     fun delete(fp: FilterProfile) {
-        vm.delete(fp.id)
-
+        val position = vm.filterProfiles.value?.indexOf(fp) ?: return
+        // if there is already a profile to delete, delete it now
+        actuallyDelete()
         deleteSnackbar?.dismiss()
+
+        toDelete = fp
+
         view?.let {
             val snackbar = Snackbar.make(
                 it,
                 getString(R.string.deleted_filterprofile, fp.name),
                 Snackbar.LENGTH_LONG
             ).setAction(R.string.undo) {
-                vm.insert(fp.copy(id = 0))
-            }
+                toDelete = null
+                adapter.notifyItemChanged(position)
+            }.addCallback(object : Snackbar.Callback() {
+                override fun onDismissed(transientBottomBar: Snackbar?, event: Int) {
+                    // if undo was not clicked, actually delete
+                    if (event == DISMISS_EVENT_TIMEOUT || event == DISMISS_EVENT_SWIPE) {
+                        actuallyDelete()
+                    }
+                }
+            })
             deleteSnackbar = snackbar
             snackbar.show()
+        } ?: run {
+            actuallyDelete()
         }
     }
+
+    private fun actuallyDelete() {
+        toDelete?.let { vm.delete(it.id) }
+        toDelete = null
+    }
+
+    override fun onStop() {
+        super.onStop()
+        actuallyDelete()
+    }
 }

app/src/main/java/net/vonforst/evmap/fragment/MapFragment.kt

@@ -7,6 +7,7 @@ import android.content.Intent
 import android.content.pm.PackageManager
 import android.content.res.Configuration
 import android.graphics.Color
+import android.location.Location
 import android.os.Bundle
 import android.os.Handler
 import android.view.*
@@ -50,6 +51,8 @@ import com.mahc.custombottomsheetbehavior.BottomSheetBehaviorGoogleMapsLike
 import com.mahc.custombottomsheetbehavior.BottomSheetBehaviorGoogleMapsLike.STATE_COLLAPSED
 import com.mahc.custombottomsheetbehavior.BottomSheetBehaviorGoogleMapsLike.STATE_HIDDEN
 import com.mahc.custombottomsheetbehavior.MergedAppBarLayoutBehavior
+import com.mapzen.android.lost.api.LocationListener
+import com.mapzen.android.lost.api.LocationRequest
 import com.mapzen.android.lost.api.LocationServices
 import com.mapzen.android.lost.api.LostApiClient
 import io.michaelrocks.bimap.HashBiMap
@@ -74,13 +77,14 @@ import net.vonforst.evmap.ui.MarkerAnimator
 import net.vonforst.evmap.ui.getMarkerTint
 import net.vonforst.evmap.viewmodel.*
 
+
 const val REQUEST_AUTOCOMPLETE = 2
 const val ARG_CHARGER_ID = "chargerId"
 const val ARG_LAT = "lat"
 const val ARG_LON = "lon"
 
 class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallback,
-    LostApiClient.ConnectionCallbacks {
+    LostApiClient.ConnectionCallbacks, LocationListener {
     private lateinit var binding: FragmentMapBinding
     private val vm: MapViewModel by viewModels(factoryProducer = {
         viewModelFactory {
@@ -94,6 +98,7 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
     private var mapFragment: MapFragment? = null
     private var map: AnyMap? = null
     private lateinit var locationClient: LostApiClient
+    private var requestingLocationUpdates = false
     private lateinit var bottomSheetBehavior: BottomSheetBehaviorGoogleMapsLike<View>
     private lateinit var detailAppBarBehavior: MergedAppBarLayoutBehavior
     private var markers: MutableBiMap<Marker, ChargeLocation> = HashBiMap()
@@ -223,8 +228,19 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
             (requireActivity() as MapsActivity).appBarConfiguration
         )
 
-        if (!PreferenceDataSource(requireContext()).welcomeDialogShown) {
-            navController.navigate(R.id.action_map_to_welcome)
+        val prefs = PreferenceDataSource(requireContext())
+        if (!prefs.welcomeDialogShown) {
+            try {
+                navController.navigate(R.id.action_map_to_welcome)
+            } catch (ignored: IllegalArgumentException) {
+                // when there is already another navigation going on
+            }
+        } else if (!prefs.update060AndroidAutoDialogShown) {
+            try {
+                navController.navigate(R.id.action_map_to_update_060_androidauto)
+            } catch (ignored: IllegalArgumentException) {
+                // when there is already another navigation going on
+            }
         }
     }
 
@@ -233,6 +249,13 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
         val hostActivity = activity as? MapsActivity ?: return
         hostActivity.fragmentCallback = this
         vm.reloadPrefs()
+        if (requestingLocationUpdates && ContextCompat.checkSelfPermission(
+                requireContext(),
+                ACCESS_FINE_LOCATION
+            ) == PackageManager.PERMISSION_GRANTED
+        ) {
+            requestLocationUpdates()
+        }
     }
 
     private fun setupClickListeners() {
@@ -270,7 +293,8 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
         binding.detailView.btnChargeprice.setOnClickListener {
             val charger = vm.charger.value?.data ?: return@setOnClickListener
             (activity as? MapsActivity)?.openUrl(
-                "https://www.chargeprice.app/?poi_id=${charger.id}&poi_source=going_electric")
+                "https://www.chargeprice.app/?poi_id=${charger.id}&poi_source=going_electric"
+            )
         }
         binding.detailView.topPart.setOnClickListener {
             bottomSheetBehavior.state = BottomSheetBehaviorGoogleMapsLike.STATE_ANCHOR_POINT
@@ -353,7 +377,12 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
                 vm.bottomSheetState.value = newState
                 updateBackPressedCallback()
 
-                if (vm.layersMenuOpen.value!! && newState !in listOf(BottomSheetBehaviorGoogleMapsLike.STATE_SETTLING, BottomSheetBehaviorGoogleMapsLike.STATE_HIDDEN, BottomSheetBehaviorGoogleMapsLike.STATE_COLLAPSED)) {
+                if (vm.layersMenuOpen.value!! && newState !in listOf(
+                        BottomSheetBehaviorGoogleMapsLike.STATE_SETTLING,
+                        BottomSheetBehaviorGoogleMapsLike.STATE_HIDDEN,
+                        BottomSheetBehaviorGoogleMapsLike.STATE_COLLAPSED
+                    )
+                ) {
                     closeLayersMenu()
                 }
             }
@@ -407,6 +436,8 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
             searchResultMarker = null
 
             if (place != null) {
+                // disable location following when search result is shown
+                vm.myLocationEnabled.value = false
                 if (place.viewport != null) {
                     map.animateCamera(map.cameraUpdateFactory.newLatLngBounds(place.viewport, 0))
                 } else {
@@ -456,7 +487,7 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
                     getMarkerTint(c, vm.filteredConnectors.value),
                     highlight = false,
                     fault = c.faultReport != null,
-                    multi = getMarkerMulti(c, vm.filteredConnectors.value)
+                    multi = c.isMulti(vm.filteredConnectors.value)
                 )
             )
         }
@@ -470,7 +501,7 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
                 getMarkerTint(charger, vm.filteredConnectors.value),
                 highlight = true,
                 fault = charger.faultReport != null,
-                multi = getMarkerMulti(charger, vm.filteredConnectors.value)
+                multi = charger.isMulti(vm.filteredConnectors.value)
             )
         )
         animator.animateMarkerBounce(marker)
@@ -483,28 +514,13 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
                         getMarkerTint(c, vm.filteredConnectors.value),
                         highlight = false,
                         fault = c.faultReport != null,
-                        multi = getMarkerMulti(c, vm.filteredConnectors.value)
+                        multi = c.isMulti(vm.filteredConnectors.value)
                     )
                 )
             }
         }
     }
 
-    private fun getMarkerMulti(charger: ChargeLocation, filteredConnectors: Set<String>?): Boolean {
-        var chargepoints = charger.chargepointsMerged
-            .filter { filteredConnectors?.contains(it.type) ?: true }
-        if (charger.maxPower(filteredConnectors) >= 43) {
-            // fast charger -> only count fast chargers
-            chargepoints = chargepoints.filter { it.power >= 43 }
-        }
-        val connectors = chargepoints.map { it.type }.distinct().toSet()
-
-        // check if there is more than one plug for any connector type
-        val chargepointsPerConnector =
-            connectors.map { conn -> chargepoints.filter { it.type == conn }.sumBy { it.count } }
-        return chargepointsPerConnector.any { it > 1 }
-    }
-
     private fun updateFavoriteToggle() {
         val favs = vm.favorites.value ?: return
         val charger = vm.chargerSparse.value ?: return
@@ -673,6 +689,15 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
         map.setOnCameraMoveListener {
             binding.scaleView.update(map.cameraPosition.zoom, map.cameraPosition.target.latitude)
         }
+        map.setOnCameraMoveStartedListener { reason ->
+            if (reason == AnyMap.OnCameraMoveStartedListener.REASON_GESTURE
+                && vm.myLocationEnabled.value == true
+            ) {
+                // disable location following when manually scrolling the map
+                vm.myLocationEnabled.value = false
+                removeLocationUpdates()
+            }
+        }
         map.setOnMarkerClickListener { marker ->
             when (marker) {
                 in markers -> {
@@ -698,6 +723,8 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
                 backPressedCallback.handleOnBackPressed()
             }
         }
+        map.setMapType(vm.mapType.value)
+        map.setTrafficEnabled(vm.mapTrafficEnabled.value ?: false)
 
         // set padding so that compass is not obstructed by toolbar
         map.setPadding(0, binding.toolbarContainer.height, 0, 0)
@@ -711,33 +738,57 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
         val position = vm.mapPosition.value
         val lat = arguments?.optDouble(ARG_LAT)
         val lon = arguments?.optDouble(ARG_LON)
+        val chargerId = arguments?.optLong(ARG_CHARGER_ID)
+
         var positionSet = false
 
         if (position != null) {
             val cameraUpdate =
                 map.cameraUpdateFactory.newLatLngZoom(position.bounds.center, position.zoom)
             map.moveCamera(cameraUpdate)
+            positionSet = true
+        } else if (chargerId != null && (lat == null || lon == null)) {
+            // show given charger ID
+            vm.loadChargerById(chargerId)
+            vm.chargerSparse.observe(
+                viewLifecycleOwner,
+                object : Observer<ChargeLocation> {
+                    override fun onChanged(item: ChargeLocation?) {
+                        if (item?.id == chargerId) {
+                            val cameraUpdate = map.cameraUpdateFactory.newLatLngZoom(
+                                LatLng(item.coordinates.lat, item.coordinates.lng), 16f
+                            )
+                            map.moveCamera(cameraUpdate)
+                            vm.chargerSparse.removeObserver(this)
+                        }
+                    }
+                })
+
             positionSet = true
         } else if (lat != null && lon != null) {
             // show given position
             val cameraUpdate = map.cameraUpdateFactory.newLatLngZoom(LatLng(lat, lon), 16f)
             map.moveCamera(cameraUpdate)
 
-            // show charger detail after chargers were loaded
-            val chargerId = arguments?.optLong(ARG_CHARGER_ID)
-            vm.chargepoints.observe(
-                viewLifecycleOwner,
-                object : Observer<Resource<List<ChargepointListItem>>> {
-                    override fun onChanged(res: Resource<List<ChargepointListItem>>) {
-                        if (res.data == null) return
-                        for (item in res.data) {
-                            if (item is ChargeLocation && item.id == chargerId) {
-                                vm.chargerSparse.value = item
-                                vm.chargepoints.removeObserver(this)
+            if (chargerId != null) {
+                // show charger detail after chargers were loaded
+                vm.chargepoints.observe(
+                    viewLifecycleOwner,
+                    object : Observer<Resource<List<ChargepointListItem>>> {
+                        override fun onChanged(res: Resource<List<ChargepointListItem>>) {
+                            if (res.data == null) return
+                            for (item in res.data) {
+                                if (item is ChargeLocation && item.id == chargerId) {
+                                    vm.chargerSparse.value = item
+                                    vm.chargepoints.removeObserver(this)
+                                }
                             }
                         }
-                    }
-                })
+                    })
+            } else {
+                // mark location as search result
+                vm.searchResult.value = PlaceWithBounds(LatLng(lat, lon), null)
+            }
 
             positionSet = true
         }
@@ -765,15 +816,18 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
     private fun enableLocation(moveTo: Boolean, animate: Boolean) {
         val map = this.map ?: return
         map.setMyLocationEnabled(true)
-        vm.myLocationEnabled.value = true
         map.uiSettings.setMyLocationButtonEnabled(false)
-        if (moveTo && locationClient.isConnected) {
-            moveToCurrentLocation(map, animate)
+        if (moveTo) {
+            vm.myLocationEnabled.value = true
+            if (locationClient.isConnected) {
+                moveToLastLocation(map, animate)
+                requestLocationUpdates()
+            }
         }
     }
 
     @RequiresPermission(ACCESS_FINE_LOCATION)
-    private fun moveToCurrentLocation(map: AnyMap, animate: Boolean) {
+    private fun moveToLastLocation(map: AnyMap, animate: Boolean) {
         val location = LocationServices.FusedLocationApi.getLastLocation(locationClient)
         if (location != null) {
             val latLng = LatLng(location.latitude, location.longitude)
@@ -804,7 +858,7 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
                     getMarkerTint(charger, vm.filteredConnectors.value),
                     highlight = charger == vm.chargerSparse.value,
                     fault = charger.faultReport != null,
-                    multi = getMarkerMulti(charger, vm.filteredConnectors.value)
+                    multi = charger.isMulti(vm.filteredConnectors.value)
                 )
             )
         }
@@ -821,7 +875,7 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
                         val tint = getMarkerTint(charger, vm.filteredConnectors.value)
                         val highlight = charger == vm.chargerSparse.value
                         val fault = charger.faultReport != null
-                        val multi = getMarkerMulti(charger, vm.filteredConnectors.value)
+                        val multi = charger.isMulti(vm.filteredConnectors.value)
                         animator.animateMarkerDisappear(marker, tint, highlight, fault, multi)
                     } else {
                         animator.deleteMarker(marker)
@@ -836,7 +890,7 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
                     val tint = getMarkerTint(charger, vm.filteredConnectors.value)
                     val highlight = charger == vm.chargerSparse.value
                     val fault = charger.faultReport != null
-                    val multi = getMarkerMulti(charger, vm.filteredConnectors.value)
+                    val multi = charger.isMulti(vm.filteredConnectors.value)
                     val marker = map.addMarker(
                         MarkerOptions()
                             .position(LatLng(charger.coordinates.lat, charger.coordinates.lng))
@@ -1050,21 +1104,74 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
                 putDouble(ARG_LON, charger.coordinates.lng)
             }
         }
+
+        fun showLocation(lat: Double, lon: Double): Bundle {
+            return Bundle().apply {
+                putDouble(ARG_LAT, lat)
+                putDouble(ARG_LON, lon)
+            }
+        }
+
+        fun showChargerById(id: Long): Bundle? {
+            return Bundle().apply {
+                putLong(ARG_CHARGER_ID, id)
+            }
+        }
+
+        fun showCharger(id: Long, lat: Double, lon: Double): Bundle {
+            return Bundle().apply {
+                putLong(ARG_CHARGER_ID, id)
+                putDouble(ARG_LAT, lat)
+                putDouble(ARG_LON, lon)
+            }
+        }
     }
 
     override fun onConnected() {
         val map = this.map ?: return
+        val context = this.context ?: return
         if (vm.myLocationEnabled.value == true) {
             if (ActivityCompat.checkSelfPermission(
-                    requireContext(),
+                    context,
                     ACCESS_FINE_LOCATION
                 ) == PackageManager.PERMISSION_GRANTED
             ) {
-                moveToCurrentLocation(map, false)
+                moveToLastLocation(map, false)
+                requestLocationUpdates()
             }
         }
     }
 
+    @RequiresPermission(ACCESS_FINE_LOCATION)
+    private fun requestLocationUpdates() {
+        val request: LocationRequest = LocationRequest.create()
+            .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
+            .setInterval(5000)
+        LocationServices.FusedLocationApi.requestLocationUpdates(locationClient, request, this)
+        requestingLocationUpdates = true
+    }
+
+    private fun removeLocationUpdates() {
+        if (locationClient.isConnected) {
+            LocationServices.FusedLocationApi.removeLocationUpdates(locationClient, this)
+        }
+    }
+
     override fun onConnectionSuspended() {
     }
+
+    override fun onLocationChanged(location: Location?) {
+        val map = this.map ?: return
+        if (location == null || vm.myLocationEnabled.value == false) return
+
+        val latLng = LatLng(location.latitude, location.longitude)
+        vm.location.value = latLng
+        val camUpdate = map.cameraUpdateFactory.newLatLng(latLng)
+        map.animateCamera(camUpdate)
+    }
+
+    override fun onPause() {
+        super.onPause()
+        removeLocationUpdates()
+    }
 }

app/src/main/java/net/vonforst/evmap/fragment/WelcomeDialogFragment.kt

@@ -25,7 +25,9 @@ class WelcomeDialogFragment : AppCompatDialogFragment() {
         super.onViewCreated(view, savedInstanceState)
 
         binding.btnOk.setOnClickListener {
-            PreferenceDataSource(requireContext()).welcomeDialogShown = true
+            val prefs = PreferenceDataSource(requireContext())
+            prefs.welcomeDialogShown = true
+            prefs.update060AndroidAutoDialogShown = true
             dismiss()
         }
     }

app/src/main/java/net/vonforst/evmap/fragment/updatedialogs/Update060AndroidAutoDialogFramgent.kt

@@ -0,0 +1,40 @@
+package net.vonforst.evmap.fragment.updatedialogs
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.view.WindowManager
+import androidx.appcompat.app.AppCompatDialogFragment
+import net.vonforst.evmap.databinding.DialogUpdate060AndroidautoBinding
+import net.vonforst.evmap.storage.PreferenceDataSource
+
+class Update060AndroidAutoDialogFramgent : AppCompatDialogFragment() {
+    private lateinit var binding: DialogUpdate060AndroidautoBinding
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        binding = DialogUpdate060AndroidautoBinding.inflate(inflater, container, false)
+        return binding.root
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+
+        binding.btnOk.setOnClickListener {
+            PreferenceDataSource(requireContext()).update060AndroidAutoDialogShown = true
+            dismiss()
+        }
+    }
+
+    override fun onStart() {
+        super.onStart()
+        dialog?.window?.setLayout(
+            WindowManager.LayoutParams.MATCH_PARENT,
+            WindowManager.LayoutParams.WRAP_CONTENT
+        )
+    }
+}

app/src/main/java/net/vonforst/evmap/storage/ChargeLocationsDao.kt

@@ -14,4 +14,7 @@ interface ChargeLocationsDao {
 
     @Query("SELECT * FROM chargelocation")
     fun getAllChargeLocations(): LiveData<List<ChargeLocation>>
+
+    @Query("SELECT * FROM chargelocation")
+    suspend fun getAllChargeLocationsAsync(): List<ChargeLocation>
 }

app/src/main/java/net/vonforst/evmap/storage/PreferenceDataSource.kt

@@ -2,6 +2,7 @@ package net.vonforst.evmap.storage
 
 import android.content.Context
 import androidx.preference.PreferenceManager
+import com.car2go.maps.AnyMap
 import net.vonforst.evmap.R
 import net.vonforst.evmap.viewmodel.FILTERS_CUSTOM
 import net.vonforst.evmap.viewmodel.FILTERS_DISABLED
@@ -73,9 +74,27 @@ class PreferenceDataSource(val context: Context) {
             context.getString(R.string.pref_map_provider_default)
         )!!
 
+    var mapType: AnyMap.Type
+        get() = AnyMap.Type.valueOf(sp.getString("map_type", null) ?: AnyMap.Type.NORMAL.toString())
+        set(type) {
+            sp.edit().putString("map_type", type.toString()).apply()
+        }
+
+    var mapTrafficEnabled: Boolean
+        get() = sp.getBoolean("map_traffic_enabled", false)
+        set(value) {
+            sp.edit().putBoolean("map_traffic_enabled", value).apply()
+        }
+
     var welcomeDialogShown: Boolean
         get() = sp.getBoolean("welcome_dialog_shown", false)
         set(value) {
             sp.edit().putBoolean("welcome_dialog_shown", value).apply()
         }
+
+    var update060AndroidAutoDialogShown: Boolean
+        get() = sp.getBoolean("update_0.6.0_androidauto_dialog_shown", false)
+        set(value) {
+            sp.edit().putBoolean("update_0.6.0_androidauto_dialog_shown", value).apply()
+        }
 }

app/src/main/java/net/vonforst/evmap/ui/BindingAdapters.kt

@@ -17,7 +17,7 @@ import androidx.viewpager2.widget.ViewPager2
 import com.google.android.material.floatingactionbutton.FloatingActionButton
 import net.vonforst.evmap.R
 import net.vonforst.evmap.api.availability.ChargepointStatus
-import net.vonforst.evmap.api.goingelectric.Chargepoint
+import net.vonforst.evmap.api.iconForPlugType
 import kotlin.math.roundToInt
 
 
@@ -80,20 +80,7 @@ fun <T> setRecyclerViewData(recyclerView: ViewPager2, items: List<T>?) {
 
 @BindingAdapter("connectorIcon")
 fun getConnectorItem(view: ImageView, type: String) {
-    view.setImageResource(
-        when (type) {
-            Chargepoint.CCS -> R.drawable.ic_connector_ccs
-            Chargepoint.CHADEMO -> R.drawable.ic_connector_chademo
-            Chargepoint.SCHUKO -> R.drawable.ic_connector_schuko
-            Chargepoint.SUPERCHARGER -> R.drawable.ic_connector_supercharger
-            Chargepoint.TYPE_2 -> R.drawable.ic_connector_typ2
-            Chargepoint.CEE_BLAU -> R.drawable.ic_connector_cee_blau
-            Chargepoint.CEE_ROT -> R.drawable.ic_connector_cee_rot
-            Chargepoint.TYPE_1 -> R.drawable.ic_connector_typ1
-            // TODO: add other connectors
-            else -> 0
-        }
-    )
+    view.setImageResource(iconForPlugType(type))
 }
 
 @BindingAdapter("srcCompat")
@@ -163,8 +150,8 @@ fun setLinkify(textView: TextView, oldValue: Int, newValue: Int) {
     textView.linksClickable = newValue != 0
 
     // remove spans
-    if (newValue == 0) {
-        val text = textView.text as SpannableString
+    val text = textView.text
+    if (newValue == 0 && text != null && text is SpannableString) {
         text.getSpans(0, text.length, Any::class.java).forEach {
             text.removeSpan(it)
         }

app/src/main/java/net/vonforst/evmap/ui/IconGenerators.kt

@@ -43,8 +43,11 @@ class ClusterIconGenerator(context: Context) : IconGenerator(context) {
 
 
 class ChargerIconGenerator(
-    val context: Context, val factory: BitmapDescriptorFactory,
-    val scaleResolution: Int = 20
+    val context: Context,
+    val factory: BitmapDescriptorFactory?,
+    val scaleResolution: Int = 20,
+    val oversize: Float = 1.4f, // increase to add padding for fault icon or scale > 1
+    val height: Int = 44
 ) {
     private data class BitmapData(
         val tint: Int,
@@ -58,7 +61,6 @@ class ChargerIconGenerator(
     // 230 items: (21 sizes, 5 colors, multi on/off) + highlight + fault (only with scale = 1)
     private val cacheSize = (scaleResolution + 3) * 5 * 2;
     private val cache = LruCache<BitmapData, BitmapDescriptor>(cacheSize)
-    private val oversize = 1.4f  // increase to add padding for fault icon or scale > 1
     private val icon = R.drawable.ic_map_marker_charging
     private val multiIcon = R.drawable.ic_map_marker_charging_multiple
     private val highlightIcon = R.drawable.ic_map_marker_highlight
@@ -110,12 +112,30 @@ class ChargerIconGenerator(
             cachedImg
         } else {
             val bitmap = generateBitmap(data)
-            val bmd = factory.fromBitmap(bitmap)
+            val bmd = factory!!.fromBitmap(bitmap)
             cache.put(data, bmd)
             bmd
         }
     }
 
+    fun getBitmap(
+        @ColorRes tint: Int,
+        scale: Float = 1f,
+        alpha: Int = 255,
+        highlight: Boolean = false,
+        fault: Boolean = false,
+        multi: Boolean = false
+    ): Bitmap {
+        val data = BitmapData(
+            tint, (scale * scaleResolution).roundToInt(),
+            alpha,
+            if (scale == 1f) highlight else false,
+            if (scale == 1f) fault else false,
+            multi
+        )
+        return generateBitmap(data)
+    }
+
     private fun generateBitmap(data: BitmapData): Bitmap {
         val icon = if (data.multi) multiIcon else icon
         val vd: Drawable = ContextCompat.getDrawable(context, icon)!!
@@ -123,17 +143,22 @@ class ChargerIconGenerator(
         DrawableCompat.setTint(vd, ContextCompat.getColor(context, data.tint));
         DrawableCompat.setTintMode(vd, PorterDuff.Mode.MULTIPLY);
 
-        val leftPadding = vd.intrinsicWidth * (oversize - 1) / 2
-        val topPadding = vd.intrinsicHeight * (oversize - 1)
+        val density = context.resources.displayMetrics.density
+        val width =
+            (height.toFloat() * density / vd.intrinsicHeight * vd.intrinsicWidth).roundToInt()
+        val height = (height * density).roundToInt()
+
+        val leftPadding = width * (oversize - 1) / 2
+        val topPadding = height * (oversize - 1)
         vd.setBounds(
             leftPadding.toInt(), topPadding.toInt(),
-            leftPadding.toInt() + vd.intrinsicWidth,
-            topPadding.toInt() + vd.intrinsicHeight
+            leftPadding.toInt() + width,
+            topPadding.toInt() + height
         )
         vd.alpha = data.alpha
 
         val bm = Bitmap.createBitmap(
-            (vd.intrinsicWidth * oversize).toInt(), (vd.intrinsicHeight * oversize).toInt(),
+            (width * oversize).toInt(), (height * oversize).toInt(),
             Bitmap.Config.ARGB_8888
         )
         val canvas = Canvas(bm)
@@ -142,8 +167,8 @@ class ChargerIconGenerator(
         canvas.scale(
             scale,
             scale,
-            leftPadding + vd.intrinsicWidth / 2f,
-            topPadding + vd.intrinsicHeight.toFloat()
+            leftPadding + width / 2f,
+            topPadding + height.toFloat()
         )
 
         vd.draw(canvas)
@@ -153,8 +178,8 @@ class ChargerIconGenerator(
             val highlightDrawable = ContextCompat.getDrawable(context, hIcon)!!
             highlightDrawable.setBounds(
                 leftPadding.toInt(), topPadding.toInt(),
-                leftPadding.toInt() + vd.intrinsicWidth,
-                topPadding.toInt() + vd.intrinsicHeight
+                leftPadding.toInt() + width,
+                topPadding.toInt() + height
             )
             highlightDrawable.alpha = data.alpha
             highlightDrawable.draw(canvas)
@@ -164,7 +189,7 @@ class ChargerIconGenerator(
             val faultDrawable = ContextCompat.getDrawable(context, faultIcon)!!
             val faultSize = 0.75
             val faultShift = 0.25
-            val base = vd.intrinsicWidth
+            val base = width
             faultDrawable.setBounds(
                 (leftPadding.toInt() + base * (1 - faultSize + faultShift)).toInt(),
                 (topPadding.toInt() - base * faultShift).toInt(),

app/src/main/java/net/vonforst/evmap/ui/MarkerUtils.kt

@@ -12,7 +12,7 @@ import kotlin.math.max
 
 fun getMarkerTint(
     charger: ChargeLocation,
-    connectors: Set<String>?
+    connectors: Set<String>? = null
 ): Int = when {
     charger.maxPower(connectors) >= 100 -> R.color.charger_100kw
     charger.maxPower(connectors) >= 43 -> R.color.charger_43kw

app/src/main/java/net/vonforst/evmap/utils/LocationUtils.kt

@@ -0,0 +1,34 @@
+package net.vonforst.evmap.utils
+
+import android.location.Location
+import kotlin.math.*
+
+/**
+ * Adds a certain distance in meters to a location. Approximate calculation.
+ */
+fun Location.plusMeters(dx: Double, dy: Double): Pair<Double, Double> {
+    val lat = this.latitude + (180 / Math.PI) * (dx / 6378137.0)
+    val lon = this.longitude + (180 / Math.PI) * (dy / 6378137.0) / cos(Math.toRadians(lat))
+    return Pair(lat, lon)
+}
+
+const val earthRadiusM = 6378137.0
+
+/**
+ * Calculates the distance between two points on Earth in meters.
+ * Latitude and longitude should be given in degrees.
+ */
+fun distanceBetween(
+    startLatitude: Double, startLongitude: Double,
+    endLatitude: Double, endLongitude: Double
+): Double {
+    // see https://rosettacode.org/wiki/Haversine_formula#Java
+    val dLat = Math.toRadians(endLatitude - startLatitude)
+    val dLon = Math.toRadians(endLongitude - startLongitude)
+    val originLat = Math.toRadians(startLatitude)
+    val destinationLat = Math.toRadians(endLatitude)
+
+    val a = sin(dLat / 2).pow(2.0) + sin(dLon / 2).pow(2.0) * cos(originLat) * cos(destinationLat)
+    val c = 2 * asin(sqrt(a))
+    return earthRadiusM * c
+}

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

@@ -10,10 +10,10 @@ import net.vonforst.evmap.adapter.Equatable
 import net.vonforst.evmap.api.availability.ChargeLocationStatus
 import net.vonforst.evmap.api.availability.ChargepointStatus
 import net.vonforst.evmap.api.availability.getAvailability
-import net.vonforst.evmap.api.distanceBetween
 import net.vonforst.evmap.api.goingelectric.ChargeLocation
 import net.vonforst.evmap.api.goingelectric.GoingElectricApi
 import net.vonforst.evmap.storage.AppDatabase
+import net.vonforst.evmap.utils.distanceBetween
 
 class FavoritesViewModel(application: Application, geApiKey: String) :
     AndroidViewModel(application) {

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

@@ -33,6 +33,12 @@ class FilterProfilesViewModel(application: Application) : AndroidViewModel(appli
         }
     }
 
+    fun update(item: FilterProfile) {
+        viewModelScope.launch {
+            db.filterProfileDao().update(item)
+        }
+    }
+
     fun reorderProfiles(list: List<FilterProfile>) {
         viewModelScope.launch {
             db.filterProfileDao().update(*list.toTypedArray())

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

@@ -12,6 +12,7 @@ import net.vonforst.evmap.adapter.Equatable
 import net.vonforst.evmap.api.goingelectric.ChargeCard
 import net.vonforst.evmap.api.goingelectric.Chargepoint
 import net.vonforst.evmap.api.goingelectric.GoingElectricApi
+import net.vonforst.evmap.api.nameForPlugType
 import net.vonforst.evmap.storage.*
 import kotlin.math.abs
 import kotlin.reflect.KClass
@@ -30,21 +31,9 @@ internal fun getFilters(
     chargeCards: LiveData<List<ChargeCard>>
 ): LiveData<List<Filter<FilterValue>>> {
     return MediatorLiveData<List<Filter<FilterValue>>>().apply {
-        val plugNames = mapOf(
-            Chargepoint.TYPE_1 to application.getString(R.string.plug_type_1),
-            Chargepoint.TYPE_2 to application.getString(R.string.plug_type_2),
-            Chargepoint.TYPE_3 to application.getString(R.string.plug_type_3),
-            Chargepoint.CCS to application.getString(R.string.plug_ccs),
-            Chargepoint.SCHUKO to application.getString(R.string.plug_schuko),
-            Chargepoint.CHADEMO to application.getString(R.string.plug_chademo),
-            Chargepoint.SUPERCHARGER to application.getString(R.string.plug_supercharger),
-            Chargepoint.CEE_BLAU to application.getString(R.string.plug_cee_blau),
-            Chargepoint.CEE_ROT to application.getString(R.string.plug_cee_rot),
-            Chargepoint.TESLA_ROADSTER_HPC to application.getString(R.string.plug_roadster_hpc)
-        )
         listOf(plugs, networks, chargeCards).forEach { source ->
             addSource(source) { _ ->
-                buildFilters(plugs, plugNames, networks, chargeCards, application)
+                buildFilters(plugs, networks, chargeCards, application)
             }
         }
     }
@@ -52,13 +41,12 @@ internal fun getFilters(
 
 private fun MediatorLiveData<List<Filter<FilterValue>>>.buildFilters(
     plugs: LiveData<List<Plug>>,
-    plugNames: Map<String, String>,
     networks: LiveData<List<Network>>,
     chargeCards: LiveData<List<ChargeCard>>,
     application: Application
 ) {
     val plugMap = plugs.value?.map { plug ->
-        plug.name to (plugNames[plug.name] ?: plug.name)
+        plug.name to nameForPlugType(application, plug.name)
     }?.toMap() ?: return
     val networkMap = networks.value?.map { it.name to it.name }?.toMap() ?: return
     val chargecardMap = chargeCards.value?.map { it.id.toString() to it.name }?.toMap() ?: return
@@ -135,8 +123,8 @@ private fun MediatorLiveData<List<Filter<FilterValue>>>.buildFilters(
 internal fun filtersWithValue(
     filters: LiveData<List<Filter<FilterValue>>>,
     filterValues: LiveData<List<FilterValue>>
-): MediatorLiveData<List<FilterWithValue<out FilterValue>>> =
-    MediatorLiveData<List<FilterWithValue<out FilterValue>>>().apply {
+): MediatorLiveData<FilterValues> =
+    MediatorLiveData<FilterValues>().apply {
         listOf(filters, filterValues).forEach {
             addSource(it) {
                 val f = filters.value ?: return@addSource
@@ -173,7 +161,7 @@ class FilterViewModel(application: Application, geApiKey: String) :
         db.filterValueDao().getFilterValues(FILTERS_CUSTOM)
     }
 
-    val filtersWithValue: LiveData<List<FilterWithValue<out FilterValue>>> by lazy {
+    val filtersWithValue: LiveData<FilterValues> by lazy {
         filtersWithValue(filters, filterValues)
     }
 
@@ -331,5 +319,19 @@ data class SliderFilterValue(
 
 data class FilterWithValue<T : FilterValue>(val filter: Filter<T>, val value: T) : Equatable
 
+typealias FilterValues = List<FilterWithValue<out FilterValue>>
+
+fun FilterValues.getBooleanValue(key: String) =
+    (this.find { it.value.key == key }!!.value as BooleanFilterValue).value
+
+fun FilterValues.getSliderValue(key: String) =
+    (this.find { it.value.key == key }!!.value as SliderFilterValue).value
+
+fun FilterValues.getMultipleChoiceFilter(key: String) =
+    this.find { it.value.key == key }!!.filter as MultipleChoiceFilter
+
+fun FilterValues.getMultipleChoiceValue(key: String) =
+    this.find { it.value.key == key }!!.value as MultipleChoiceFilterValue
+
 const val FILTERS_DISABLED = -2L
 const val FILTERS_CUSTOM = -1L

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

@@ -6,17 +6,16 @@ import com.car2go.maps.AnyMap
 import com.car2go.maps.model.LatLng
 import com.car2go.maps.model.LatLngBounds
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 import net.vonforst.evmap.api.availability.ChargeLocationStatus
 import net.vonforst.evmap.api.availability.getAvailability
-import net.vonforst.evmap.api.distanceBetween
-import net.vonforst.evmap.api.goingelectric.*
+import net.vonforst.evmap.api.goingelectric.ChargeCard
+import net.vonforst.evmap.api.goingelectric.ChargeLocation
+import net.vonforst.evmap.api.goingelectric.ChargepointListItem
+import net.vonforst.evmap.api.goingelectric.GoingElectricApi
 import net.vonforst.evmap.storage.*
 import net.vonforst.evmap.ui.cluster
-import retrofit2.Call
-import retrofit2.Callback
-import retrofit2.Response
+import net.vonforst.evmap.utils.distanceBetween
 import java.io.IOException
 
 data class MapPosition(val bounds: LatLngBounds, val zoom: Float)
@@ -37,7 +36,6 @@ class MapViewModel(application: Application, geApiKey: String) : AndroidViewMode
     private var api = GoingElectricApi.create(geApiKey, context = application)
     private var db = AppDatabase.getInstance(application)
     private var prefs = PreferenceDataSource(application)
-    private var chargepointLoader: Job? = null
 
     val bottomSheetState: MutableLiveData<Int> by lazy {
         MutableLiveData<Int>()
@@ -69,7 +67,7 @@ class MapViewModel(application: Application, geApiKey: String) : AndroidViewMode
     }
     private val filters = getFilters(application, plugs, networks, chargeCards)
 
-    private val filtersWithValue: LiveData<List<FilterWithValue<out FilterValue>>> by lazy {
+    private val filtersWithValue: LiveData<FilterValues> by lazy {
         filtersWithValue(filters, filterValues)
     }
 
@@ -147,7 +145,7 @@ class MapViewModel(application: Application, geApiKey: String) : AndroidViewMode
             val callback = { _: Any? ->
                 val loc = location.value
                 val charger = chargerSparse.value
-                value = if (loc != null && charger != null && myLocationEnabled.value == true) {
+                value = if (loc != null && charger != null) {
                     distanceBetween(
                         loc.latitude,
                         loc.longitude,
@@ -158,7 +156,6 @@ class MapViewModel(application: Application, geApiKey: String) : AndroidViewMode
             }
             addSource(chargerSparse, callback)
             addSource(location, callback)
-            addSource(myLocationEnabled, callback)
         }
     }
     val location: MutableLiveData<LatLng> by lazy {
@@ -177,6 +174,21 @@ class MapViewModel(application: Application, geApiKey: String) : AndroidViewMode
             }
         }
     }
+    val filteredAvailability: MediatorLiveData<Resource<ChargeLocationStatus>> by lazy {
+        MediatorLiveData<Resource<ChargeLocationStatus>>().apply {
+            val callback = { _: Any? ->
+                val av = availability.value
+                val filters = filtersWithValue.value
+                if (av?.status == Status.SUCCESS && filters != null) {
+                    value = Resource.success(av.data!!.applyFilters(filters))
+                } else {
+                    value = av
+                }
+            }
+            addSource(availability, callback)
+            addSource(filtersWithValue, callback)
+        }
+    }
     val myLocationEnabled: MutableLiveData<Boolean> by lazy {
         MutableLiveData<Boolean>()
     }
@@ -196,13 +208,19 @@ class MapViewModel(application: Application, geApiKey: String) : AndroidViewMode
 
     val mapType: MutableLiveData<AnyMap.Type> by lazy {
         MutableLiveData<AnyMap.Type>().apply {
-            value = AnyMap.Type.NORMAL
+            value = prefs.mapType
+            observeForever {
+                prefs.mapType = it
+            }
         }
     }
 
     val mapTrafficEnabled: MutableLiveData<Boolean> by lazy {
         MutableLiveData<Boolean>().apply {
-            value = false
+            value = prefs.mapTrafficEnabled
+            observeForever {
+                prefs.mapTrafficEnabled = it
+            }
         }
     }
 
@@ -260,39 +278,41 @@ class MapViewModel(application: Application, geApiKey: String) : AndroidViewMode
         loadChargepoints(pos, filters)
     }
 
-    private fun loadChargepoints(
-        mapPosition: MapPosition,
-        filters: List<FilterWithValue<out FilterValue>>
-    ) {
-        chargepointLoader?.cancel()
+    private var chargepointLoader =
+        throttleLatest(500L, viewModelScope) { data: Pair<MapPosition, FilterValues> ->
+            chargepoints.value = Resource.loading(chargepoints.value?.data)
+            filteredConnectors.value = null
+            filteredChargeCards.value = null
 
-        chargepoints.value = Resource.loading(chargepoints.value?.data)
-        filteredConnectors.value = null
-        filteredChargeCards.value = null
-        val bounds = mapPosition.bounds
-        val zoom = mapPosition.zoom
-        chargepointLoader = viewModelScope.launch {
-            val result = getChargepointsWithFilters(bounds, zoom, filters)
+            val mapPosition = data.first
+            val filters = data.second
+            val result = getChargepointsWithFilters(mapPosition.bounds, mapPosition.zoom, filters)
             filteredConnectors.value = result.second
             filteredChargeCards.value = result.third
             chargepoints.value = result.first
         }
+
+    private fun loadChargepoints(
+        mapPosition: MapPosition,
+        filters: FilterValues
+    ) {
+        chargepointLoader(Pair(mapPosition, filters))
     }
 
     private suspend fun getChargepointsWithFilters(
         bounds: LatLngBounds,
         zoom: Float,
-        filters: List<FilterWithValue<out FilterValue>>
+        filters: FilterValues
     ): Triple<Resource<List<ChargepointListItem>>, Set<String>?, Set<Long>?> {
-        val freecharging = getBooleanValue(filters, "freecharging")
-        val freeparking = getBooleanValue(filters, "freeparking")
-        val open247 = getBooleanValue(filters, "open_247")
-        val barrierfree = getBooleanValue(filters, "barrierfree")
-        val excludeFaults = getBooleanValue(filters, "exclude_faults")
-        val minPower = getSliderValue(filters, "min_power")
-        val minConnectors = getSliderValue(filters, "min_connectors")
+        val freecharging = filters.getBooleanValue("freecharging")
+        val freeparking = filters.getBooleanValue("freeparking")
+        val open247 = filters.getBooleanValue("open_247")
+        val barrierfree = filters.getBooleanValue("barrierfree")
+        val excludeFaults = filters.getBooleanValue("exclude_faults")
+        val minPower = filters.getSliderValue("min_power")
+        val minConnectors = filters.getSliderValue("min_connectors")
 
-        val connectorsVal = getMultipleChoiceValue(filters, "connectors")
+        val connectorsVal = filters.getMultipleChoiceValue("connectors")
         if (connectorsVal.values.isEmpty() && !connectorsVal.all) {
             // no connectors chosen
             return Triple(Resource.success(emptyList()), null, null)
@@ -300,7 +320,7 @@ class MapViewModel(application: Application, geApiKey: String) : AndroidViewMode
         val connectors = formatMultipleChoice(connectorsVal)
         val filteredConnectors = if (connectorsVal.all) null else connectorsVal.values
 
-        val chargeCardsVal = getMultipleChoiceValue(filters, "chargecards")
+        val chargeCardsVal = filters.getMultipleChoiceValue("chargecards")
         if (chargeCardsVal.values.isEmpty() && !chargeCardsVal.all) {
             // no chargeCards chosen
             return Triple(Resource.success(emptyList()), filteredConnectors, null)
@@ -309,14 +329,14 @@ class MapViewModel(application: Application, geApiKey: String) : AndroidViewMode
         val filteredChargeCards =
             if (chargeCardsVal.all) null else chargeCardsVal.values.map { it.toLong() }.toSet()
 
-        val networksVal = getMultipleChoiceValue(filters, "networks")
+        val networksVal = filters.getMultipleChoiceValue("networks")
         if (networksVal.values.isEmpty() && !networksVal.all) {
             // no networks chosen
             return Triple(Resource.success(emptyList()), filteredConnectors, filteredChargeCards)
         }
         val networks = formatMultipleChoice(networksVal)
 
-        val categoriesVal = getMultipleChoiceValue(filters, "categories")
+        val categoriesVal = filters.getMultipleChoiceValue("categories")
         if (categoriesVal.values.isEmpty() && !categoriesVal.all) {
             // no categories chosen
             return Triple(Resource.success(emptyList()), filteredConnectors, filteredChargeCards)
@@ -398,26 +418,6 @@ class MapViewModel(application: Application, geApiKey: String) : AndroidViewMode
     private fun formatMultipleChoice(connectorsVal: MultipleChoiceFilterValue) =
         if (connectorsVal.all) null else connectorsVal.values.joinToString(",")
 
-    private fun getBooleanValue(
-        filters: List<FilterWithValue<out FilterValue>>,
-        key: String
-    ) = (filters.find { it.value.key == key }!!.value as BooleanFilterValue).value
-
-    private fun getSliderValue(
-        filters: List<FilterWithValue<out FilterValue>>,
-        key: String
-    ) = (filters.find { it.value.key == key }!!.value as SliderFilterValue).value
-
-    private fun getMultipleChoiceFilter(
-        filters: List<FilterWithValue<out FilterValue>>,
-        key: String
-    ) = filters.find { it.value.key == key }!!.filter as MultipleChoiceFilter
-
-    private fun getMultipleChoiceValue(
-        filters: List<FilterWithValue<out FilterValue>>,
-        key: String
-    ) = filters.find { it.value.key == key }!!.value as MultipleChoiceFilterValue
-
     private suspend fun loadAvailability(charger: ChargeLocation) {
         availability.value = Resource.loading(null)
         availability.value = getAvailability(charger)
@@ -425,24 +425,41 @@ class MapViewModel(application: Application, geApiKey: String) : AndroidViewMode
 
     private fun loadChargerDetails(charger: ChargeLocation) {
         chargerDetails.value = Resource.loading(null)
-        api.getChargepointDetail(charger.id).enqueue(object :
-            Callback<ChargepointList> {
-            override fun onFailure(call: Call<ChargepointList>, t: Throwable) {
-                chargerDetails.value = Resource.error(t.message, null)
-                t.printStackTrace()
-            }
-
-            override fun onResponse(
-                call: Call<ChargepointList>,
-                response: Response<ChargepointList>
-            ) {
+        viewModelScope.launch {
+            try {
+                val response = api.getChargepointDetail(charger.id)
                 if (!response.isSuccessful || response.body()!!.status != "ok") {
                     chargerDetails.value = Resource.error(response.message(), null)
                 } else {
                     chargerDetails.value =
                         Resource.success(response.body()!!.chargelocations[0] as ChargeLocation)
                 }
+            } catch (e: IOException) {
+                chargerDetails.value = Resource.error(e.message, null)
+                e.printStackTrace()
             }
-        })
+        }
+    }
+
+    fun loadChargerById(chargerId: Long) {
+        chargerDetails.value = Resource.loading(null)
+        chargerSparse.value = null
+        viewModelScope.launch {
+            val response = api.getChargepointDetail(chargerId)
+            if (!response.isSuccessful || response.body()!!.status != "ok") {
+                chargerSparse.value = null
+                chargerDetails.value = Resource.error(response.message(), null)
+            } else {
+                val chargers = response.body()!!.chargelocations
+                    if (chargers.isNotEmpty()) {
+                        val charger = chargers[0] as ChargeLocation
+                chargerDetails.value =
+                    Resource.success(charger)
+                chargerSparse.value = charger} else {
+                        chargerDetails.value = Resource.error("not found", null)
+                        chargerSparse.value = null
+                    }
+            }
+        }
     }
 }

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

@@ -3,6 +3,10 @@ package net.vonforst.evmap.viewmodel
 import androidx.annotation.MainThread
 import androidx.annotation.Nullable
 import androidx.lifecycle.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 import java.util.concurrent.atomic.AtomicBoolean
 
 
@@ -63,4 +67,27 @@ class SingleLiveEvent<T> : MutableLiveData<T>() {
     fun call() {
         value = null
     }
+}
+
+fun <T> throttleLatest(
+    skipMs: Long = 300L,
+    coroutineScope: CoroutineScope,
+    destinationFunction: suspend (T) -> Unit
+): (T) -> Unit {
+    var throttleJob: Job? = null
+    var waitingParam: T? = null
+    return { param: T ->
+        if (throttleJob?.isCompleted != false) {
+            throttleJob = coroutineScope.launch {
+                destinationFunction(param)
+                delay(skipMs)
+                waitingParam?.let { wParam ->
+                    waitingParam = null
+                    destinationFunction(wParam)
+                }
+            }
+        } else {
+            waitingParam = param
+        }
+    }
 }

app/src/main/res/drawable/android_auto.xml

@@ -0,0 +1,42 @@
+<vector android:height="45.9264dp"
+    android:viewportHeight="480"
+    android:viewportWidth="501.334"
+    android:width="48dp"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    xmlns:android="http://schemas.android.com/apk/res/android">
+    <path
+        android:fillColor="#03a9f4"
+        android:fillType="evenOdd"
+        android:pathData="m32,416c-17.68,0 -32,-14.32 -32,-32 0,-5.814 1.547,-11.28 4.267,-15.974l202.667,-352c5.52,-9.573 15.866,-16.026 27.733,-16.026s22.213,6.453 27.733,16.026l202.667,352c2.72,4.694 4.267,10.16 4.267,15.974 0,17.68 -14.32,32 -32,32z" />
+    <path
+        android:fillType="evenOdd"
+        android:pathData="m234.667,149.333v266.667h266.667z">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:endX="459.19528"
+                android:endY="410.17865"
+                android:startX="177.41093"
+                android:startY="250.14912"
+                android:type="linear">
+                <item
+                    android:color="#331A237E"
+                    android:offset="0" />
+                <item
+                    android:color="#051A237E"
+                    android:offset="1" />
+            </gradient>
+        </aapt:attr>
+    </path>
+    <path
+        android:fillColor="#039be5"
+        android:fillType="evenOdd"
+        android:pathData="m206.934,16.026 l-202.667,352c-2.72,4.694 -4.267,10.16 -4.267,15.974 0,17.68 14.32,32 32,32h202.667v-416c-11.867,0 -22.213,6.453 -27.733,16.026z" />
+    <path
+        android:fillColor="#f1f1f1"
+        android:fillType="evenOdd"
+        android:pathData="m234.667,149.333 l181.333,320 -10.666,10.667 -170.667,-64 -170.667,64 -10.666,-10.667z" />
+    <path
+        android:fillColor="#e1e1e1"
+        android:fillType="evenOdd"
+        android:pathData="m234.667,149.333 l181.333,320 -10.666,10.667 -170.667,-64" />
+</vector>

app/src/main/res/drawable/circle_bg_logo.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item>
+        <shape android:shape="oval">
+            <solid android:color="#66FFFFFF" />
+            <size
+                android:height="24dp"
+                android:width="24dp" />
+        </shape>
+    </item>
+    <item android:drawable="?attr/controlBackground" />
+</layer-list>

app/src/main/res/drawable/ic_navigation.xml

@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24"
+    android:tint="?attr/colorControlNormal">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M12,2L4.5,20.29l0.71,0.71L12,18l6.79,3 0.71,-0.71z" />
+</vector>

app/src/main/res/drawable/ic_verified.xml

@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M23,12l-2.44,-2.79l0.34,-3.69l-3.61,-0.82L15.4,1.5L12,2.96L8.6,1.5L6.71,4.69L3.1,5.5L3.44,9.2L1,12l2.44,2.79l-0.34,3.7l3.61,0.82L8.6,22.5l3.4,-1.47l3.4,1.46l1.89,-3.19l3.61,-0.82l-0.34,-3.69L23,12zM10.09,16.72l-3.8,-3.81l1.48,-1.48l2.32,2.33l5.85,-5.87l1.48,1.48L10.09,16.72z" />
+</vector>

app/src/main/res/layout/detail_view.xml

@@ -35,6 +35,10 @@
             name="availability"
             type="Resource<ChargeLocationStatus>" />
 
+        <variable
+            name="filteredAvailability"
+            type="Resource&lt;ChargeLocationStatus&gt;" />
+
         <variable
             name="chargeCards"
             type="java.util.Map&lt;Long, ChargeCard&gt;" />
@@ -66,14 +70,16 @@
 
             <TextView
                 android:id="@+id/txtName"
-                android:layout_width="0dp"
+                android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
-                android:layout_marginEnd="8dp"
+                android:layout_marginEnd="30dp"
                 android:ellipsize="end"
                 android:maxLines="1"
                 android:text="@{charger.data.name}"
                 android:textAppearance="@style/TextAppearance.MaterialComponents.Body1"
+                app:layout_constrainedWidth="true"
                 app:layout_constraintEnd_toStartOf="@+id/txtAvailability"
+                app:layout_constraintHorizontal_bias="0.0"
                 app:layout_constraintStart_toStartOf="@+id/guideline"
                 app:layout_constraintTop_toTopOf="parent"
                 tools:text="Parkhaus" />
@@ -116,7 +122,7 @@
                 android:gravity="end"
                 android:maxLines="1"
                 android:padding="2dp"
-                android:text="@{String.format(&quot;%s/%d&quot;, BindingAdaptersKt.availabilityText(BindingAdaptersKt.flatten(availability.data.status.values())), charger.data.totalChargepoints)}"
+                android:text="@{String.format(&quot;%s/%d&quot;, BindingAdaptersKt.availabilityText(BindingAdaptersKt.flatten(filteredAvailability.data.status.values())), filteredAvailability.data.totalChargepoints)}"
                 android:textAppearance="@style/TextAppearance.MaterialComponents.Caption"
                 android:textColor="@android:color/white"
                 app:backgroundTintAvailability="@{BindingAdaptersKt.flatten(availability.data.status.values())}"
@@ -308,6 +314,23 @@
                 app:layout_constraintStart_toStartOf="@+id/guideline"
                 app:layout_constraintTop_toBottomOf="@+id/textView13" />
 
+            <ImageView
+                android:id="@+id/imgVerified"
+                android:layout_width="18dp"
+                android:layout_height="18dp"
+                android:layout_marginStart="4dp"
+                android:layout_marginTop="2dp"
+                android:layout_marginBottom="2dp"
+                android:contentDescription="@string/verified"
+                android:tooltipText="@string/verified_desc"
+                app:goneUnless="@{ charger.data.verified &amp;&amp; charger.data.faultReport == null }"
+                app:layout_constraintBottom_toBottomOf="@+id/txtName"
+                app:layout_constraintStart_toEndOf="@+id/txtName"
+                app:layout_constraintTop_toTopOf="@+id/txtName"
+                app:srcCompat="@drawable/ic_verified"
+                app:tint="@color/available"
+                tools:targetApi="o" />
+
         </androidx.constraintlayout.widget.ConstraintLayout>
 
     </androidx.cardview.widget.CardView>

app/src/main/res/layout/dialog_update_060_androidauto.xml

@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:maxWidth="200dp"
+    android:orientation="vertical">
+
+    <ScrollView
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1">
+
+        <androidx.constraintlayout.widget.ConstraintLayout
+            android:id="@+id/linearLayout4"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical">
+
+            <FrameLayout
+                android:id="@+id/topPanel"
+                android:layout_width="0dp"
+                android:layout_height="88dp"
+                android:background="@color/android_auto_accent"
+                app:layout_constraintEnd_toEndOf="parent"
+                app:layout_constraintStart_toStartOf="parent"
+                app:layout_constraintTop_toTopOf="parent">
+
+                <ImageView
+                    android:id="@+id/imageView4"
+                    android:layout_width="72dp"
+                    android:layout_height="72dp"
+                    android:layout_gravity="center"
+                    android:background="@drawable/circle_bg_logo"
+                    android:scaleType="center"
+                    app:srcCompat="@drawable/android_auto" />
+            </FrameLayout>
+
+            <TextView
+                android:id="@+id/welcomeTitle"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_marginStart="16dp"
+                android:layout_marginTop="16dp"
+                android:layout_marginEnd="16dp"
+                android:text="@string/update_060_androidauto_title"
+                android:textAppearance="@style/TextAppearance.MaterialComponents.Headline6"
+                app:layout_constraintEnd_toEndOf="parent"
+                app:layout_constraintStart_toStartOf="parent"
+                app:layout_constraintTop_toBottomOf="@+id/topPanel" />
+
+            <TextView
+                android:id="@+id/welcomeText1"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_marginStart="16dp"
+                android:layout_marginTop="8dp"
+                android:layout_marginEnd="16dp"
+                android:text="@string/update_060_androidauto_text"
+                android:textAppearance="@style/TextAppearance.MaterialComponents.Body2"
+                app:layout_constraintEnd_toEndOf="parent"
+                app:layout_constraintStart_toStartOf="parent"
+                app:layout_constraintTop_toBottomOf="@+id/welcomeTitle" />
+
+
+            <ImageView
+                android:id="@+id/icon1"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_marginStart="32dp"
+                android:layout_marginTop="16dp"
+                android:layout_marginEnd="32dp"
+                android:adjustViewBounds="true"
+                android:scaleType="fitCenter"
+                app:layout_constraintEnd_toEndOf="parent"
+                app:layout_constraintStart_toStartOf="parent"
+                app:layout_constraintTop_toBottomOf="@+id/welcomeText1"
+                app:srcCompat="@drawable/android_auto_screenshot" />
+
+        </androidx.constraintlayout.widget.ConstraintLayout>
+    </ScrollView>
+
+    <Button
+        android:id="@+id/btnOk"
+        style="@style/Widget.MaterialComponents.Button.TextButton.Dialog"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="end"
+        android:layout_marginEnd="16dp"
+        android:layout_marginBottom="8dp"
+        android:text="@string/ok" />
+
+</LinearLayout>

app/src/main/res/layout/fragment_map.xml

@@ -63,7 +63,8 @@
                     <TextView
                         android:id="@+id/search"
                         android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
+                        android:layout_height="match_parent"
+                        android:gravity="center_vertical"
                         android:text="@string/search"
                         android:textAppearance="@style/TextAppearance.MaterialComponents.Subtitle1"
                         android:textColor="?android:textColorSecondary" />
@@ -139,6 +140,7 @@
                 layout="@layout/detail_view"
                 app:charger="@{vm.charger}"
                 app:availability="@{vm.availability}"
+                app:filteredAvailability="@{vm.filteredAvailability}"
                 app:chargeCards="@{vm.chargeCardMap}"
                 app:filteredChargeCards="@{vm.filteredChargeCards}"
                 app:distance="@{vm.chargerDistance}"

app/src/main/res/navigation/nav_graph.xml

@@ -34,6 +34,9 @@
         <action
             android:id="@+id/action_map_to_welcome"
             app:destination="@id/welcome" />
+        <action
+            android:id="@+id/action_map_to_update_060_androidauto"
+            app:destination="@id/update_060_androidauto" />
     </fragment>
     <fragment
         android:id="@+id/about"
@@ -83,6 +86,11 @@
         android:name="net.vonforst.evmap.fragment.WelcomeDialogFragment"
         android:label="@string/welcome_to_evmap"
         tools:layout="@layout/dialog_welcome" />
+    <dialog
+        android:id="@+id/update_060_androidauto"
+        android:name="net.vonforst.evmap.fragment.updatedialogs.Update060AndroidAutoDialogFramgent"
+        android:label="@string/welcome_to_evmap"
+        tools:layout="@layout/dialog_update_060_androidauto" />
     <chrome
         android:id="@+id/report_new_charger"
         app:url="@string/report_new_charger_url" />

app/src/main/res/values-de/strings.xml

@@ -37,7 +37,7 @@
     <string name="settings_ui">Oberfläche</string>
     <string name="settings_map">Karte</string>
     <string name="copyright">Copyright</string>
-    <string name="copyright_summary">©2020 Johan von Forstner</string>
+    <string name="copyright_summary">©2020–2021 Johan von Forstner</string>
     <string name="other">Sonstiges</string>
     <string name="privacy">Datenschutzerklärung</string>
     <string name="fav_add">Zu Favoriten hinzufügen</string>
@@ -156,4 +156,9 @@
         <item quantity="one">%d kompatibler Ladetarif</item>
         <item quantity="other">%d kompatible Ladetarife</item>
     </plurals>
+    <string name="navigate">Navigieren</string>
+    <string name="verified">Verifiziert</string>
+    <string name="verified_desc">Verifiziert von der GoingElectric.de Community – nicht zwangsläufig auch aktuell verfügbar.</string>
+    <string name="update_060_androidauto_title">Neues Update: Android Auto</string>
+    <string name="update_060_androidauto_text">Mit diesem neuen Update kannst du EVMap nutzen, um Ladestationen in der Nähe auf unterstützen Autos direkt aus Android Auto zu finden. Öffne einfach die EVMap-App aus dem Menü von Android Auto.</string>
 </resources>

app/src/main/res/values/colors.xml

@@ -14,4 +14,5 @@
     <color name="unknown">#9e9e9e</color>
     <color name="status_bar_scrim">#C3000000</color>
     <color name="delete_red">#f44336</color>
+    <color name="android_auto_accent">#039be5</color>
 </resources>

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

@@ -36,7 +36,7 @@
     <string name="settings_ui">User Interface</string>
     <string name="settings_map">Map</string>
     <string name="copyright">Copyright</string>
-    <string name="copyright_summary">©2020 Johan von Forstner</string>
+    <string name="copyright_summary">©2020–2021 Johan von Forstner</string>
     <string name="other">Other</string>
     <string name="privacy">Privacy Notice</string>
     <string name="fav_add">Add to favorites</string>
@@ -155,4 +155,9 @@
         <item quantity="one">%d compatible payment method</item>
         <item quantity="other">%d compatible payment methods</item>
     </plurals>
+    <string name="navigate">Navigate</string>
+    <string name="verified">verified</string>
+    <string name="verified_desc">Charger verified by a member at the GoingElectric.de community — not necessarily working right now.</string>
+    <string name="update_060_androidauto_title">New update: Android Auto</string>
+    <string name="update_060_androidauto_text">With this new update, you can also use EVMap to find nearby chargers from within Android Auto on supported cars. Simply select the EVMap app in the Android Auto menu.</string>
 </resources>

app/src/test/java/net/vonforst/evmap/api/UtilsTest.kt

@@ -1,12 +0,0 @@
-package net.vonforst.evmap.api
-
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-
-class UtilsTest {
-    @Test
-    fun testDistanceBetween() {
-        assertEquals(129412.71, distanceBetween(54.0, 9.0, 53.0, 8.0), 0.01)
-    }
-}

app/src/test/java/net/vonforst/evmap/api/availability/NewMotionAvailabilityDetectorTest.kt

@@ -66,8 +66,7 @@ class NewMotionAvailabilityDetectorTest {
     @Test
     fun apiTest() {
         for (chargepoint in listOf(2105L, 18284L)) {
-            val charger = api.getChargepointDetail(chargepoint)
-                .execute().body()!!
+            val charger = runBlocking { api.getChargepointDetail(chargepoint).body()!! }
                 .chargelocations[0] as ChargeLocation
             println(charger)
 

app/src/test/java/net/vonforst/evmap/api/goingelectric/GoingElectricApiTest.kt

@@ -53,7 +53,7 @@ class GoingElectricApiTest {
 
     @Test
     fun testLoadChargepointDetail() {
-        val response = api.getChargepointDetail(2105).execute()
+        val response = runBlocking { api.getChargepointDetail(2105) }
         assertTrue(response.isSuccessful)
         val body = response.body()!!
         assertEquals("ok", body.status)

app/src/test/java/net/vonforst/evmap/utils/LocationUtilsTest.kt

@@ -0,0 +1,12 @@
+package net.vonforst.evmap.utils
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+
+class LocationUtilsTest {
+    @Test
+    fun testDistanceBetween() {
+        assertEquals(129521.08, distanceBetween(54.0, 9.0, 53.0, 8.0), 0.01)
+    }
+}

fastlane/metadata/android/de-DE/changelogs/36.txt

@@ -0,0 +1,2 @@
+Verbesserungen:
+- Verschiedene Abstürze behoben

fastlane/metadata/android/de-DE/changelogs/39.txt

@@ -0,0 +1,10 @@
+Neue Features:
+- Kartenausschnitt folgt der aktuellen Position
+- Verfügbarkeitsanzeige in der Kartenansicht beinhaltet nur die per Filter gewählten Anschlüsse (z.B. nur CCS)
+- Links zu https://www.goingelectric.de/stromtankstellen können in EVMap geöffnet werden
+- Geteilte Standorte (z.B. aus Messenger-Apps) können in EVMap geöffnet werden
+
+Fehlerkorrekturen:
+- Filtereinstellungen wurden bei Umbenennen eines Filterprofils fälschlicherweise gelöscht
+- Ausgewählter Kartentyp (Satellit, Gelände, Standard) bleibt beim App-Neustart erhalten
+- Copyright-Jahr aktualisiert

fastlane/metadata/android/de-DE/changelogs/42.txt

@@ -0,0 +1,7 @@
+Neue Features:
+- Unterstützung für Android Auto
+- Von der GoingElectric.de-Community verifizierte Ladestationen werden markiert
+
+Verbesserungen:
+- Aktivierte Verkehrsdaten auf der Karte werden nach App-Neustart beibehalten
+- Abstürze behoben

fastlane/metadata/android/de-DE/full_description.txt

@@ -10,6 +10,7 @@ Funktionen:
 - Suche nach Orten
 - Erweiterte Filterfunktionen
 - Favoritenliste, auch mit Anzeige der Verfügbarkeit
+- Unterstützung für Android Auto
 - Keine nervige Werbung
 
 EVMap ist ein Open-Source-Projekt und unter https://github.com/johan12345/EVMap zu finden.

fastlane/metadata/android/en-US/changelogs/36.txt

@@ -0,0 +1,2 @@
+Improvements:
+- Fixed various crashes

fastlane/metadata/android/en-US/changelogs/39.txt

@@ -0,0 +1,10 @@
+New Features:
+- Map follows current location
+- Availability indicator in map view only shows currently filtered connectors (e.g. only CCS)
+- Links to https://www.goingelectric.de/stromtankstellen can be opened in EVMap
+- Shared locations (e.g. from messenger apps) can be opened in EVMap
+
+Bugfixes:
+- Filter settings would be deleted when renaming a saved filter profile
+- Selected map type (Default, Satellite, Terrain) will be kept across app restarts
+- Updated copyright year

fastlane/metadata/android/en-US/changelogs/42.txt

@@ -0,0 +1,7 @@
+New Features:
+- Android Auto support
+- Chargers verified by the GoingElectric.de community are marked
+
+Improvements:
+- Enabled traffic data on map is preserved after app restart
+- Fixed crashes

fastlane/metadata/android/en-US/full_description.txt

@@ -9,6 +9,7 @@ Features:
 - Search places
 - Favorites list, also with availability information
 - Advanced filtering options
+- Android Auto support
 - No ads, fully open source
 
 EVMap is an open source project and can be found at https://github.com/johan12345/EVMap.