NAVAND-5469: Support refresh interval for notifications with geometry-aware refresh logic (#9593)

* NAVAND-5469 Support refresh interval for notifications; support refresh_type (dynamic/static)

GitOrigin-RevId: 0fd0309df975043cc4d3cd590935c6380e2759d6

Author: yuryybk

base/src/main/java/com/mapbox/navigation/base/internal/route/NavigationRouteEx.kt

@@ -65,6 +65,7 @@ fun NavigationRoute.internalRefreshRoute(
             ?.get(KEY_REFRESH_TTL)?.asInt,
         IncidentsRefresher(),
         ClosuresRefresher(),
+        NotificationsRefresher(),
     )
 }
 
@@ -97,6 +98,7 @@ fun NavigationRoute.refreshRoute(
         refreshTtl,
         IncidentsRefresher(),
         ClosuresRefresher(),
+        NotificationsRefresher(),
     )
 }
 
@@ -113,6 +115,7 @@ internal fun NavigationRoute.refreshRoute(
     refreshTtl: Int?,
     incidentsRefresher: IncidentsRefresher,
     closuresRefresher: ClosuresRefresher,
+    notificationsRefresher: NotificationsRefresher,
 ): NavigationRoute {
     val updateLegs = directionsRoute.legs()?.mapIndexed { index, routeLeg ->
         if (index < initialLegIndex) {
@@ -153,18 +156,20 @@ internal fun NavigationRoute.refreshRoute(
                 startingLegGeometryIndex,
                 lastLegRefreshIndex,
             )
+            val mergedNotifications = notificationsRefresher.getRefreshedNotifications(
+                routeLeg.unrecognizedJsonProperties?.get(KEY_NOTIFICATIONS) as? JsonArray,
+                unrecognizedLegNotifications?.getOrNull(index) as? JsonArray,
+                startingLegGeometryIndex,
+                lastLegRefreshIndex,
+            )
 
             routeLeg.toBuilder()
                 .duration(mergedAnnotation?.duration()?.sumOf { it } ?: routeLeg.duration())
                 .annotation(mergedAnnotation)
                 .incidents(mergedIncidents)
                 .closures(mergedClosures)
                 .steps(routeLeg.steps()?.updateSteps(directionsRoute, mergedAnnotation))
-                .updateNotifications(
-                    routeLeg.unrecognizedJsonProperties,
-                    unrecognizedLegNotifications?.getOrNull(index) as? JsonArray,
-                    routeOptions.isEVRoute(),
-                )
+                .applyMergedNotifications(routeLeg.unrecognizedJsonProperties, mergedNotifications)
                 .build()
         }
     }
@@ -327,3 +332,18 @@ private fun DirectionsRoute.Builder.updateRouteDurationBasedOnLegsDurationAndCha
     duration(result)
     return this
 }
+
+private fun RouteLeg.Builder.applyMergedNotifications(
+    oldUnrecognizedProperties: Map<String, JsonElement>?,
+    mergedNotifications: JsonArray?,
+): RouteLeg.Builder {
+    return unrecognizedJsonProperties(
+        oldUnrecognizedProperties.orEmpty().toMutableMap().also {
+            if (mergedNotifications == null || mergedNotifications.isEmpty) {
+                it.remove(KEY_NOTIFICATIONS)
+            } else {
+                it[KEY_NOTIFICATIONS] = mergedNotifications
+            }
+        },
+    )
+}

base/src/main/java/com/mapbox/navigation/base/internal/route/NotificationsRefresher.kt

