Release 0.6.0

Add Android Auto information dialog
Show GoingElectric verified state
2025-12-26 16:47:47 -05:00 · 2021-04-05 22:52:34 +02:00 · 2021-04-05 22:42:26 +02:00 · 2021-04-05 22:01:52 +02:00 · 2021-04-05 21:22:44 +02:00 · 2021-04-05 21:14:16 +02:00
51 changed files with 1482 additions and 167 deletions
--- a/_img/screenshots/phone/11_android_auto_detail.png
+++ b/_img/screenshots/phone/11_android_auto_detail.png
--- a/_img/screenshots/phone/11_android_auto_map.png
+++ b/_img/screenshots/phone/11_android_auto_map.png
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -13,8 +13,8 @@ android {
        applicationId "net.vonforst.evmap"
        minSdkVersion 21
        targetSdkVersion 30
-        versionCode 39
-        versionName "0.5.0"
+        versionCode 42
+        versionName "0.6.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
@@ -119,6 +119,9 @@ 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 = '1f050d860f'
    implementation "com.github.johan12345.AnyMaps:anymaps-base:$anyMapsVersion"
--- a/app/src/google/AndroidManifest.xml
+++ b/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>
--- a/app/src/google/java/net/vonforst/evmap/auto/CarAppService.kt
+++ b/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
+    }
+}
--- a/app/src/google/java/net/vonforst/evmap/auto/CarLocationService.kt
+++ b/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()
+}
--- a/app/src/google/java/net/vonforst/evmap/auto/PermissionActivity.kt
+++ b/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)
+    }
+}
--- a/app/src/google/res/values-de/values.xml
+++ b/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>
--- a/app/src/google/res/values/styles.xml
+++ b/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>
--- a/app/src/google/res/values/values.xml
+++ b/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>
--- a/app/src/google/res/xml/automotive_app_desc.xml
+++ b/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>
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -48,12 +48,13 @@
                <data
                    android:scheme="https"
                    android:host="www.goingelectric.de"
-                    android:pathPrefix="/stromtankstellen/" />
+                    android:pathPattern="/stromtankstellen/..*/..*/..*/..*/" />

                <category android:name="android.intent.category.DEFAULT" />
                <category android:name="android.intent.category.BROWSABLE" />
            </intent-filter>
        </activity>
+
    </application>

 </manifest>
--- a/app/src/main/java/net/vonforst/evmap/MapsActivity.kt
+++ b/app/src/main/java/net/vonforst/evmap/MapsActivity.kt
@@ -23,6 +23,9 @@ 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 {
@@ -92,6 +95,18 @@ class MapsActivity : AppCompatActivity() {
                    .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()
        }
    }

--- a/app/src/main/java/net/vonforst/evmap/api/Utils.kt
+++ b/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
+    }
--- a/app/src/main/java/net/vonforst/evmap/api/availability/NewMotionAvailabilityDetector.kt
+++ b/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
--- a/app/src/main/java/net/vonforst/evmap/api/goingelectric/GoingElectricApi.kt
+++ b/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>
--- a/app/src/main/java/net/vonforst/evmap/api/goingelectric/GoingElectricModel.kt
+++ b/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)
+        }
    }
 }

--- a/app/src/main/java/net/vonforst/evmap/fragment/MapFragment.kt
+++ b/app/src/main/java/net/vonforst/evmap/fragment/MapFragment.kt
@@ -228,12 +228,19 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
            (requireActivity() as MapsActivity).appBarConfiguration
        )

-        if (!PreferenceDataSource(requireContext()).welcomeDialogShown) {
+        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
+            }
        }
    }

@@ -429,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 {
@@ -478,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)
                )
            )
        }
@@ -492,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)
@@ -505,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
@@ -730,6 +724,7 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
            }
        }
        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)
@@ -863,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)
                )
            )
        }
@@ -880,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)
@@ -895,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))
@@ -1122,6 +1117,14 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
                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() {
@@ -1149,7 +1152,9 @@ class MapFragment : Fragment(), OnMapReadyCallback, MapsActivity.FragmentCallbac
    }

    private fun removeLocationUpdates() {
-        LocationServices.FusedLocationApi.removeLocationUpdates(locationClient, this)
+        if (locationClient.isConnected) {
+            LocationServices.FusedLocationApi.removeLocationUpdates(locationClient, this)
+        }
    }

    override fun onConnectionSuspended() {
--- a/app/src/main/java/net/vonforst/evmap/fragment/WelcomeDialogFragment.kt
+++ b/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()
        }
    }
