CarInfo and CarSensors Osrm

common/data/src/main/java/com/kouros/navigation/data/Data.kt

@@ -174,6 +174,8 @@ object Constants {
 
     const val AVOID_TOLLWAY = "AvoidTollway"
 
+    const val ROUTING_ENGINE = "RoutingEngine"
+
     const val NEXT_STEP_THRESHOLD = 100.0
 
     const val MAXIMAL_SNAP_CORRECTION = 50.0
@@ -182,7 +184,6 @@ object Constants {
 
     const val DESTINATION_ARRIVAL_DISTANCE = 40.0
 
-    val ROUTE_ENGINE = RouteEngine.VALHALLA.name
 }
 
 

common/data/src/main/java/com/kouros/navigation/data/NavigationRepository.kt

@@ -30,8 +30,6 @@ import kotlinx.serialization.json.Json
 
 abstract class NavigationRepository {
 
-    private val placesUrl = "https://kouros-online.de/maps/placespwd";
-
     private val nominatimUrl = "https://nominatim.openstreetmap.org/"
 
 
@@ -58,27 +56,6 @@ abstract class NavigationRepository {
         return fetchUrl("${nominatimUrl}reverse?lat=${location.latitude}&lon=${location.longitude}&format=jsonv2&addressdetails=true&countrycodes=de", false)
     }
 
-    fun getPlaces(): List<Place> {
-        val places: MutableList<Place> = ArrayList()
-        val placesStr = fetchUrl(placesUrl, true)
-        val jArray = JSONArray(placesStr)
-        for (i in 0..<jArray.length()) {
-            val json = jArray.getJSONObject(i)
-            val place = Place(
-                json.getString("id").toLong(),
-                json.getString("name"),
-                category = json.getString("category"),
-                latitude = json.getDouble("latitude"),
-                longitude = json.getDouble("longitude"),
-                postalCode = json.getString("postalCode"),
-                city = json.getString("city"),
-                street = json.getString("street"),
-            )
-            places.add(place)
-        }
-        return places
-    }
-
     fun fetchUrl(url: String, authenticator : Boolean): String {
         try {
             if (authenticator) {

common/data/src/main/java/com/kouros/navigation/data/Route.kt

@@ -2,7 +2,6 @@ package com.kouros.navigation.data
 
 import android.location.Location
 import com.google.gson.GsonBuilder
-import com.kouros.navigation.data.Constants.ROUTE_ENGINE
 import com.kouros.navigation.data.osrm.OsrmResponse
 import com.kouros.navigation.data.osrm.OsrmRoute
 import com.kouros.navigation.data.route.Leg
@@ -11,8 +10,6 @@ import com.kouros.navigation.data.route.Summary
 import com.kouros.navigation.data.valhalla.ValhallaResponse
 import com.kouros.navigation.data.valhalla.ValhallaRoute
 import com.kouros.navigation.utils.GeoUtils.createCenterLocation
-import com.kouros.navigation.utils.NavigationUtils.getIntKeyValue
-import com.kouros.navigation.utils.NavigationUtils.getRouteEngine
 import com.kouros.navigation.utils.location
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonElement

common/data/src/main/java/com/kouros/navigation/data/osrm/OsrmRepository.kt

@@ -4,9 +4,7 @@ import android.location.Location
 import com.kouros.navigation.data.NavigationRepository
 import com.kouros.navigation.data.SearchFilter
 
-//private const val routeUrl = "https://kouros-online.de/osrm/route/v1/driving/"
-
-private const val routeUrl = "http://192.168.1.37:5000/route/v1/driving/"
+private const val routeUrl = "https://kouros-online.de/osrm/route/v1/driving/"
 
 class OsrmRepository : NavigationRepository() {
     override fun getRoute(

common/data/src/main/java/com/kouros/navigation/data/osrm/OsrmRoute.kt

@@ -66,17 +66,34 @@ class OsrmRoute {
             ManeuverType.continue_.value -> {
                 newType = androidx.car.app.navigation.model.Maneuver.TYPE_STRAIGHT
             }
-            ManeuverType.turn.value -> {
+            ManeuverType.turn.value,
+            ManeuverType.endOfRoad.value -> {
                 if (maneuver.modifier == "right") {
                     newType = androidx.car.app.navigation.model.Maneuver.TYPE_TURN_NORMAL_RIGHT
                 }
             }
-            ManeuverType.turn.value -> {
+            ManeuverType.turn.value,
+            ManeuverType.endOfRoad.value,
+            ManeuverType.onRamp.value
+                    -> {
                 if (maneuver.modifier == "left") {
                     newType = androidx.car.app.navigation.model.Maneuver.TYPE_TURN_NORMAL_LEFT
                 }
             }
+            ManeuverType.fork.value
+                -> {
+                if (maneuver.modifier == "slight left") {
+                    newType = androidx.car.app.navigation.model.Maneuver.TYPE_TURN_SLIGHT_LEFT
+                }
+            }
+            ManeuverType.fork.value
+                -> {
+                if (maneuver.modifier == "slight right") {
+                    newType = androidx.car.app.navigation.model.Maneuver.TYPE_TURN_SLIGHT_RIGHT
+                }
+            }
         }
+
         return newType
     }
 }

common/data/src/main/java/com/kouros/navigation/data/overpass/Overpass.kt

@@ -64,18 +64,20 @@ class Overpass {
     }
 
     fun overpassApi(httpURLConnection: HttpURLConnection, searchQuery: String) : List<Elements> {
-        val outputStreamWriter = OutputStreamWriter(httpURLConnection.outputStream)
-        outputStreamWriter.write(searchQuery)
-        outputStreamWriter.flush()
-        // Check if the connection is successful
-        val responseCode = httpURLConnection.responseCode
-        if (responseCode == HttpURLConnection.HTTP_OK) {
-            val response = httpURLConnection.inputStream.bufferedReader()
-                .use { it.readText() }  // defaults to UTF-8
-            val gson = GsonBuilder().serializeNulls().create()
-            val overpass = gson.fromJson(response, Amenity::class.java)
-           // println("Overpass: $response")
-            return overpass.elements
+        try {
+            val outputStreamWriter = OutputStreamWriter(httpURLConnection.outputStream)
+            outputStreamWriter.write(searchQuery)
+            outputStreamWriter.flush()
+            // Check if the connection is successful
+            val responseCode = httpURLConnection.responseCode
+            if (responseCode == HttpURLConnection.HTTP_OK) {
+                val response = httpURLConnection.inputStream.bufferedReader()
+                    .use { it.readText() }  // defaults to UTF-8
+                val gson = GsonBuilder().serializeNulls().create()
+                val overpass = gson.fromJson(response, Amenity::class.java)
+                return overpass.elements
+            }
+        } catch (e: Exception) {
         }
         return emptyList()
     }

common/data/src/main/java/com/kouros/navigation/data/route/Step.kt

@@ -1,8 +1,12 @@
 package com.kouros.navigation.data.route
 
+import android.location.Location
+import com.kouros.navigation.utils.location
+
 data class Step(
     var index : Int = 0,
     var waypointIndex : Int = 0,
+    var wayPointLocation : Location =  location(0.0,0.0),
     val maneuver: Maneuver,
     val duration: Double = 0.0,
     val distance: Double = 0.0,

common/data/src/main/java/com/kouros/navigation/data/valhalla/ValhallaRoute.kt

@@ -1,8 +1,10 @@
 package com.kouros.navigation.data.valhalla
 
+import androidx.car.app.navigation.model.Maneuver
+import com.kouros.data.R
 import com.kouros.navigation.data.Route
 import com.kouros.navigation.data.route.Leg
-import com.kouros.navigation.data.route.Maneuver
+import com.kouros.navigation.data.route.Maneuver as RouteManeuver
 import com.kouros.navigation.data.route.Step
 import com.kouros.navigation.data.route.Summary
 import com.kouros.navigation.utils.GeoUtils.createLineStringCollection
@@ -18,10 +20,11 @@ class ValhallaRoute {
         val steps = mutableListOf<Step>()
         var stepIndex = 0
         routeJson.legs[0].maneuvers.forEach {
-            val maneuver = Maneuver(
+            val maneuver = RouteManeuver(
                 bearingBefore = 0,
                 bearingAfter = it.bearingAfter,
-                type = it.type,
+                //type = it.type,
+                type = convertType(it),
                 waypoints =waypoints.subList(it.beginShapeIndex, it.endShapeIndex+1)
             )
             var name = ""
@@ -40,4 +43,56 @@ class ValhallaRoute {
             .legs(listOf(leg))
             .waypoints(waypoints)
     }
+
+    fun convertType(maneuver: Maneuvers): Int {
+        var newType = 0
+        when (maneuver.type) {
+            ManeuverType.None.value -> {
+                newType = Maneuver.TYPE_STRAIGHT
+            }
+            ManeuverType.Destination.value,
+            ManeuverType.DestinationRight.value,
+            ManeuverType.DestinationLeft.value,
+                -> {
+                newType = Maneuver.TYPE_DESTINATION
+            }
+
+            ManeuverType.Right.value -> {
+                newType = Maneuver.TYPE_TURN_NORMAL_RIGHT
+            }
+
+            ManeuverType.Left.value -> {
+                newType = Maneuver.TYPE_TURN_NORMAL_LEFT
+            }
+
+            ManeuverType.RampRight.value -> {
+                newType = Maneuver.TYPE_OFF_RAMP_SLIGHT_RIGHT
+            }
+
+            ManeuverType.RampLeft.value -> {
+                newType = Maneuver.TYPE_OFF_RAMP_SLIGHT_LEFT
+            }
+
+            ManeuverType.ExitRight.value -> {
+                newType = Maneuver.TYPE_TURN_SLIGHT_RIGHT
+            }
+
+            ManeuverType.StayRight.value -> {
+                newType = Maneuver.TYPE_KEEP_RIGHT
+            }
+
+            ManeuverType.StayLeft.value -> {
+                newType = Maneuver.TYPE_KEEP_LEFT
+            }
+
+            ManeuverType.RoundaboutEnter.value -> {
+                newType = Maneuver.TYPE_ROUNDABOUT_ENTER_CCW
+            }
+
+            ManeuverType.RoundaboutExit.value -> {
+                newType = Maneuver.TYPE_ROUNDABOUT_EXIT_CCW
+            }
+        }
+        return newType
+    }
 }

common/data/src/main/java/com/kouros/navigation/model/RouteModel.kt

@@ -1,28 +1,31 @@
 package com.kouros.navigation.model
 
 import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Matrix
 import android.location.Location
 import androidx.car.app.navigation.model.Maneuver
 import androidx.car.app.navigation.model.Step
+import androidx.core.graphics.createBitmap
+import androidx.core.graphics.drawable.IconCompat
 import com.kouros.data.R
 import com.kouros.navigation.data.Constants.NEXT_STEP_THRESHOLD
-import com.kouros.navigation.data.Constants.ROUTE_ENGINE
-import com.kouros.navigation.data.valhalla.ManeuverType
+import com.kouros.navigation.data.Constants.ROUTING_ENGINE
 import com.kouros.navigation.data.Place
 import com.kouros.navigation.data.Route
-import com.kouros.navigation.data.RouteEngine
 import com.kouros.navigation.data.StepData
 import com.kouros.navigation.data.route.Intersection
 import com.kouros.navigation.data.route.Lane
 import com.kouros.navigation.data.route.Leg
+import com.kouros.navigation.data.valhalla.ManeuverType
+import com.kouros.navigation.utils.GeoUtils.createCenterLocation
 import com.kouros.navigation.utils.NavigationUtils.getIntKeyValue
 import com.kouros.navigation.utils.location
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.invoke
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import java.util.concurrent.TimeUnit
@@ -40,6 +43,8 @@ open class RouteModel() {
         val lastSpeedIndex: Int = 0,
         val maxSpeed: Int = 0,
         val location: Location = location(0.0, 0.0),
+        val lastLocation: Location = location(0.0, 0.0),
+        val bearing : Float = 0F
     )
 
     var routeState = RouteState()
@@ -55,11 +60,14 @@ open class RouteModel() {
         get() = routeState.route!!.legs!!.first()
 
     fun startNavigation(routeString: String, context: Context) {
-        val routeEngine = getIntKeyValue(context = context, ROUTE_ENGINE)
-        val newRoute = Route.Builder()
+        val routeEngine = getIntKeyValue(context = context, ROUTING_ENGINE)
+        var newRoute = Route.Builder()
             .routeEngine(routeEngine)
             .route(routeString)
             .build()
+        // TODO:
+        newRoute = newRoute.copy(centerLocation = createCenterLocation(newRoute.routeGeoJson))
+        println("Route ${newRoute.centerLocation}")
         this.routeState = routeState.copy(
             route = newRoute,
             isNavigating = true
@@ -80,6 +88,7 @@ open class RouteModel() {
         routeState = routeState.copy(location = location)
         findStep(location)
         updateSpeedLimit(location, viewModel)
+
     }
 
     private fun findStep(location: Location) {
@@ -93,6 +102,9 @@ open class RouteModel() {
                             nearestDistance = distance
                             route.currentStep = step.index
                             step.waypointIndex = wayIndex
+                            step.wayPointLocation = location(waypoint[0], waypoint[1])
+                            val bearing = routeState.lastLocation.bearingTo(location)
+                            this.routeState = routeState.copy(lastLocation = location, bearing = bearing)
                         }
                     }
                     if (nearestDistance == 0F) {
@@ -104,11 +116,9 @@ open class RouteModel() {
                 break
             }
         }
-        //println("Current Index  ${route.currentStep} WayPoint: ${route.currentStep().waypointIndex}")
     }
 
     private fun currentIntersection(location: Location): Intersection {
-
         var inter = Intersection()
         var nearestDistance = 100000.0f
         route.currentStep().intersection.forEach {
@@ -120,6 +130,7 @@ open class RouteModel() {
         }
         return inter
     }
+
     fun updateSpeedLimit(location: Location, viewModel: ViewModel) = runBlocking {
         CoroutineScope(Dispatchers.IO).launch {
             // speed limit
@@ -150,7 +161,7 @@ open class RouteModel() {
         var maneuverType = if (hasArrived(currentStep.maneuver.type)) {
             currentStep.maneuver.type
         } else {
-            ManeuverType.None.value
+            Maneuver.TYPE_STRAIGHT
         }
         // Get the single, correct maneuver for this state
         val relevantStep = if (shouldAdvance) {
@@ -187,6 +198,7 @@ open class RouteModel() {
         when (distanceLeft) {
             in 0.0..NEXT_STEP_THRESHOLD -> {
             }
+
             else -> {
                 if (step.name.isNotEmpty()) {
                     text = step.name
@@ -262,68 +274,49 @@ open class RouteModel() {
     }
 
     fun maneuverIcon(routeManeuverType: Int): (Pair<Int, Int>) {
-        var type = Maneuver.TYPE_DEPART
         var currentTurnIcon = R.drawable.ic_turn_name_change
         when (routeManeuverType) {
-            ManeuverType.None.value -> {
-                type = Maneuver.TYPE_STRAIGHT
+            Maneuver.TYPE_STRAIGHT -> {
                 currentTurnIcon = R.drawable.ic_turn_name_change
             }
 
-            ManeuverType.Destination.value,
-            ManeuverType.DestinationRight.value,
-            ManeuverType.DestinationLeft.value,
+            Maneuver.TYPE_DESTINATION,
                 -> {
-                type = Maneuver.TYPE_DESTINATION
                 currentTurnIcon = R.drawable.ic_turn_destination
             }
 
-            ManeuverType.Right.value -> {
-                type = Maneuver.TYPE_TURN_NORMAL_RIGHT
+            Maneuver.TYPE_TURN_NORMAL_RIGHT -> {
                 currentTurnIcon = R.drawable.ic_turn_normal_right
             }
 
-            ManeuverType.Left.value -> {
-                type = Maneuver.TYPE_TURN_NORMAL_LEFT
+            Maneuver.TYPE_TURN_NORMAL_LEFT -> {
                 currentTurnIcon = R.drawable.ic_turn_normal_left
             }
 
-            ManeuverType.RampRight.value -> {
-                type = Maneuver.TYPE_OFF_RAMP_SLIGHT_RIGHT
+            Maneuver.TYPE_OFF_RAMP_SLIGHT_RIGHT -> {
                 currentTurnIcon = R.drawable.ic_turn_slight_right
             }
 
-            ManeuverType.RampLeft.value -> {
-                type = Maneuver.TYPE_TURN_NORMAL_LEFT
-                currentTurnIcon = R.drawable.ic_turn_normal_left
-            }
-
-            ManeuverType.ExitRight.value -> {
-                type = Maneuver.TYPE_TURN_SLIGHT_RIGHT
+            Maneuver.TYPE_TURN_SLIGHT_RIGHT -> {
                 currentTurnIcon = R.drawable.ic_turn_slight_right
             }
 
-            ManeuverType.StayRight.value -> {
-                type = Maneuver.TYPE_KEEP_RIGHT
+            Maneuver.TYPE_KEEP_RIGHT -> {
                 currentTurnIcon = R.drawable.ic_turn_name_change
             }
-
-            ManeuverType.StayLeft.value -> {
-                type = Maneuver.TYPE_KEEP_LEFT
+            Maneuver.TYPE_KEEP_LEFT -> {
                 currentTurnIcon = R.drawable.ic_turn_name_change
             }
-
-            ManeuverType.RoundaboutEnter.value -> {
-                type = Maneuver.TYPE_ROUNDABOUT_ENTER_CCW
+            Maneuver.TYPE_ROUNDABOUT_ENTER_CCW -> {
                 currentTurnIcon = R.drawable.ic_roundabout_ccw
             }
 
-            ManeuverType.RoundaboutExit.value -> {
-                type = Maneuver.TYPE_ROUNDABOUT_EXIT_CCW
+            Maneuver.TYPE_ROUNDABOUT_EXIT_CCW -> {
+
                 currentTurnIcon = R.drawable.ic_roundabout_ccw
             }
         }
-        return Pair(type, currentTurnIcon)
+        return Pair(routeManeuverType, currentTurnIcon)
     }
 
     fun isNavigating(): Boolean {
@@ -336,4 +329,79 @@ open class RouteModel() {
                 || type == ManeuverType.Destination.value
                 || type == ManeuverType.DestinationLeft.value
     }
+
+    fun createLaneIcon(context: Context, stepData: StepData): IconCompat {
+        val bitmaps = mutableListOf<Bitmap>()
+        stepData.lane.forEach {
+            if (it.indications.isNotEmpty()) {
+                it.indications.forEach { it2 ->
+                    val resource = laneToResource(it2, it, stepData)
+                    if (it2 != "none") {
+                        println("Direction $resource")
+                        if (resource.isNotEmpty()) {
+                            val id = resourceId( resource);
+                            val bitMap = BitmapFactory.decodeResource(context.resources, id)
+                            bitmaps.add(bitMap)
+                        }
+                    }
+                }
+            }
+        }
+        return IconCompat.createWithBitmap(overlay(bitmaps = bitmaps))
+    }
+
+
+    fun overlay(bitmaps: List<Bitmap>): Bitmap {
+        val matrix = Matrix()
+        if (bitmaps.size == 1) {
+            return bitmaps.first()
+        }
+        val bmOverlay = createBitmap(
+            bitmaps.first().getWidth() * bitmaps.size,
+            bitmaps.first().getHeight(),
+            bitmaps.first().getConfig()!!
+        )
+        val canvas = Canvas(bmOverlay)
+        canvas.drawBitmap(bitmaps.first(), matrix, null)
+        var i = 0
+        bitmaps.forEach {
+            if (i > 0) {
+                matrix.setTranslate(i * 40F, 0F)
+                canvas.drawBitmap(it, matrix, null)
+            }
+            i++
+        }
+        return bmOverlay
+    }
+
+    private fun laneToResource(direction: String, lane: Lane, stepData: StepData): String {
+        println("Maneuver  ${stepData.maneuverType}")
+        return when (val direction = direction.replace(" ", "_")) {
+            "left" -> if (stepData.maneuverType == Maneuver.TYPE_TURN_NORMAL_LEFT) "${direction}_valid" else "${direction}_not_valid"
+            "right" -> if (stepData.maneuverType == Maneuver.TYPE_TURN_NORMAL_RIGHT) "${direction}_valid" else "${direction}_not_valid"
+            "straight" -> if (stepData.maneuverType == Maneuver.TYPE_STRAIGHT) "${direction}_valid" else "${direction}_not_valid"
+            "slight_right" -> if (stepData.maneuverType == Maneuver.TYPE_TURN_SLIGHT_RIGHT) "${direction}_valid" else "${direction}_not_valid"
+            "slight_left" -> if (stepData.maneuverType == Maneuver.TYPE_TURN_SLIGHT_LEFT) "${direction}_valid" else "${direction}_not_valid"
+            else -> {""}
+        }
+    }
+
+    fun resourceId(
+        variableName: String,
+    ): Int {
+        return  when(variableName) {
+            "left_not_valid" -> R.drawable.left_not_valid
+            "left_valid" -> R.drawable.left_valid
+            "left_valid_right_not_valid" -> R.drawable.left_valid_right_not_valid
+            "right_not_valid" -> R.drawable.right_not_valid
+            "right_valid" -> R.drawable.right_valid
+            "slight_right_not_valid" -> R.drawable.slight_right_not_valid
+            "slight_right_valid" -> R.drawable.slight_right_valid
+            "straight_not_valid" -> R.drawable.straight_not_valid
+            "straight_not_valid_right_valid" -> R.drawable.straight_not_valid_right_valid
+            "straight_valid" -> R.drawable.straight_valid
+            else -> {R.drawable.ic_close_white_24dp}
+        }
+    }
+
 }

common/data/src/main/java/com/kouros/navigation/model/ViewModel.kt

@@ -67,6 +67,11 @@ class ViewModel(private val repository: NavigationRepository) : ViewModel() {
         MutableLiveData()
     }
 
+    val routingEngine: MutableLiveData<Int> by lazy {
+        MutableLiveData()
+    }
+
+
     fun loadRecentPlace(location: Location, context: Context) {
         viewModelScope.launch(Dispatchers.IO) {
             try {

common/data/src/main/java/com/kouros/navigation/utils/NavigationUtils.kt

@@ -4,7 +4,7 @@ import android.content.Context
 import android.location.Location
 import android.location.LocationManager
 import androidx.core.content.edit
-import com.kouros.navigation.data.Constants.ROUTE_ENGINE
+import com.kouros.navigation.data.Constants.ROUTING_ENGINE
 import com.kouros.navigation.data.Constants.SHARED_PREF_KEY
 import com.kouros.navigation.data.RouteEngine
 import com.kouros.navigation.data.osrm.OsrmRepository
@@ -26,7 +26,7 @@ import kotlin.time.Duration.Companion.seconds
 object NavigationUtils {
 
     fun getRouteEngine(context: Context): ViewModel {
-        val  routeEngine = getIntKeyValue(context = context, ROUTE_ENGINE)
+        val  routeEngine = getIntKeyValue(context = context, ROUTING_ENGINE)
         return when (routeEngine) {
             RouteEngine.VALHALLA.ordinal -> ViewModel(ValhallaRepository())
             else -> ViewModel(OsrmRepository())

common/data/src/main/res/drawable/speed_camera_24px.xml

@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M701,600L614,550L754,446L840,496L701,600ZM160,800L160,720L360,720Q360,720 360,720Q360,720 360,720L360,482L240,413Q211,396 202.5,364.5Q194,333 211,304L271,200Q288,171 319.5,162.5Q351,154 380,171L761,391L517,573L440,529L440,720Q440,753 416.5,776.5Q393,800 360,800L160,800Z"/>
+</vector>

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

@@ -30,4 +30,7 @@
     <string name="reject_action_title">Reject</string>
     <string name="ok_action_title">OK</string>
     <string name="search_action_title">Search</string>
+    <string name="valhalla">Valhalla</string>
+    <string name="osrm">Osrm</string>
+    <string name="routing_engine">Routing engine</string>
 </resources>