@@ -0,0 +1,150 @@
+package com.mapbox.navigation.base.internal.route
+
+import com.google.gson.JsonArray
+import com.google.gson.JsonElement
+import com.mapbox.navigation.base.internal.utils.Constants.NotificationRefreshType.DYNAMIC
+
+internal class NotificationsRefresher {
+
+    fun getRefreshedNotifications(
+        oldNotifications: JsonArray?,
+        newNotifications: JsonArray?,
+        startingLegGeometryIndex: Int,
+        lastRefreshLegGeometryIndex: Int,
+    ): JsonArray? {
+        return when {
+            oldNotifications == null && newNotifications == null -> null
+            oldNotifications == null -> adjustNotificationIndices(
+                newNotifications,
+                startingLegGeometryIndex,
+            )
+            newNotifications == null -> filterNotificationsByGeometryRange(
+                oldNotifications,
+                startingLegGeometryIndex,
+                lastRefreshLegGeometryIndex,
+            )
+            else -> mergeNotifications(
+                oldNotifications,
+                newNotifications,
+                startingLegGeometryIndex,
+                lastRefreshLegGeometryIndex,
+            )
+        }
+    }
+
+    private fun mergeNotifications(
+        oldNotifications: JsonArray,
+        newNotifications: JsonArray,
+        startingLegGeometryIndex: Int,
+        lastRefreshLegGeometryIndex: Int,
+    ): JsonArray {
+        // Filter old notifications to keep static and dynamic notifications outside refresh range
+        val result = filterNotificationsByGeometryRange(
+            oldNotifications,
+            startingLegGeometryIndex,
+            lastRefreshLegGeometryIndex,
+        )
+
+        // Add new dynamic notifications with adjusted indices
+        result.addAll(
+            adjustNotificationIndices(
+                newNotifications,
+                startingLegGeometryIndex,
+            ),
+        )
+
+        return result
+    }
+
+    private fun filterNotificationsByGeometryRange(
+        notifications: JsonArray,
+        startingLegGeometryIndex: Int,
+        lastRefreshLegGeometryIndex: Int,
+    ): JsonArray {
+        val result = JsonArray()
+
+        notifications.forEach { notification ->
+            if (notification.isDynamicNotification()) {
+                // Dynamic notifications: only keep those outside the refresh range
+                val geometryIndex = notification.getGeometryIndex()
+                if (geometryIndex != null) {
+                    val isOutsideRange = geometryIndex < startingLegGeometryIndex ||
+                        geometryIndex > lastRefreshLegGeometryIndex
+                    if (isOutsideRange) {
+                        result.add(notification)
+                    }
+                }
+                // Dynamic notifications without geometry_index are filtered out
+            } else {
+                // Static notifications: always keep them
+                result.add(notification)
+            }
+        }
+
+        return result
+    }
+
+    /**
+     * Adjusts geometry indices for new notifications using the provided starting leg geometry index.
+     */
+    private fun adjustNotificationIndices(
+        notifications: JsonArray?,
+        startingLegGeometryIndex: Int,
+    ): JsonArray? {
+        if (notifications == null || notifications.isEmpty) {
+            return notifications
+        }
+
+        val result = JsonArray()
+        notifications.forEach { notification ->
+            val adjustedNotification = adjustNotificationIndex(
+                notification,
+                startingLegGeometryIndex,
+            )
+            result.add(adjustedNotification)
+        }
+        return result
+    }
+
+    private fun adjustNotificationIndex(
+        notification: JsonElement,
+        startingLegGeometryIndex: Int,
+    ): JsonElement {
+        if (!notification.isJsonObject) {
+            return notification
+        }
+
+        val notificationObject = notification.asJsonObject
+        val geometryIndex = notificationObject.get("geometry_index")?.asInt
+
+        if (geometryIndex != null) {
+            val adjustedNotification = notificationObject.deepCopy()
+            adjustedNotification.addProperty(
+                "geometry_index",
+                startingLegGeometryIndex + geometryIndex,
+            )
+            return adjustedNotification
+        }
+
+        return notification
+    }
+
+    private fun JsonElement.getGeometryIndex(): Int? {
+        return if (isJsonObject) {
+            asJsonObject.get("geometry_index")?.asInt
+        } else {
+            null
+        }
+    }
+
+    /**
+     * Determines if a notification should be treated as dynamic (refreshable)
+     * based on the refresh_type field
+     */
+    private fun JsonElement.isDynamicNotification(): Boolean {
+        if (!isJsonObject) return false
+
+        val refreshType = asJsonObject.get("refresh_type")?.asJsonPrimitive?.asString
+        return refreshType == DYNAMIC
+    }
+}

base/src/main/java/com/mapbox/navigation/base/internal/route/RouteLegNotificationMergeEx.kt

@@ -14,17 +14,8 @@ class Constants {
         val SEVERE_CONGESTION_RANGE = 80..100
     }
 
-    internal object NotificationSubtype {
-        private const val EV_MIN_CHARGE_AT_CHARGING_STATION = "evMinChargeAtChargingStation"
-        private const val EV_MIN_CHARGE_AT_DESTINATION = "evMinChargeAtDestination"
-        private const val EV_INSUFFICIENT_CHARGE = "evInsufficientCharge"
-        private const val EV_STATION_UNAVAILABLE = "stationUnavailable"
-
-        val EV_NOTIFICATIONS_SUB_TYPES = setOf(
-            EV_MIN_CHARGE_AT_CHARGING_STATION,
-            EV_MIN_CHARGE_AT_DESTINATION,
-            EV_INSUFFICIENT_CHARGE,
-            EV_STATION_UNAVAILABLE,
-        )
+    internal object NotificationRefreshType {
+        const val STATIC = "static"
+        const val DYNAMIC = "dynamic"
     }
 }