--- a/app/src/main/java/net/vonforst/evmap/fragment/updatedialogs/Update060AndroidAutoDialogFramgent.kt
+++ b/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
+        )
+    }
+}
--- a/app/src/main/java/net/vonforst/evmap/storage/ChargeLocationsDao.kt
+++ b/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>
 }
--- a/app/src/main/java/net/vonforst/evmap/storage/PreferenceDataSource.kt
+++ b/app/src/main/java/net/vonforst/evmap/storage/PreferenceDataSource.kt
@@ -80,9 +80,21 @@ class PreferenceDataSource(val context: Context) {
            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()
+        }
 }
--- a/app/src/main/java/net/vonforst/evmap/ui/BindingAdapters.kt
+++ b/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")
--- a/app/src/main/java/net/vonforst/evmap/ui/IconGenerators.kt
+++ b/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(),
--- a/app/src/main/java/net/vonforst/evmap/ui/MarkerUtils.kt
+++ b/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
--- a/app/src/main/java/net/vonforst/evmap/utils/LocationUtils.kt
+++ b/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
+}
--- a/app/src/main/java/net/vonforst/evmap/viewmodel/FavoritesViewModel.kt
+++ b/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) {
--- a/app/src/main/java/net/vonforst/evmap/viewmodel/FilterViewModel.kt
+++ b/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
--- a/app/src/main/java/net/vonforst/evmap/viewmodel/MapViewModel.kt
+++ b/app/src/main/java/net/vonforst/evmap/viewmodel/MapViewModel.kt
@@ -9,13 +9,13 @@ import kotlinx.coroutines.Dispatchers
 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)
@@ -217,7 +217,10 @@ class MapViewModel(application: Application, geApiKey: String) : AndroidViewMode

    val mapTrafficEnabled: MutableLiveData<Boolean> by lazy {
        MutableLiveData<Boolean>().apply {
-            value = false
+            value = prefs.mapTrafficEnabled
+            observeForever {
+                prefs.mapTrafficEnabled = it
+            }
        }
    }

@@ -422,52 +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
-        api.getChargepointDetail(chargerId).enqueue(object :
-            Callback<ChargepointList> {
-            override fun onFailure(call: Call<ChargepointList>, t: Throwable) {
+        viewModelScope.launch {
+            val response = api.getChargepointDetail(chargerId)
+            if (!response.isSuccessful || response.body()!!.status != "ok") {
                chargerSparse.value = null
-                chargerDetails.value = Resource.error(t.message, null)
-                t.printStackTrace()
+                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
+                    }
            }
-
-            override fun onResponse(
-                call: Call<ChargepointList>,
-                response: Response<ChargepointList>
-            ) {
-                if (!response.isSuccessful || response.body()!!.status != "ok") {
-                    chargerDetails.value = Resource.error(response.message(), null)
-                    chargerSparse.value = null
-                } else {
-                    val charger = response.body()!!.chargelocations[0] as ChargeLocation
-                    chargerDetails.value =
-                        Resource.success(charger)
-                    chargerSparse.value = charger
-                }
-            }
-        })
+        }
    }
 }
--- a/app/src/main/res/drawable-nodpi/android_auto_screenshot.png
+++ b/app/src/main/res/drawable-nodpi/android_auto_screenshot.png
--- a/app/src/main/res/drawable/android_auto.xml
+++ b/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>
--- a/app/src/main/res/drawable/circle_bg_logo.xml
+++ b/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>
--- a/app/src/main/res/drawable/ic_navigation.xml
+++ b/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>
--- a/app/src/main/res/drawable/ic_verified.xml
+++ b/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>
--- a/app/src/main/res/layout/detail_view.xml
+++ b/app/src/main/res/layout/detail_view.xml
@@ -70,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" />
@@ -312,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>
--- a/app/src/main/res/layout/dialog_update_060_androidauto.xml
+++ b/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>
--- a/app/src/main/res/layout/fragment_map.xml
+++ b/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" />
--- a/app/src/main/res/navigation/nav_graph.xml
+++ b/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" />
--- a/app/src/main/res/values-de/strings.xml
+++ b/app/src/main/res/values-de/strings.xml
@@ -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>
--- a/app/src/main/res/values/colors.xml
+++ b/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>
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -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>
--- a/app/src/test/java/net/vonforst/evmap/api/UtilsTest.kt
+++ b/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)
-    }
-}
--- a/app/src/test/java/net/vonforst/evmap/api/availability/NewMotionAvailabilityDetectorTest.kt
+++ b/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)

--- a/app/src/test/java/net/vonforst/evmap/api/goingelectric/GoingElectricApiTest.kt
+++ b/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)
--- a/app/src/test/java/net/vonforst/evmap/utils/LocationUtilsTest.kt
+++ b/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)
+    }
+}
--- a/fastlane/metadata/android/de-DE/changelogs/42.txt
+++ b/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
--- a/fastlane/metadata/android/de-DE/full_description.txt
+++ b/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.
--- a/fastlane/metadata/android/de-DE/images/phoneScreenshots/3_de-DE.png
+++ b/fastlane/metadata/android/de-DE/images/phoneScreenshots/3_de-DE.png
--- a/fastlane/metadata/android/de-DE/images/phoneScreenshots/4_de-DE.png
+++ b/fastlane/metadata/android/de-DE/images/phoneScreenshots/4_de-DE.png
--- a/fastlane/metadata/android/en-US/changelogs/42.txt
+++ b/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
--- a/fastlane/metadata/android/en-US/full_description.txt
+++ b/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.
Author	SHA1	Message	Date
johan12345	6aa8a3d7a2	Release 0.6.0	2021-04-05 22:52:34 +02:00
johan12345	887702b729	Add Android Auto information dialog	2021-04-05 22:42:26 +02:00
johan12345	0417c4f1ae	Show GoingElectric verified state	2021-04-05 22:01:52 +02:00
johan12345	0b95785f49	add Android Auto screenshots	2021-04-05 21:22:44 +02:00
Johan von Forstner	2772e9ad4d	Merge pull request #63 from johan12345/android-auto Android Auto support	2021-04-05 21:14:16 +02:00
johan12345	8a16fa3a5c	Android Auto: update car app library	2021-04-05 21:13:53 +02:00
johan12345	84d3127675	Android Auto: migrate to new version of car app library	2021-04-05 21:13:53 +02:00
Johan von Forstner	e684fbc0dc	Android Auto: avoid crash after maximum number of updates is reached	2021-04-05 21:13:53 +02:00
Johan von Forstner	bb92d26be9	Android Auto: display fault reports	2021-04-05 21:13:53 +02:00
Johan von Forstner	f74bb8e4a5	Android Auto: fix typo for cost string	2021-04-05 21:13:53 +02:00
Johan von Forstner	5d72be8e87	Android Auto: Add charger icon	2021-04-05 21:13:53 +02:00
Johan von Forstner	04e6f63cd7	Android Auto: Add permission screen, add selection between nearby and favorites	2021-04-05 21:13:53 +02:00
Johan von Forstner	ffb0b77f37	Android Auto: implement detail view to app link	2021-04-05 21:13:53 +02:00
Johan von Forstner	9d621c3149	Android Auto: add more information in detail view	2021-04-05 21:13:52 +02:00
Johan von Forstner	7126c3c67c	Android Auto: add detail view with button to navigate	2021-04-05 21:13:52 +02:00
Johan von Forstner	62197f99cb	GoingElectricApi: use coroutines for loading charger details	2021-04-05 21:13:51 +02:00
johan12345	db68452f55	Android Auto: initial implementation	2021-04-05 21:13:51 +02:00
johan12345	9ec5010495	NewMotionAvailabilityDetector: fail silently for unknown connector types	2021-04-05 21:03:56 +02:00
johan12345	5978b90da2	fix crash if charger ID was not found	2021-04-05 21:00:25 +02:00
johan12345	223d9d394f	fix crash if location client is not connected	2021-04-05 20:58:31 +02:00
johan12345	38b82abc48	Preserve map traffic enabled state across app restarts like map type, which was implemented in `6cb682f0`	2021-04-05 20:56:03 +02:00
johan12345	aade4ec488	increase touch target size for search bar	2021-04-05 20:51:33 +02:00
johan12345	38a02f8304	use more restrictive pattern for intent-filter For example edit button (url ending with /edit/) would try to open in EVMap	2021-04-05 20:47:50 +02:00
johan12345	8f7e1c5629	disable location following when search result is shown	2021-04-05 19:11:09 +02:00