Bump driver app version code to 48

app/build.gradle.kts

@@ -34,8 +34,8 @@ android {
         applicationId = "pl.firmatpp.kierowca"
         minSdk = 26
         targetSdk = 35
-        versionCode = 42
-        versionName = "1.0.41"
+        versionCode = 48
+        versionName = "1.0.44"
         setProperty("archivesBaseName", "pl.firmatpp.kierowca")
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
 

app/src/main/AndroidManifest.xml

@@ -5,6 +5,8 @@
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
 
     <application
         android:allowBackup="false"
@@ -40,5 +42,10 @@
                 <action android:name="com.google.firebase.MESSAGING_EVENT" />
             </intent-filter>
         </service>
+
+        <service
+            android:name=".tracking.ActiveRouteTrackingService"
+            android:exported="false"
+            android:foregroundServiceType="location" />
     </application>
 </manifest>

app/src/main/java/pl/firmatpp/kierowca/MainActivity.kt

@@ -1,11 +1,12 @@
 package pl.firmatpp.kierowca
 
 import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
-import androidx.activity.ComponentActivity
-import androidx.activity.compose.setContent
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
 import pl.firmatpp.kierowca.ui.DriverApp
 import pl.firmatpp.kierowca.ui.DriverViewModel
@@ -13,18 +14,23 @@ import pl.firmatpp.kierowca.ui.theme.TppKierowcaTheme
 
 class MainActivity : ComponentActivity() {
     private var notificationRouteId by mutableStateOf<String?>(null)
+    private var notificationRouteTarget by mutableStateOf<String?>(null)
     private var notificationLeaveRequestId by mutableStateOf<String?>(null)
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         notificationRouteId = intent.getStringExtra(EXTRA_ROUTE_ID)
+        notificationRouteTarget = intent.getStringExtra(EXTRA_ROUTE_TARGET)
         notificationLeaveRequestId = intent.getStringExtra(EXTRA_LEAVE_REQUEST_ID)
         setContent {
-            TppKierowcaTheme {
             val viewModel: DriverViewModel = viewModel()
+            val state by viewModel.state.collectAsStateWithLifecycle()
+
+            TppKierowcaTheme(themeMode = state.themeMode) {
                 DriverApp(
                     viewModel = viewModel,
                     initialRouteId = notificationRouteId,
+                    initialRouteTarget = notificationRouteTarget,
                     initialLeaveRequestId = notificationLeaveRequestId,
                 )
             }
@@ -35,11 +41,15 @@ class MainActivity : ComponentActivity() {
         super.onNewIntent(intent)
         setIntent(intent)
         notificationRouteId = intent.getStringExtra(EXTRA_ROUTE_ID)
+        notificationRouteTarget = intent.getStringExtra(EXTRA_ROUTE_TARGET)
         notificationLeaveRequestId = intent.getStringExtra(EXTRA_LEAVE_REQUEST_ID)
     }
 
     companion object {
         const val EXTRA_ROUTE_ID = "pl.firmatpp.kierowca.EXTRA_ROUTE_ID"
+        const val EXTRA_ROUTE_TARGET = "pl.firmatpp.kierowca.EXTRA_ROUTE_TARGET"
         const val EXTRA_LEAVE_REQUEST_ID = "pl.firmatpp.kierowca.EXTRA_LEAVE_REQUEST_ID"
+        const val ROUTE_TARGET_DETAIL = "detail"
+        const val ROUTE_TARGET_FINISH = "finish"
     }
 }

app/src/main/java/pl/firmatpp/kierowca/data/ApiErrorMapper.kt

@@ -1,6 +1,7 @@
 package pl.firmatpp.kierowca.data
 
 import java.io.IOException
+import java.net.UnknownHostException
 import retrofit2.HttpException
 
 enum class ApiErrorKind {
@@ -26,6 +27,11 @@ data class ApiError(
 object ApiErrorMapper {
     fun map(throwable: Throwable): ApiError =
         when (throwable) {
+            is UnknownHostException -> ApiError(
+                kind = ApiErrorKind.Network,
+                message = "Brak internetu lub połączenia z serwerem. Sprawdź zasięg i spróbuj ponownie.",
+                retryable = true,
+            )
             is IOException -> ApiError(
                 kind = ApiErrorKind.Network,
                 message = "Nie udało się połączyć z serwerem. Operacja nie została potwierdzona.",
@@ -39,6 +45,9 @@ object ApiErrorMapper {
             )
         }
 
+    fun shouldReportNonFatal(throwable: Throwable): Boolean =
+        map(throwable).kind != ApiErrorKind.Network
+
     fun mapHttpStatus(statusCode: Int, body: String?): ApiError {
         val code = body?.let { """"code"\s*:\s*"([^"]+)"""".toRegex().find(it)?.groupValues?.getOrNull(1) }
         val message = body?.let { """"message"\s*:\s*"([^"]+)"""".toRegex().find(it)?.groupValues?.getOrNull(1) }

app/src/main/java/pl/firmatpp/kierowca/data/AppPreferencesStore.kt

@@ -0,0 +1,41 @@
+package pl.firmatpp.kierowca.data
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.booleanPreferencesKey
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.datastore.preferences.preferencesDataStore
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import pl.firmatpp.kierowca.ui.theme.AppThemeMode
+
+private val Context.driverAppPreferencesDataStore by preferencesDataStore(name = "driver_app_preferences")
+
+class AppPreferencesStore(
+    private val dataStore: DataStore<Preferences>,
+) {
+    constructor(context: Context) : this(context.driverAppPreferencesDataStore)
+
+    private val themeModeKey = stringPreferencesKey("theme_mode")
+    private val routeProgressNotificationEnabledKey = booleanPreferencesKey("route_progress_notification_enabled")
+
+    val themeMode: Flow<AppThemeMode> = dataStore.data
+        .map { preferences -> AppThemeMode.fromStoredValue(preferences[themeModeKey]) }
+
+    val routeProgressNotificationEnabled: Flow<Boolean> = dataStore.data
+        .map { preferences -> preferences[routeProgressNotificationEnabledKey] ?: true }
+
+    suspend fun setThemeMode(themeMode: AppThemeMode) {
+        dataStore.edit { preferences ->
+            preferences[themeModeKey] = themeMode.storedValue
+        }
+    }
+
+    suspend fun setRouteProgressNotificationEnabled(enabled: Boolean) {
+        dataStore.edit { preferences ->
+            preferences[routeProgressNotificationEnabledKey] = enabled
+        }
+    }
+}

app/src/main/java/pl/firmatpp/kierowca/data/DriverRepository.kt

@@ -19,6 +19,7 @@ import pl.firmatpp.kierowca.data.model.DispatchSheetUploadResponse
 import pl.firmatpp.kierowca.data.model.CreateLeaveRequestBody
 import pl.firmatpp.kierowca.data.model.DriverDto
 import pl.firmatpp.kierowca.data.model.DriverLeaveRequestDto
+import pl.firmatpp.kierowca.data.model.FinishRouteBody
 import pl.firmatpp.kierowca.data.model.NotificationPreferencesBody
 import pl.firmatpp.kierowca.data.model.NotificationPreferencesDto
 import pl.firmatpp.kierowca.data.model.OtpResponse
@@ -26,7 +27,10 @@ import pl.firmatpp.kierowca.data.model.PhotoUploadResponse
 import pl.firmatpp.kierowca.data.model.PushTokenBody
 import pl.firmatpp.kierowca.data.model.RealtimeStatusBody
 import pl.firmatpp.kierowca.data.model.RequestOtpBody
+import pl.firmatpp.kierowca.data.model.RoutePointBatchBody
+import pl.firmatpp.kierowca.data.model.RoutePointsResponse
 import pl.firmatpp.kierowca.data.model.RouteResponse
+import pl.firmatpp.kierowca.data.model.StartRouteBody
 import pl.firmatpp.kierowca.data.model.SyncStateResponse
 import pl.firmatpp.kierowca.data.model.VerifyOtpBody
 import pl.firmatpp.kierowca.data.upload.DispatchSheetUploadEntity
@@ -69,6 +73,15 @@ class DriverRepository(
     suspend fun completeRoute(routeId: String) =
         api.completeRoute(authHeader(requireToken()), routeId)
 
+    suspend fun startRoute(routeId: String, body: StartRouteBody) =
+        api.startRoute(authHeader(requireToken()), routeId, body)
+
+    suspend fun finishRoute(routeId: String, body: FinishRouteBody) =
+        api.finishRoute(authHeader(requireToken()), routeId, body)
+
+    suspend fun storeRoutePoints(routeId: String, body: RoutePointBatchBody): RoutePointsResponse =
+        api.storeRoutePoints(authHeader(requireToken()), routeId, body)
+
     suspend fun updateNotificationPreferences(notifyNewRoutes: Boolean): NotificationPreferencesDto =
         api.updateNotificationPreferences(authHeader(requireToken()), NotificationPreferencesBody(notifyNewRoutes))
 
@@ -95,6 +108,7 @@ class DriverRepository(
         routeId: String,
         uri: Uri,
         source: String,
+        stage: String = "other",
         metadata: PhotoUploadMetadata = PhotoUploadMetadata(),
     ): PhotoUploadResponse {
         val resolver = context.contentResolver
@@ -115,6 +129,7 @@ class DriverRepository(
             clientRequestId.toPlainTextBody(),
             contentSha256.toPlainTextBody(),
             sourceBody,
+            stage.toPlainTextBody(),
             metadataParts["takenAt"],
             metadataParts["latitude"],
             metadataParts["longitude"],
@@ -141,6 +156,7 @@ class DriverRepository(
             upload.clientRequestId.toPlainTextBody(),
             upload.contentSha256.toPlainTextBody(),
             upload.source.toPlainTextBody(),
+            upload.stage.toPlainTextBody(),
             metadataParts["takenAt"],
             metadataParts["latitude"],
             metadataParts["longitude"],

app/src/main/java/pl/firmatpp/kierowca/data/api/MobileDriverApi.kt

@@ -9,6 +9,7 @@ import pl.firmatpp.kierowca.data.model.CancelLeaveRequestBody
 import pl.firmatpp.kierowca.data.model.CompleteRouteResponse
 import pl.firmatpp.kierowca.data.model.CreateLeaveRequestBody
 import pl.firmatpp.kierowca.data.model.DispatchSheetUploadResponse
+import pl.firmatpp.kierowca.data.model.FinishRouteBody
 import pl.firmatpp.kierowca.data.model.LeaveRequestListResponse
 import pl.firmatpp.kierowca.data.model.LeaveRequestResponse
 import pl.firmatpp.kierowca.data.model.LeaveRequestTypesResponse
@@ -19,7 +20,11 @@ import pl.firmatpp.kierowca.data.model.PhotoUploadResponse
 import pl.firmatpp.kierowca.data.model.PushTokenBody
 import pl.firmatpp.kierowca.data.model.RealtimeStatusBody
 import pl.firmatpp.kierowca.data.model.RequestOtpBody
+import pl.firmatpp.kierowca.data.model.RouteActionResponse
+import pl.firmatpp.kierowca.data.model.RoutePointBatchBody
+import pl.firmatpp.kierowca.data.model.RoutePointsResponse
 import pl.firmatpp.kierowca.data.model.RouteResponse
+import pl.firmatpp.kierowca.data.model.StartRouteBody
 import pl.firmatpp.kierowca.data.model.SyncStateResponse
 import pl.firmatpp.kierowca.data.model.VerifyOtpBody
 import pl.firmatpp.kierowca.data.model.VerifyOtpResponse
@@ -102,6 +107,27 @@ interface MobileDriverApi {
         @Path("routeId") routeId: String,
     ): CompleteRouteResponse
 
+    @POST("mobile/driver/routes/{routeId}/start")
+    suspend fun startRoute(
+        @Header("Authorization") authorization: String,
+        @Path("routeId") routeId: String,
+        @Body body: StartRouteBody,
+    ): RouteActionResponse
+
+    @POST("mobile/driver/routes/{routeId}/finish")
+    suspend fun finishRoute(
+        @Header("Authorization") authorization: String,
+        @Path("routeId") routeId: String,
+        @Body body: FinishRouteBody,
+    ): RouteActionResponse
+
+    @POST("mobile/driver/routes/{routeId}/points")
+    suspend fun storeRoutePoints(
+        @Header("Authorization") authorization: String,
+        @Path("routeId") routeId: String,
+        @Body body: RoutePointBatchBody,
+    ): RoutePointsResponse
+
     @GET("mobile/driver/sync-state")
     suspend fun syncState(
         @Header("Authorization") authorization: String,
@@ -142,6 +168,7 @@ interface MobileDriverApi {
         @Part("clientRequestId") clientRequestId: RequestBody,
         @Part("contentSha256") contentSha256: RequestBody,
         @Part("source") source: RequestBody,
+        @Part("stage") stage: RequestBody?,
         @Part("takenAt") takenAt: RequestBody?,
         @Part("latitude") latitude: RequestBody?,
         @Part("longitude") longitude: RequestBody?,

app/src/main/java/pl/firmatpp/kierowca/data/model/DriverModels.kt

@@ -232,6 +232,10 @@ data class DriverRouteDto(
     val contractCode: String?,
     val relationLabel: String,
     val status: String,
+    val loadingWeight: Double? = null,
+    val unloadingWeight: Double? = null,
+    val trackingStatus: String? = null,
+    val arrivedAt: String? = null,
     val distanceKm: Double?,
     val notes: String?,
     val truck: TruckDto?,
@@ -240,6 +244,13 @@ data class DriverRouteDto(
     val originNavigation: NavigationPointDto? = null,
     val destinationNavigation: NavigationPointDto? = null,
     val photos: List<RoutePhotoDto> = emptyList(),
+    val photosByStage: RoutePhotosByStageDto? = null,
+)
+
+data class RoutePhotosByStageDto(
+    val loading: List<RoutePhotoDto> = emptyList(),
+    val unloading: List<RoutePhotoDto> = emptyList(),
+    val other: List<RoutePhotoDto> = emptyList(),
 )
 
 data class TruckDto(
@@ -262,6 +273,7 @@ data class RoutePhotoDto(
     val clientRequestId: String? = null,
     val contentSha256: String? = null,
     val source: String,
+    val stage: String = "other",
     val mimeType: String?,
     val size: Long,
     val url: String,
@@ -286,6 +298,55 @@ data class PhotoUploadReceiptDto(
     val storedAt: String?,
 )
 
+data class StartRouteBody(
+    val clientActionId: String,
+    val loadingWeight: Double,
+    val occurredAt: String,
+    val photoClientRequestIds: List<String>,
+)
+
+data class FinishRouteBody(
+    val clientActionId: String,
+    val unloadingWeight: Double,
+    val occurredAt: String,
+    val photoClientRequestIds: List<String>,
+)
+
+data class RouteActionResponse(
+    val ok: Boolean,
+    val alreadyProcessed: Boolean,
+    val route: DriverRouteDto,
+)
+
+data class RoutePointBatchBody(
+    val clientBatchId: String,
+    val points: List<RoutePointDto>,
+)
+
+data class RoutePointDto(
+    val clientPointId: String,
+    val trip_id: String,
+    val driver_id: String,
+    val lat: Double,
+    val lon: Double,
+    val accuracy: Double,
+    val speed: Double?,
+    val bearing: Double?,
+    val timestamp: Long,
+    val battery: Int?,
+    val charging: Boolean,
+)
+
+data class RoutePointsResponse(
+    val ok: Boolean,
+    val stored: Int,
+    val progress: Double?,
+    val remainingDistanceMeters: Int?,
+    val arrived: Boolean,
+    val offRoute: Boolean,
+    val routeVersion: Long?,
+)
+
 data class DispatchSheetUploadResponse(
     val photo: DispatchSheetPhotoDto,
     val reminder: DispatchSheetReminderDto,

app/src/main/java/pl/firmatpp/kierowca/data/upload/DriverDatabase.kt

@@ -15,16 +15,20 @@ import pl.firmatpp.kierowca.data.sync.DriverSyncStateEntity
     entities = [
         PhotoUploadEntity::class,
         DispatchSheetUploadEntity::class,
+        RouteActionEntity::class,
+        RoutePointEntity::class,
         DriverBootstrapCacheEntity::class,
         DriverRouteCacheEntity::class,
         DriverSyncStateEntity::class,
     ],
-    version = 3,
+    version = 5,
     exportSchema = false,
 )
 abstract class DriverDatabase : RoomDatabase() {
     abstract fun photoUploadDao(): PhotoUploadDao
     abstract fun dispatchSheetUploadDao(): DispatchSheetUploadDao
+    abstract fun routeActionDao(): RouteActionDao
+    abstract fun routePointDao(): RoutePointDao
     abstract fun driverCacheDao(): DriverCacheDao
 
     companion object {
@@ -105,13 +109,68 @@ abstract class DriverDatabase : RoomDatabase() {
             }
         }
 
+        private val migration3To4 = object : Migration(3, 4) {
+            override fun migrate(db: SupportSQLiteDatabase) {
+                db.execSQL("ALTER TABLE photo_uploads ADD COLUMN stage TEXT NOT NULL DEFAULT 'other'")
+            }
+        }
+
+        private val migration4To5 = object : Migration(4, 5) {
+            override fun migrate(db: SupportSQLiteDatabase) {
+                db.execSQL(
+                    """
+                    CREATE TABLE IF NOT EXISTS route_actions (
+                        clientActionId TEXT NOT NULL PRIMARY KEY,
+                        routeId TEXT NOT NULL,
+                        action TEXT NOT NULL,
+                        weight REAL NOT NULL,
+                        occurredAt TEXT NOT NULL,
+                        photoClientRequestIdsJson TEXT NOT NULL,
+                        status TEXT NOT NULL,
+                        attemptCount INTEGER NOT NULL,
+                        lastError TEXT,
+                        createdAtEpochMillis INTEGER NOT NULL,
+                        updatedAtEpochMillis INTEGER NOT NULL
+                    )
+                    """.trimIndent(),
+                )
+                db.execSQL("CREATE INDEX IF NOT EXISTS index_route_actions_routeId ON route_actions(routeId)")
+                db.execSQL("CREATE INDEX IF NOT EXISTS index_route_actions_status ON route_actions(status)")
+                db.execSQL(
+                    """
+                    CREATE TABLE IF NOT EXISTS route_points (
+                        clientPointId TEXT NOT NULL PRIMARY KEY,
+                        routeId TEXT NOT NULL,
+                        driverId TEXT NOT NULL,
+                        lat REAL NOT NULL,
+                        lon REAL NOT NULL,
+                        accuracy REAL NOT NULL,
+                        speed REAL,
+                        bearing REAL,
+                        timestamp INTEGER NOT NULL,
+                        battery INTEGER,
+                        charging INTEGER NOT NULL,
+                        status TEXT NOT NULL,
+                        attemptCount INTEGER NOT NULL,
+                        lastError TEXT,
+                        createdAtEpochMillis INTEGER NOT NULL,
+                        updatedAtEpochMillis INTEGER NOT NULL
+                    )
+                    """.trimIndent(),
+                )
+                db.execSQL("CREATE INDEX IF NOT EXISTS index_route_points_routeId ON route_points(routeId)")
+                db.execSQL("CREATE INDEX IF NOT EXISTS index_route_points_status ON route_points(status)")
+                db.execSQL("CREATE INDEX IF NOT EXISTS index_route_points_routeId_status ON route_points(routeId, status)")
+            }
+        }
+
         fun get(context: Context): DriverDatabase =
             instance ?: synchronized(this) {
                 instance ?: Room.databaseBuilder(
                     context.applicationContext,
                     DriverDatabase::class.java,
                     "driver-local-outbox.db",
-                ).addMigrations(migration1To2, migration2To3).build().also { instance = it }
+                ).addMigrations(migration1To2, migration2To3, migration3To4, migration4To5).build().also { instance = it }
             }
     }
 }

app/src/main/java/pl/firmatpp/kierowca/data/upload/PhotoUploadEntity.kt

@@ -16,6 +16,7 @@ data class PhotoUploadEntity(
     val routeId: String,
     val localPath: String,
     val source: String,
+    val stage: String = "other",
     val takenAt: String?,
     val latitude: Double?,
     val longitude: Double?,

app/src/main/java/pl/firmatpp/kierowca/data/upload/PhotoUploadOutbox.kt

@@ -28,7 +28,7 @@ class PhotoUploadOutbox(
     fun observeQueuedUploads(): Flow<List<PhotoUploadEntity>> =
         dao.observeQueuedUploads()
 
-    suspend fun enqueue(routeId: String, uri: Uri, source: String, metadata: PhotoUploadMetadata): PhotoUploadEntity {
+    suspend fun enqueue(routeId: String, uri: Uri, source: String, metadata: PhotoUploadMetadata, stage: String = "other"): PhotoUploadEntity {
         val clientRequestId = UUID.randomUUID().toString()
         val mimeType = context.contentResolver.getType(uri) ?: "image/jpeg"
         val extension = when (mimeType) {
@@ -44,6 +44,7 @@ class PhotoUploadOutbox(
             routeId = routeId,
             localPath = localFile.absolutePath,
             source = source,
+            stage = stage,
             takenAt = metadata.takenAt,
             latitude = metadata.latitude,
             longitude = metadata.longitude,

app/src/main/java/pl/firmatpp/kierowca/data/upload/RouteActionDao.kt

@@ -0,0 +1,53 @@
+package pl.firmatpp.kierowca.data.upload
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface RouteActionDao {
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun upsert(action: RouteActionEntity)
+
+    @Query("SELECT * FROM route_actions WHERE clientActionId = :clientActionId LIMIT 1")
+    suspend fun find(clientActionId: String): RouteActionEntity?
+
+    @Query(
+        """
+        SELECT * FROM route_actions
+        WHERE routeId = :routeId
+        AND status IN ('PENDING', 'WAITING_FOR_PHOTOS', 'SYNCING', 'CONFIRMED', 'FAILED_RETRYABLE', 'FAILED_CONFLICT', 'FAILED_PERMANENT')
+        ORDER BY createdAtEpochMillis DESC
+        """,
+    )
+    fun observeUnresolvedForRoute(routeId: String): Flow<List<RouteActionEntity>>
+
+    @Query(
+        """
+        SELECT * FROM route_actions
+        WHERE status IN ('PENDING', 'WAITING_FOR_PHOTOS', 'SYNCING', 'CONFIRMED', 'FAILED_RETRYABLE', 'FAILED_CONFLICT', 'FAILED_PERMANENT')
+        ORDER BY createdAtEpochMillis DESC
+        """,
+    )
+    fun observeVisibleActions(): Flow<List<RouteActionEntity>>
+
+    @Query(
+        """
+        UPDATE route_actions
+        SET status = :status,
+            lastError = :lastError,
+            attemptCount = attemptCount + :attemptIncrement,
+            updatedAtEpochMillis = :updatedAt
+        WHERE clientActionId = :clientActionId
+        """,
+    )
+    suspend fun updateStatus(
+        clientActionId: String,
+        status: String,
+        lastError: String?,
+        attemptIncrement: Int,
+        updatedAt: Long = System.currentTimeMillis(),
+    )
+}

app/src/main/java/pl/firmatpp/kierowca/data/upload/RouteActionEntity.kt

@@ -0,0 +1,41 @@
+package pl.firmatpp.kierowca.data.upload
+
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+
+object RouteActionStatus {
+    const val Pending = "PENDING"
+    const val WaitingForPhotos = "WAITING_FOR_PHOTOS"
+    const val Syncing = "SYNCING"
+    const val Confirmed = "CONFIRMED"
+    const val FailedRetryable = "FAILED_RETRYABLE"
+    const val FailedPermanent = "FAILED_PERMANENT"
+    const val FailedConflict = "FAILED_CONFLICT"
+}
+
+object RouteActionType {
+    const val Start = "start"
+    const val Finish = "finish"
+}
+
+@Entity(
+    tableName = "route_actions",
+    indices = [
+        Index(value = ["routeId"]),
+        Index(value = ["status"]),
+    ],
+)
+data class RouteActionEntity(
+    @PrimaryKey val clientActionId: String,
+    val routeId: String,
+    val action: String,
+    val weight: Double,
+    val occurredAt: String,
+    val photoClientRequestIdsJson: String,
+    val status: String = RouteActionStatus.Pending,
+    val attemptCount: Int = 0,
+    val lastError: String? = null,
+    val createdAtEpochMillis: Long = System.currentTimeMillis(),
+    val updatedAtEpochMillis: Long = System.currentTimeMillis(),
+)

app/src/main/java/pl/firmatpp/kierowca/data/upload/RouteActionOutbox.kt

@@ -0,0 +1,69 @@
+package pl.firmatpp.kierowca.data.upload
+
+import android.content.Context
+import androidx.work.BackoffPolicy
+import androidx.work.Constraints
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.workDataOf
+import com.google.gson.Gson
+import java.time.Instant
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+import kotlinx.coroutines.flow.Flow
+
+class RouteActionOutbox(
+    private val context: Context,
+    private val dao: RouteActionDao = DriverDatabase.get(context).routeActionDao(),
+    private val workManager: WorkManager = WorkManager.getInstance(context),
+    private val gson: Gson = Gson(),
+) {
+    fun observeUnresolvedForRoute(routeId: String): Flow<List<RouteActionEntity>> =
+        dao.observeUnresolvedForRoute(routeId)
+
+    fun observeVisibleActions(): Flow<List<RouteActionEntity>> =
+        dao.observeVisibleActions()
+
+    suspend fun enqueueStart(routeId: String, loadingWeight: Double, photoClientRequestIds: List<String>): RouteActionEntity =
+        enqueue(RouteActionType.Start, routeId, loadingWeight, photoClientRequestIds)
+
+    suspend fun enqueueFinish(routeId: String, unloadingWeight: Double, photoClientRequestIds: List<String>): RouteActionEntity =
+        enqueue(RouteActionType.Finish, routeId, unloadingWeight, photoClientRequestIds)
+
+    private suspend fun enqueue(
+        action: String,
+        routeId: String,
+        weight: Double,
+        photoClientRequestIds: List<String>,
+    ): RouteActionEntity {
+        val entity = RouteActionEntity(
+            clientActionId = UUID.randomUUID().toString(),
+            routeId = routeId,
+            action = action,
+            weight = weight,
+            occurredAt = Instant.now().toString(),
+            photoClientRequestIdsJson = gson.toJson(photoClientRequestIds.distinct()),
+        )
+
+        dao.upsert(entity)
+        enqueueWorker(entity.clientActionId)
+
+        return entity
+    }
+
+    private fun enqueueWorker(clientActionId: String) {
+        val request = OneTimeWorkRequestBuilder<RouteActionWorker>()
+            .setInputData(workDataOf(RouteActionWorker.KEY_CLIENT_ACTION_ID to clientActionId))
+            .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build())
+            .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
+            .build()
+
+        workManager.enqueueUniqueWork(
+            RouteActionWorker.uniqueWorkName(clientActionId),
+            ExistingWorkPolicy.REPLACE,
+            request,
+        )
+    }
+}

app/src/main/java/pl/firmatpp/kierowca/data/upload/RouteActionWorker.kt

@@ -0,0 +1,132 @@
+package pl.firmatpp.kierowca.data.upload
+
+import android.content.Context
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import com.google.gson.Gson
+import pl.firmatpp.kierowca.data.ApiErrorKind
+import pl.firmatpp.kierowca.data.ApiErrorMapper
+import pl.firmatpp.kierowca.data.DriverRepository
+import pl.firmatpp.kierowca.data.model.FinishRouteBody
+import pl.firmatpp.kierowca.data.model.RouteActionResponse
+import pl.firmatpp.kierowca.data.model.StartRouteBody
+import pl.firmatpp.kierowca.data.sync.DriverSyncRepository
+import pl.firmatpp.kierowca.diagnostics.AppDiagnostics
+import pl.firmatpp.kierowca.sync.DriverSyncWorker
+
+class RouteActionWorker(
+    appContext: Context,
+    params: WorkerParameters,
+) : CoroutineWorker(appContext, params) {
+    private val database = DriverDatabase.get(appContext)
+    private val dao = database.routeActionDao()
+    private val photoDao = database.photoUploadDao()
+    private val repository = DriverRepository(appContext)
+    private val syncRepository = DriverSyncRepository(appContext, repository)
+    private val gson = Gson()
+
+    override suspend fun doWork(): Result {
+        val clientActionId = inputData.getString(KEY_CLIENT_ACTION_ID) ?: return Result.failure()
+        val action = dao.find(clientActionId) ?: return Result.failure()
+        val photoClientRequestIds = photoClientRequestIds(action)
+
+        val waitingForPhotos = photoClientRequestIds
+            .mapNotNull { photoDao.find(it) }
+            .any { it.status != PhotoUploadStatus.Confirmed.storageValue }
+
+        if (waitingForPhotos) {
+            dao.updateStatus(
+                clientActionId = clientActionId,
+                status = RouteActionStatus.WaitingForPhotos,
+                lastError = "Czekam na wysłanie zdjęć etapu.",
+                attemptIncrement = 0,
+            )
+            return Result.retry()
+        }
+
+        dao.updateStatus(
+            clientActionId = clientActionId,
+            status = RouteActionStatus.Syncing,
+            lastError = null,
+            attemptIncrement = 1,
+        )
+
+        return runCatching {
+            val response = sendAction(action, photoClientRequestIds)
+            dao.updateStatus(
+                clientActionId = clientActionId,
+                status = RouteActionStatus.Confirmed,
+                lastError = null,
+                attemptIncrement = 0,
+            )
+            syncRepository.cacheConfirmedRoute(response.route, response.route.routeDate)
+            DriverSyncWorker.enqueue(applicationContext, response.route.routeDate, response.route.id)
+            Result.success()
+        }.getOrElse { throwable ->
+            val error = ApiErrorMapper.map(throwable)
+            AppDiagnostics.reportNonFatal(
+                throwable = throwable,
+                operation = "route_action_worker",
+                keys = mapOf(
+                    "client_action_id" to clientActionId,
+                    "route_id" to action.routeId,
+                    "route_action" to action.action,
+                    "api_error_kind" to error.kind.name,
+                    "api_error_code" to error.code,
+                    "api_status_code" to error.statusCode,
+                    "retryable" to error.retryable,
+                ),
+            )
+            val status = when {
+                error.kind == ApiErrorKind.Conflict -> RouteActionStatus.FailedConflict
+                error.retryable -> RouteActionStatus.FailedRetryable
+                else -> RouteActionStatus.FailedPermanent
+            }
+            dao.updateStatus(
+                clientActionId = clientActionId,
+                status = status,
+                lastError = error.message,
+                attemptIncrement = 0,
+            )
+
+            if (error.retryable && error.kind != ApiErrorKind.Auth) Result.retry() else Result.failure()
+        }
+    }
+
+    private suspend fun sendAction(action: RouteActionEntity, photoClientRequestIds: List<String>): RouteActionResponse =
+        when (action.action) {
+            RouteActionType.Start -> repository.startRoute(
+                routeId = action.routeId,
+                body = StartRouteBody(
+                    clientActionId = action.clientActionId,
+                    loadingWeight = action.weight,
+                    occurredAt = action.occurredAt,
+                    photoClientRequestIds = photoClientRequestIds,
+                ),
+            )
+            RouteActionType.Finish -> repository.finishRoute(
+                routeId = action.routeId,
+                body = FinishRouteBody(
+                    clientActionId = action.clientActionId,
+                    unloadingWeight = action.weight,
+                    occurredAt = action.occurredAt,
+                    photoClientRequestIds = photoClientRequestIds,
+                ),
+            )
+            else -> error("Nieznana akcja kursu: ${action.action}")
+        }
+
+    private fun photoClientRequestIds(action: RouteActionEntity): List<String> =
+        runCatching {
+            gson.fromJson(action.photoClientRequestIdsJson, Array<String>::class.java)?.toList().orEmpty()
+        }.getOrDefault(emptyList())
+            .map { it.trim() }
+            .filter { it.isNotBlank() }
+            .distinct()
+
+    companion object {
+        const val KEY_CLIENT_ACTION_ID = "clientActionId"
+
+        fun uniqueWorkName(clientActionId: String): String = "route-action-$clientActionId"
+    }
+}

app/src/main/java/pl/firmatpp/kierowca/data/upload/RoutePointDao.kt

@@ -0,0 +1,50 @@
+package pl.firmatpp.kierowca.data.upload
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+
+@Dao
+interface RoutePointDao {
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun upsert(point: RoutePointEntity)
+
+    @Query(
+        """
+        SELECT * FROM route_points
+        WHERE routeId = :routeId
+        AND status != 'CONFIRMED'
+        ORDER BY timestamp ASC
+        LIMIT :limit
+        """,
+    )
+    suspend fun pendingForRoute(routeId: String, limit: Int): List<RoutePointEntity>
+
+    @Query(
+        """
+        SELECT COUNT(*) FROM route_points
+        WHERE routeId = :routeId
+        AND status != 'CONFIRMED'
+        """,
+    )
+    suspend fun pendingCount(routeId: String): Int
+
+    @Query(
+        """
+        UPDATE route_points
+        SET status = :status,
+            lastError = :lastError,
+            attemptCount = attemptCount + :attemptIncrement,
+            updatedAtEpochMillis = :updatedAt
+        WHERE clientPointId IN (:clientPointIds)
+        """,
+    )
+    suspend fun updateStatus(
+        clientPointIds: List<String>,
+        status: String,
+        lastError: String?,
+        attemptIncrement: Int,
+        updatedAt: Long = System.currentTimeMillis(),
+    )
+}

app/src/main/java/pl/firmatpp/kierowca/data/upload/RoutePointEntity.kt

@@ -0,0 +1,40 @@
+package pl.firmatpp.kierowca.data.upload
+
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+
+object RoutePointStatus {
+    const val Pending = "PENDING"
+    const val Syncing = "SYNCING"
+    const val Confirmed = "CONFIRMED"
+    const val FailedRetryable = "FAILED_RETRYABLE"
+    const val FailedPermanent = "FAILED_PERMANENT"
+}
+
+@Entity(
+    tableName = "route_points",
+    indices = [
+        Index(value = ["routeId"]),
+        Index(value = ["status"]),
+        Index(value = ["routeId", "status"]),
+    ],
+)
+data class RoutePointEntity(
+    @PrimaryKey val clientPointId: String,
+    val routeId: String,
+    val driverId: String,
+    val lat: Double,
+    val lon: Double,
+    val accuracy: Double,
+    val speed: Double?,
+    val bearing: Double?,
+    val timestamp: Long,
+    val battery: Int?,
+    val charging: Boolean,
+    val status: String = RoutePointStatus.Pending,
+    val attemptCount: Int = 0,
+    val lastError: String? = null,
+    val createdAtEpochMillis: Long = System.currentTimeMillis(),
+    val updatedAtEpochMillis: Long = System.currentTimeMillis(),
+)

app/src/main/java/pl/firmatpp/kierowca/data/upload/RoutePointOutbox.kt

@@ -0,0 +1,61 @@
+package pl.firmatpp.kierowca.data.upload
+
+import android.content.Context
+import android.location.Location
+import androidx.work.BackoffPolicy
+import androidx.work.Constraints
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.workDataOf
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+
+class RoutePointOutbox(
+    private val context: Context,
+    private val dao: RoutePointDao = DriverDatabase.get(context).routePointDao(),
+    private val workManager: WorkManager = WorkManager.getInstance(context),
+) {
+    suspend fun enqueue(
+        routeId: String,
+        driverId: String,
+        location: Location,
+        battery: Int?,
+        charging: Boolean,
+        uploadDelaySeconds: Long,
+    ) {
+        dao.upsert(
+            RoutePointEntity(
+                clientPointId = UUID.randomUUID().toString(),
+                routeId = routeId,
+                driverId = driverId,
+                lat = location.latitude,
+                lon = location.longitude,
+                accuracy = if (location.hasAccuracy()) location.accuracy.toDouble() else 0.0,
+                speed = if (location.hasSpeed()) location.speed.toDouble() else null,
+                bearing = if (location.hasBearing()) location.bearing.toDouble() else null,
+                timestamp = ((location.time.takeIf { it > 0L } ?: System.currentTimeMillis()) / 1000L),
+                battery = battery,
+                charging = charging,
+            ),
+        )
+
+        enqueueWorker(routeId, uploadDelaySeconds)
+    }
+
+    fun enqueueWorker(routeId: String, delaySeconds: Long = 20L) {
+        val request = OneTimeWorkRequestBuilder<RoutePointWorker>()
+            .setInputData(workDataOf(RoutePointWorker.KEY_ROUTE_ID to routeId))
+            .setInitialDelay(delaySeconds.coerceAtLeast(0L), TimeUnit.SECONDS)
+            .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build())
+            .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
+            .build()
+
+        workManager.enqueueUniqueWork(
+            RoutePointWorker.uniqueWorkName(routeId),
+            ExistingWorkPolicy.KEEP,
+            request,
+        )
+    }
+}

app/src/main/java/pl/firmatpp/kierowca/data/upload/RoutePointWorker.kt

@@ -0,0 +1,90 @@
+package pl.firmatpp.kierowca.data.upload
+
+import android.content.Context
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import java.util.UUID
+import pl.firmatpp.kierowca.data.ApiErrorKind
+import pl.firmatpp.kierowca.data.ApiErrorMapper
+import pl.firmatpp.kierowca.data.DriverRepository
+import pl.firmatpp.kierowca.data.model.RoutePointBatchBody
+import pl.firmatpp.kierowca.data.model.RoutePointDto
+import pl.firmatpp.kierowca.diagnostics.AppDiagnostics
+import pl.firmatpp.kierowca.tracking.ActiveRouteTrackingService
+
+class RoutePointWorker(
+    appContext: Context,
+    params: WorkerParameters,
+) : CoroutineWorker(appContext, params) {
+    private val dao = DriverDatabase.get(appContext).routePointDao()
+    private val repository = DriverRepository(appContext)
+
+    override suspend fun doWork(): Result {
+        val routeId = inputData.getString(KEY_ROUTE_ID) ?: return Result.failure()
+        val points = dao.pendingForRoute(routeId, BATCH_LIMIT)
+        if (points.isEmpty()) return Result.success()
+
+        val pointIds = points.map { it.clientPointId }
+        dao.updateStatus(pointIds, RoutePointStatus.Syncing, null, attemptIncrement = 1)
+
+        return runCatching {
+            val response = repository.storeRoutePoints(
+                routeId = routeId,
+                body = RoutePointBatchBody(
+                    clientBatchId = UUID.randomUUID().toString(),
+                    points = points.map { it.toDto() },
+                ),
+            )
+            dao.updateStatus(pointIds, RoutePointStatus.Confirmed, null, attemptIncrement = 0)
+
+            if (response.arrived) {
+                ActiveRouteTrackingService.markArrived(applicationContext, routeId)
+            }
+            if (dao.pendingCount(routeId) > 0) {
+                RoutePointOutbox(applicationContext).enqueueWorker(routeId, delaySeconds = 1L)
+            }
+
+            Result.success()
+        }.getOrElse { throwable ->
+            val error = ApiErrorMapper.map(throwable)
+            AppDiagnostics.reportNonFatal(
+                throwable = throwable,
+                operation = "route_point_worker",
+                keys = mapOf(
+                    "route_id" to routeId,
+                    "batch_size" to points.size,
+                    "api_error_kind" to error.kind.name,
+                    "api_error_code" to error.code,
+                    "api_status_code" to error.statusCode,
+                    "retryable" to error.retryable,
+                ),
+            )
+            val status = if (error.retryable) RoutePointStatus.FailedRetryable else RoutePointStatus.FailedPermanent
+            dao.updateStatus(pointIds, status, error.message, attemptIncrement = 0)
+
+            if (error.retryable && error.kind != ApiErrorKind.Auth) Result.retry() else Result.failure()
+        }
+    }
+
+    private fun RoutePointEntity.toDto(): RoutePointDto =
+        RoutePointDto(
+            clientPointId = clientPointId,
+            trip_id = routeId,
+            driver_id = driverId,
+            lat = lat,
+            lon = lon,
+            accuracy = accuracy,
+            speed = speed,
+            bearing = bearing,
+            timestamp = timestamp,
+            battery = battery,
+            charging = charging,
+        )
+
+    companion object {
+        const val KEY_ROUTE_ID = "routeId"
+        private const val BATCH_LIMIT = 100
+
+        fun uniqueWorkName(routeId: String): String = "route-point-sync-$routeId"
+    }
+}

app/src/main/java/pl/firmatpp/kierowca/sync/DriverLiveSyncClient.kt

@@ -3,10 +3,10 @@ package pl.firmatpp.kierowca.sync
 import com.google.gson.Gson
 import com.google.gson.JsonObject
 import com.google.gson.JsonParser
-import java.util.concurrent.atomic.AtomicBoolean
-import kotlinx.coroutines.Job
+import java.util.concurrent.TimeUnit
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.delay
@@ -16,75 +16,155 @@ import okhttp3.Request
 import okhttp3.WebSocket
 import okhttp3.WebSocketListener
 import pl.firmatpp.kierowca.data.DriverRepository
+import pl.firmatpp.kierowca.data.model.BroadcastAuthResponse
 import pl.firmatpp.kierowca.data.model.RealtimeConfigDto
 import pl.firmatpp.kierowca.diagnostics.AppDiagnostics
 
-class DriverLiveSyncClient(
-    private val repository: DriverRepository,
-    private val onConnected: () -> Unit,
-    private val onHint: (DriverSyncHint) -> Unit,
-    private val client: OkHttpClient = OkHttpClient(),
-    private val gson: Gson = Gson(),
-) {
-    private companion object {
-        const val HEARTBEAT_INTERVAL_MS = 10_000L
+interface DriverLiveSyncGateway {
+    suspend fun broadcastAuth(socketId: String, channelName: String): BroadcastAuthResponse
+    suspend fun storeRealtimeStatus(status: String, socketId: String?, error: String?)
 }
 
-    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
-    private val started = AtomicBoolean(false)
+class DriverRepositoryLiveSyncGateway(
+    private val repository: DriverRepository,
+) : DriverLiveSyncGateway {
+    override suspend fun broadcastAuth(socketId: String, channelName: String): BroadcastAuthResponse =
+        repository.broadcastAuth(socketId, channelName)
+
+    override suspend fun storeRealtimeStatus(status: String, socketId: String?, error: String?) {
+        repository.storeRealtimeStatus(status, socketId, error)
+    }
+}
+
+interface LiveWebSocketFactory {
+    fun newWebSocket(url: String, listener: WebSocketListener): WebSocket
+}
+
+class OkHttpLiveWebSocketFactory(
+    private val client: OkHttpClient,
+) : LiveWebSocketFactory {
+    override fun newWebSocket(url: String, listener: WebSocketListener): WebSocket =
+        client.newWebSocket(Request.Builder().url(url).build(), listener)
+}
+
+private enum class LiveSyncConnectionState {
+    Stopped,
+    WaitingForNetwork,
+    Disconnected,
+    Connecting,
+    Subscribing,
+    Connected,
+}
+
+class DriverLiveSyncClient(
+    private val gateway: DriverLiveSyncGateway,
+    private val onConnected: () -> Unit,
+    private val onHint: (DriverSyncHint) -> Unit,
+    private val webSocketFactory: LiveWebSocketFactory = OkHttpLiveWebSocketFactory(defaultOkHttpClient()),
+    private val gson: Gson = Gson(),
+    private val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO),
+    private val reconnectDelaysMs: List<Long> = DEFAULT_RECONNECT_DELAYS_MS,
+    private val staleTimeoutMs: Long = STALE_TIMEOUT_MS,
+) {
+    constructor(
+        repository: DriverRepository,
+        onConnected: () -> Unit,
+        onHint: (DriverSyncHint) -> Unit,
+        client: OkHttpClient = defaultOkHttpClient(),
+        gson: Gson = Gson(),
+    ) : this(
+        gateway = DriverRepositoryLiveSyncGateway(repository),
+        onConnected = onConnected,
+        onHint = onHint,
+        webSocketFactory = OkHttpLiveWebSocketFactory(client),
+        gson = gson,
+    )
+
+    private companion object {
+        const val HEARTBEAT_INTERVAL_MS = 10_000L
+        const val STALE_TIMEOUT_MS = 30_000L
+        val DEFAULT_RECONNECT_DELAYS_MS = listOf(1_000L, 2_000L, 5_000L, 10_000L, 30_000L)
+
+        fun defaultOkHttpClient(): OkHttpClient =
+            OkHttpClient.Builder()
+                .pingInterval(15, TimeUnit.SECONDS)
+                .build()
+    }
+
+    private val lock = Any()
+    private var desiredActive: Boolean = false
+    private var networkAvailable: Boolean = true
+    private var state: LiveSyncConnectionState = LiveSyncConnectionState.Stopped
     private var webSocket: WebSocket? = null
     private var driverId: String? = null
     private var realtimeConfig: RealtimeConfigDto? = null
     private var socketId: String? = null
+    private var reconnectJob: Job? = null
     private var heartbeatJob: Job? = null
+    private var staleWatchdogJob: Job? = null
+    private var reconnectAttempt: Int = 0
+    private var messageVersion: Long = 0
 
     fun start(driverId: String, config: RealtimeConfigDto?) {
-        val appKey = config?.reverbAppKey?.takeIf { it.isNotBlank() } ?: return
-        val wsBaseUrl = config.reverbWsBaseUrl?.takeIf { it.isNotBlank() } ?: return
-        if (!config.reverbEnabled) return
+        if (!isConfigUsable(config)) return
 
+        synchronized(lock) {
             realtimeConfig = config
             this.driverId = driverId
-        if (!started.compareAndSet(false, true)) return
-
-        val wsUrl = wsBaseUrl.trimEnd('/') +
-            "/" + appKey +
-            "?protocol=7&client=android&version=1.0&flash=false"
-
-        webSocket = client.newWebSocket(
-            Request.Builder().url(wsUrl).build(),
-            object : WebSocketListener() {
-                override fun onMessage(webSocket: WebSocket, text: String) {
-                    handleMessage(webSocket, text)
+            desiredActive = true
+        }
+        ensureConnected()
     }
 
-                override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
-                    stopHeartbeat()
-                    reportRealtimeStatus("disconnected", reason.takeIf { it.isNotBlank() })
-                    started.set(false)
-                    scheduleReconnect()
-                }
-
-                override fun onFailure(webSocket: WebSocket, t: Throwable, response: okhttp3.Response?) {
-                    stopHeartbeat()
-                    AppDiagnostics.log("realtime_error: ${t.message ?: response?.message ?: "unknown"}")
-                    reportRealtimeStatus("error", t.message ?: response?.message)
-                    started.set(false)
-                    scheduleReconnect()
-                }
-            },
+    fun ensureConnected() {
+        val shouldConnect = synchronized(lock) {
+            desiredActive &&
+                networkAvailable &&
+                state !in setOf(
+                    LiveSyncConnectionState.Connecting,
+                    LiveSyncConnectionState.Subscribing,
+                    LiveSyncConnectionState.Connected,
                 )
         }
+        if (shouldConnect) connectNow()
+    }
+
+    fun onNetworkAvailable(available: Boolean) {
+        val shouldReconnect = synchronized(lock) {
+            networkAvailable = available
+            if (!available) {
+                reconnectJob?.cancel()
+                reconnectJob = null
+                closeSocketLocked("network_lost")
+                state = if (desiredActive) LiveSyncConnectionState.WaitingForNetwork else LiveSyncConnectionState.Stopped
+                false
+            } else {
+                desiredActive && state == LiveSyncConnectionState.WaitingForNetwork
+            }
+        }
+
+        if (available) {
+            reportRealtimeStatus("reconnecting", "network_available")
+        } else {
+            reportRealtimeStatus("disconnected", "network_lost")
+        }
+
+        if (shouldReconnect) connectNow(resetAttempt = true)
+    }
 
     fun stop() {
-        started.set(false)
-        stopHeartbeat()
-        reportRealtimeStatus("disconnected", "client_stop")
-        webSocket?.close(1000, "logout")
-        webSocket = null
+        synchronized(lock) {
+            desiredActive = false
+            reconnectJob?.cancel()
+            reconnectJob = null
+            closeSocketLocked("client_stop")
             driverId = null
             realtimeConfig = null
             socketId = null
+            reconnectAttempt = 0
+            state = LiveSyncConnectionState.Stopped
+        }
+        reportRealtimeStatus("disconnected", "client_stop")
     }
 
     fun close() {
@@ -92,35 +172,112 @@ class DriverLiveSyncClient(
         scope.cancel()
     }
 
+    private fun connectNow(resetAttempt: Boolean = false) {
+        val wsUrl = synchronized(lock) {
+            val config = realtimeConfig ?: return
+            val id = driverId ?: return
+            if (!desiredActive || !networkAvailable || !isConfigUsable(config)) return
+            if (state == LiveSyncConnectionState.Connecting || state == LiveSyncConnectionState.Subscribing || state == LiveSyncConnectionState.Connected) return
+
+            if (resetAttempt) reconnectAttempt = 0
+            reconnectJob?.cancel()
+            reconnectJob = null
+            socketId = null
+            state = LiveSyncConnectionState.Connecting
+
+            val appKey = config.reverbAppKey.orEmpty()
+            val wsBaseUrl = config.reverbWsBaseUrl.orEmpty()
+            wsBaseUrl.trimEnd('/') + "/" + appKey + "?protocol=7&client=android&version=1.0&flash=false"
+        }
+
+        val socket = webSocketFactory.newWebSocket(
+            wsUrl,
+            object : WebSocketListener() {
+                override fun onMessage(webSocket: WebSocket, text: String) {
+                    handleMessage(webSocket, text)
+                }
+
+                override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
+                    handleDisconnect(
+                        status = "disconnected",
+                        reason = reason.takeIf { it.isNotBlank() } ?: "closed",
+                        socket = webSocket,
+                    )
+                }
+
+                override fun onFailure(webSocket: WebSocket, t: Throwable, response: okhttp3.Response?) {
+                    AppDiagnostics.log("realtime_error: ${t.message ?: response?.message ?: "unknown"}")
+                    handleDisconnect(
+                        status = "error",
+                        reason = t.message ?: response?.message ?: "failure",
+                        socket = webSocket,
+                    )
+                }
+            },
+        )
+
+        synchronized(lock) {
+            webSocket = socket
+        }
+    }
+
     private fun handleMessage(socket: WebSocket, text: String) {
+        val isCurrentSocket = synchronized(lock) {
+            if (webSocket !== socket) {
+                false
+            } else {
+                messageVersion += 1
+                true
+            }
+        }
+        if (!isCurrentSocket) return
+
         val root = runCatching { JsonParser.parseString(text).asJsonObject }.getOrNull() ?: return
         val event = root.string("event") ?: return
 
         when (event) {
+            "pusher:ping" -> {
+                socket.send("""{"event":"pusher:pong","data":{}}""")
+                restartStaleWatchdogIfConnected()
+            }
             "pusher:connection_established" -> {
-                socketId = root.dataObject()?.string("socket_id") ?: return
-                subscribe(socket, socketId ?: return)
+                val nextSocketId = root.dataObject()?.string("socket_id") ?: return
+                synchronized(lock) {
+                    socketId = nextSocketId
+                    state = LiveSyncConnectionState.Subscribing
+                }
+                subscribe(socket, nextSocketId)
             }
             "pusher_internal:subscription_succeeded" -> {
                 val channel = root.string("channel")
-                val id = driverId ?: return
+                val id = synchronized(lock) { driverId } ?: return
                 if (channel == "private-driver-mobile.$id") {
+                    synchronized(lock) {
+                        reconnectAttempt = 0
+                        state = LiveSyncConnectionState.Connected
+                    }
                     reportRealtimeStatus("connected")
                     startHeartbeat()
+                    startStaleWatchdog()
                     onConnected()
                 }
             }
-            "DriverMobileSyncHint" -> parseHint(root.dataObject())?.let(onHint)
+            "DriverMobileSyncHint" -> {
+                restartStaleWatchdogIfConnected()
+                parseHint(root.dataObject())?.let(onHint)
+            }
+            else -> restartStaleWatchdogIfConnected()
         }
     }
 
     private fun subscribe(socket: WebSocket, socketId: String) {
-        val id = driverId ?: return
+        val id = synchronized(lock) { driverId } ?: return
         val channel = "private-driver-mobile.$id"
 
         scope.launch {
             runCatching {
-                val auth = repository.broadcastAuth(socketId, channel).auth
+                val auth = gateway.broadcastAuth(socketId, channel).auth
+                if (!isCurrentSocket(socket)) return@launch
                 val payload = mapOf(
                     "event" to "pusher:subscribe",
                     "data" to mapOf(
@@ -128,11 +285,129 @@ class DriverLiveSyncClient(
                         "auth" to auth,
                     ),
                 )
-                socket.send(gson.toJson(payload))
+                check(socket.send(gson.toJson(payload))) { "WebSocket send returned false" }
+            }.onFailure { throwable ->
+                AppDiagnostics.log("realtime_subscription_error: ${throwable.message ?: throwable::class.java.simpleName}")
+                socket.close(1000, "subscription_failed")
+                handleDisconnect("error", "subscription_failed", socket)
             }
         }
     }
 
+    private fun handleDisconnect(status: String, reason: String?, socket: WebSocket? = null) {
+        val shouldSchedule = synchronized(lock) {
+            if (socket != null && webSocket !== socket) return
+
+            stopHeartbeatLocked()
+            stopStaleWatchdogLocked()
+            webSocket = null
+            socketId = null
+
+            if (!desiredActive) {
+                state = LiveSyncConnectionState.Stopped
+                false
+            } else if (!networkAvailable) {
+                state = LiveSyncConnectionState.WaitingForNetwork
+                false
+            } else {
+                state = LiveSyncConnectionState.Disconnected
+                true
+            }
+        }
+
+        reportRealtimeStatus(status, reason)
+        if (shouldSchedule) scheduleReconnect()
+    }
+
+    private fun scheduleReconnect() {
+        val delayMs = synchronized(lock) {
+            if (!desiredActive || !networkAvailable || state == LiveSyncConnectionState.Stopped) return
+            if (reconnectJob?.isActive == true) return
+            val delay = reconnectDelaysMs.getOrElse(reconnectAttempt) { reconnectDelaysMs.last() }
+            reconnectAttempt += 1
+            delay
+        }
+
+        reconnectJob = scope.launch {
+            delay(delayMs)
+            connectNow()
+        }
+    }
+
+    private fun startHeartbeat() {
+        synchronized(lock) {
+            heartbeatJob?.cancel()
+            heartbeatJob = scope.launch {
+                while (true) {
+                    reportRealtimeStatus("connected")
+                    delay(HEARTBEAT_INTERVAL_MS)
+                }
+            }
+        }
+    }
+
+    private fun startStaleWatchdog() {
+        synchronized(lock) {
+            stopStaleWatchdogLocked()
+            val observedVersion = messageVersion
+            staleWatchdogJob = scope.launch {
+                delay(staleTimeoutMs)
+                val socketToClose = synchronized(lock) {
+                    if (state == LiveSyncConnectionState.Connected && messageVersion == observedVersion) {
+                        webSocket
+                    } else {
+                        null
+                    }
+                }
+
+                if (socketToClose != null) {
+                    socketToClose.close(1001, "stale_connection")
+                    handleDisconnect("error", "stale_connection", socketToClose)
+                    ensureConnected()
+                }
+            }
+        }
+    }
+
+    private fun restartStaleWatchdogIfConnected() {
+        val connected = synchronized(lock) { state == LiveSyncConnectionState.Connected }
+        if (connected) startStaleWatchdog()
+    }
+
+    private fun isCurrentSocket(socket: WebSocket): Boolean =
+        synchronized(lock) { webSocket === socket }
+
+    private fun closeSocketLocked(reason: String) {
+        stopHeartbeatLocked()
+        stopStaleWatchdogLocked()
+        webSocket?.close(1000, reason)
+        webSocket = null
+        socketId = null
+    }
+
+    private fun stopHeartbeatLocked() {
+        heartbeatJob?.cancel()
+        heartbeatJob = null
+    }
+
+    private fun stopStaleWatchdogLocked() {
+        staleWatchdogJob?.cancel()
+        staleWatchdogJob = null
+    }
+
+    private fun reportRealtimeStatus(status: String, error: String? = null) {
+        scope.launch {
+            runCatching {
+                gateway.storeRealtimeStatus(status, socketId, error)
+            }
+        }
+    }
+
+    private fun isConfigUsable(config: RealtimeConfigDto?): Boolean =
+        config?.reverbEnabled == true &&
+            !config.reverbAppKey.isNullOrBlank() &&
+            !config.reverbWsBaseUrl.isNullOrBlank()
+
     private fun parseHint(data: JsonObject?): DriverSyncHint? {
         if (data == null || data.string("type") != "driver_sync_hint") return null
 
@@ -152,37 +427,4 @@ class DriverLiveSyncClient(
 
     private fun JsonObject.string(name: String): String? =
         get(name)?.takeIf { !it.isJsonNull }?.asString
-
-    private fun scheduleReconnect() {
-        val id = driverId ?: return
-        scope.launch {
-            delay(5_000)
-            if (!started.get() && driverId == id) {
-                start(id, realtimeConfig)
-            }
-        }
-    }
-
-    private fun startHeartbeat() {
-        heartbeatJob?.cancel()
-        heartbeatJob = scope.launch {
-            while (started.get()) {
-                reportRealtimeStatus("connected")
-                delay(HEARTBEAT_INTERVAL_MS)
-            }
-        }
-    }
-
-    private fun stopHeartbeat() {
-        heartbeatJob?.cancel()
-        heartbeatJob = null
-    }
-
-    private fun reportRealtimeStatus(status: String, error: String? = null) {
-        scope.launch {
-            runCatching {
-                repository.storeRealtimeStatus(status, socketId, error)
-            }
-        }
-    }
 }

app/src/main/java/pl/firmatpp/kierowca/tracking/ActiveRouteTrackingService.kt

@@ -0,0 +1,300 @@
+package pl.firmatpp.kierowca.tracking
+
+import android.Manifest
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageManager
+import android.content.pm.ServiceInfo
+import android.location.Location
+import android.location.LocationListener
+import android.location.LocationManager
+import android.os.BatteryManager
+import android.os.Build
+import android.os.IBinder
+import androidx.core.app.NotificationCompat
+import androidx.core.content.ContextCompat
+import java.util.Locale
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import pl.firmatpp.kierowca.MainActivity
+import pl.firmatpp.kierowca.R
+import pl.firmatpp.kierowca.data.model.DriverDto
+import pl.firmatpp.kierowca.data.model.DriverRouteDto
+import pl.firmatpp.kierowca.data.upload.RoutePointOutbox
+
+class ActiveRouteTrackingService : Service(), LocationListener {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private lateinit var locationManager: LocationManager
+    private lateinit var routePointOutbox: RoutePointOutbox
+
+    private var routeId: String? = null
+    private var driverId: String? = null
+    private var routeLabel: String = "Kurs aktywny"
+    private var destinationLat: Double? = null
+    private var destinationLon: Double? = null
+    private var totalDistanceMeters: Double? = null
+    private var progressEnabled: Boolean = true
+    private var arrived: Boolean = false
+    private var lastRemainingMeters: Float? = null
+
+    override fun onCreate() {
+        super.onCreate()
+        locationManager = getSystemService(LocationManager::class.java)
+        routePointOutbox = RoutePointOutbox(this)
+        ensureNotificationChannel()
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        when (intent?.action) {
+            ACTION_STOP -> {
+                stopSelf()
+                return START_NOT_STICKY
+            }
+            ACTION_MARK_ARRIVED -> {
+                val id = intent.getStringExtra(EXTRA_ROUTE_ID)
+                if (!id.isNullOrBlank() && (routeId == null || id == routeId)) {
+                    routeId = id
+                    arrived = true
+                    startForegroundCompat(buildNotification())
+                }
+                return START_STICKY
+            }
+            else -> {
+                routeId = intent?.getStringExtra(EXTRA_ROUTE_ID) ?: routeId
+                driverId = intent?.getStringExtra(EXTRA_DRIVER_ID) ?: driverId
+                routeLabel = intent?.getStringExtra(EXTRA_ROUTE_LABEL) ?: routeLabel
+                destinationLat = intent?.takeIf { it.hasExtra(EXTRA_DESTINATION_LAT) }?.getDoubleExtra(EXTRA_DESTINATION_LAT, 0.0)
+                    ?: destinationLat
+                destinationLon = intent?.takeIf { it.hasExtra(EXTRA_DESTINATION_LON) }?.getDoubleExtra(EXTRA_DESTINATION_LON, 0.0)
+                    ?: destinationLon
+                totalDistanceMeters = intent?.takeIf { it.hasExtra(EXTRA_TOTAL_DISTANCE_METERS) }?.getDoubleExtra(EXTRA_TOTAL_DISTANCE_METERS, 0.0)
+                    ?.takeIf { it > 0.0 }
+                    ?: totalDistanceMeters
+                progressEnabled = intent?.getBooleanExtra(EXTRA_PROGRESS_ENABLED, true) ?: progressEnabled
+                arrived = false
+                startForegroundCompat(buildNotification())
+                requestLocationUpdates()
+                return START_STICKY
+            }
+        }
+    }
+
+    override fun onLocationChanged(location: Location) {
+        val activeRouteId = routeId ?: return
+        val activeDriverId = driverId ?: return
+        val remaining = remainingMeters(location)
+        lastRemainingMeters = remaining
+
+        if (!arrived && remaining != null && remaining <= arrivalRadiusMeters(location)) {
+            arrived = true
+            startForegroundCompat(buildNotification())
+        } else {
+            startForegroundCompat(buildNotification())
+        }
+
+        val (battery, charging) = batterySnapshot()
+        val uploadDelaySeconds = uploadDelaySeconds(location, remaining)
+        scope.launch {
+            routePointOutbox.enqueue(
+                routeId = activeRouteId,
+                driverId = activeDriverId,
+                location = location,
+                battery = battery,
+                charging = charging,
+                uploadDelaySeconds = uploadDelaySeconds,
+            )
+        }
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onDestroy() {
+        runCatching { locationManager.removeUpdates(this) }
+        scope.cancel()
+        super.onDestroy()
+    }
+
+    private fun requestLocationUpdates() {
+        if (!hasLocationPermission()) {
+            return
+        }
+        runCatching {
+            locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, LOCATION_INTERVAL_MS, 0f, this)
+        }
+        runCatching {
+            locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, LOCATION_INTERVAL_MS, 0f, this)
+        }
+    }
+
+    private fun buildNotification(): Notification {
+        val activeRouteId = routeId
+        val target = if (arrived) MainActivity.ROUTE_TARGET_FINISH else MainActivity.ROUTE_TARGET_DETAIL
+        val contentIntent = PendingIntent.getActivity(
+            this,
+            if (arrived) 202 else 201,
+            Intent(this, MainActivity::class.java).apply {
+                flags = Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP
+                putExtra(MainActivity.EXTRA_ROUTE_ID, activeRouteId)
+                putExtra(MainActivity.EXTRA_ROUTE_TARGET, target)
+            },
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+        )
+
+        val title = if (arrived) "Jesteś u celu" else routeLabel
+        val text = when {
+            arrived -> "Otwórz zakończenie kursu i dodaj wagę oraz zdjęcia."
+            !progressEnabled -> "Kurs aktywny"
+            lastRemainingMeters != null -> "Do celu: ${formatDistance(lastRemainingMeters!!.toDouble())}"
+            else -> "Kurs aktywny"
+        }
+
+        val builder = NotificationCompat.Builder(this, CHANNEL_ID)
+            .setSmallIcon(R.mipmap.ic_launcher)
+            .setContentTitle(title)
+            .setContentText(text)
+            .setContentIntent(contentIntent)
+            .setOngoing(!arrived)
+            .setOnlyAlertOnce(true)
+            .setCategory(NotificationCompat.CATEGORY_PROGRESS)
+            .setPriority(NotificationCompat.PRIORITY_LOW)
+
+        val progress = progressPercent()
+        if (!arrived && progressEnabled && progress != null) {
+            builder.setProgress(100, progress, false)
+        }
+
+        return builder.build()
+    }
+
+    private fun startForegroundCompat(notification: Notification) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && hasLocationPermission()) {
+            startForeground(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION)
+        } else {
+            startForeground(NOTIFICATION_ID, notification)
+        }
+    }
+
+    private fun ensureNotificationChannel() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val manager = getSystemService(NotificationManager::class.java)
+        val channel = NotificationChannel(
+            CHANNEL_ID,
+            "Aktywny kurs",
+            NotificationManager.IMPORTANCE_LOW,
+        ).apply {
+            description = "Postęp aktywnego kursu i lokalizacja w tle"
+        }
+        manager.createNotificationChannel(channel)
+    }
+
+    private fun remainingMeters(location: Location): Float? {
+        val lat = destinationLat ?: return null
+        val lon = destinationLon ?: return null
+        val target = Location("destination").apply {
+            latitude = lat
+            longitude = lon
+        }
+        return location.distanceTo(target)
+    }
+
+    private fun arrivalRadiusMeters(location: Location): Float =
+        maxOf(120f, if (location.hasAccuracy()) location.accuracy * 2f else 0f)
+
+    private fun progressPercent(): Int? {
+        val total = totalDistanceMeters ?: return null
+        val remaining = lastRemainingMeters ?: return null
+        if (total <= 0.0) return null
+
+        return ((1.0 - (remaining / total)).coerceIn(0.0, 1.0) * 100).toInt()
+    }
+
+    private fun uploadDelaySeconds(location: Location, remaining: Float?): Long {
+        val speed = if (location.hasSpeed()) location.speed else 0f
+        return when {
+            arrived || remaining != null && remaining <= 2_500f -> 5L
+            speed < 0.8f -> 45L
+            speed > 22f -> 20L
+            else -> 20L
+        }
+    }
+
+    private fun batterySnapshot(): Pair<Int?, Boolean> {
+        val batteryIntent = registerReceiver(null, IntentFilter(Intent.ACTION_BATTERY_CHANGED))
+        val level = batteryIntent?.getIntExtra(BatteryManager.EXTRA_LEVEL, -1) ?: -1
+        val scale = batteryIntent?.getIntExtra(BatteryManager.EXTRA_SCALE, -1) ?: -1
+        val status = batteryIntent?.getIntExtra(BatteryManager.EXTRA_STATUS, -1) ?: -1
+        val percent = if (level >= 0 && scale > 0) ((level * 100f) / scale).toInt().coerceIn(0, 100) else null
+        val charging = status == BatteryManager.BATTERY_STATUS_CHARGING ||
+            status == BatteryManager.BATTERY_STATUS_FULL
+
+        return percent to charging
+    }
+
+    private fun hasLocationPermission(): Boolean =
+        ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED ||
+            ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED
+
+    private fun formatDistance(meters: Double): String =
+        if (meters >= 1000.0) {
+            String.format(Locale("pl", "PL"), "%.1f km", meters / 1000.0)
+        } else {
+            "${meters.toInt().coerceAtLeast(0)} m"
+        }
+
+    companion object {
+        private const val CHANNEL_ID = "active_route_tracking"
+        private const val NOTIFICATION_ID = 7401
+        private const val LOCATION_INTERVAL_MS = 5_000L
+
+        private const val ACTION_START = "pl.firmatpp.kierowca.tracking.START"
+        private const val ACTION_STOP = "pl.firmatpp.kierowca.tracking.STOP"
+        private const val ACTION_MARK_ARRIVED = "pl.firmatpp.kierowca.tracking.MARK_ARRIVED"
+
+        private const val EXTRA_ROUTE_ID = "routeId"
+        private const val EXTRA_DRIVER_ID = "driverId"
+        private const val EXTRA_ROUTE_LABEL = "routeLabel"
+        private const val EXTRA_DESTINATION_LAT = "destinationLat"
+        private const val EXTRA_DESTINATION_LON = "destinationLon"
+        private const val EXTRA_TOTAL_DISTANCE_METERS = "totalDistanceMeters"
+        private const val EXTRA_PROGRESS_ENABLED = "progressEnabled"
+
+        fun start(context: Context, route: DriverRouteDto, driver: DriverDto, progressEnabled: Boolean = true) {
+            val intent = Intent(context, ActiveRouteTrackingService::class.java).apply {
+                action = ACTION_START
+                putExtra(EXTRA_ROUTE_ID, route.id)
+                putExtra(EXTRA_DRIVER_ID, driver.id)
+                putExtra(EXTRA_ROUTE_LABEL, route.contractCode?.let { "Kurs #$it" } ?: route.relationLabel)
+                putExtra(EXTRA_PROGRESS_ENABLED, progressEnabled)
+                route.destinationNavigation?.latitude?.let { putExtra(EXTRA_DESTINATION_LAT, it) }
+                route.destinationNavigation?.longitude?.let { putExtra(EXTRA_DESTINATION_LON, it) }
+                route.distanceKm?.takeIf { it > 0.0 }?.let { putExtra(EXTRA_TOTAL_DISTANCE_METERS, it * 1000.0) }
+            }
+            ContextCompat.startForegroundService(context, intent)
+        }
+
+        fun stop(context: Context) {
+            context.startService(
+                Intent(context, ActiveRouteTrackingService::class.java).apply {
+                    action = ACTION_STOP
+                },
+            )
+        }
+
+        fun markArrived(context: Context, routeId: String) {
+            val intent = Intent(context, ActiveRouteTrackingService::class.java).apply {
+                action = ACTION_MARK_ARRIVED
+                putExtra(EXTRA_ROUTE_ID, routeId)
+            }
+            ContextCompat.startForegroundService(context, intent)
+        }
+    }
+}

app/src/main/java/pl/firmatpp/kierowca/ui/DriverRouteProjection.kt

@@ -0,0 +1,73 @@
+package pl.firmatpp.kierowca.ui
+
+import pl.firmatpp.kierowca.data.model.DriverRouteDto
+import pl.firmatpp.kierowca.data.upload.RouteActionEntity
+import pl.firmatpp.kierowca.data.upload.RouteActionStatus
+import pl.firmatpp.kierowca.data.upload.RouteActionType
+
+data class ProjectedDriverRoute(
+    val route: DriverRouteDto,
+    val visibleActions: List<RouteActionEntity>,
+    val loadingWeightPending: Boolean,
+    val unloadingWeightPending: Boolean,
+)
+
+internal val routeActionVisibleStatuses = setOf(
+    RouteActionStatus.Pending,
+    RouteActionStatus.WaitingForPhotos,
+    RouteActionStatus.Syncing,
+    RouteActionStatus.FailedRetryable,
+    RouteActionStatus.FailedConflict,
+    RouteActionStatus.FailedPermanent,
+)
+
+private val routeActionProjectionStatuses = routeActionVisibleStatuses + RouteActionStatus.Confirmed
+
+fun projectDriverRoute(route: DriverRouteDto, actions: List<RouteActionEntity>): ProjectedDriverRoute {
+    val visible = actions
+        .filter { it.routeId == route.id && it.status in routeActionVisibleStatuses }
+    val projectable = actions
+        .filter { it.routeId == route.id && it.status in routeActionProjectionStatuses }
+    var projectedRoute = route
+    var loadingWeightPending = false
+    var unloadingWeightPending = false
+
+    projectable
+        .sortedWith(compareBy<RouteActionEntity> { it.createdAtEpochMillis }.thenBy { it.clientActionId })
+        .forEach { action ->
+            when (action.action) {
+                RouteActionType.Start -> {
+                    projectedRoute = projectedRoute.copy(
+                        status = "W TRAKCIE",
+                        loadingWeight = action.weight,
+                        trackingStatus = "active",
+                    )
+                    loadingWeightPending = action.status != RouteActionStatus.Confirmed
+                }
+                RouteActionType.Finish -> {
+                    projectedRoute = projectedRoute.copy(
+                        status = "ZAKOŃCZONA",
+                        unloadingWeight = action.weight,
+                        trackingStatus = "finished",
+                        completedAt = action.occurredAt,
+                    )
+                    unloadingWeightPending = action.status != RouteActionStatus.Confirmed
+                }
+            }
+        }
+
+    return ProjectedDriverRoute(
+        route = projectedRoute,
+        visibleActions = visible.sortedWith(
+            compareByDescending<RouteActionEntity> { it.createdAtEpochMillis }.thenBy { it.clientActionId },
+        ),
+        loadingWeightPending = loadingWeightPending,
+        unloadingWeightPending = unloadingWeightPending,
+    )
+}
+
+fun projectDriverRoutes(routes: List<DriverRouteDto>, actions: List<RouteActionEntity>): List<DriverRouteDto> =
+    routes.map { route -> projectDriverRoute(route, actions).route }
+
+fun routeActionNeedsAttention(status: String): Boolean =
+    status == RouteActionStatus.FailedConflict || status == RouteActionStatus.FailedPermanent

app/src/main/java/pl/firmatpp/kierowca/ui/DriverUiRules.kt

@@ -10,9 +10,42 @@ import pl.firmatpp.kierowca.data.model.DriverRouteDto
 import pl.firmatpp.kierowca.data.model.DispatchSheetReminderDto
 import pl.firmatpp.kierowca.data.model.RoutePhotoDto
 import pl.firmatpp.kierowca.data.upload.PhotoUploadEntity
+import pl.firmatpp.kierowca.data.upload.RouteActionEntity
+import pl.firmatpp.kierowca.data.upload.RouteActionStatus
+import pl.firmatpp.kierowca.data.upload.RouteActionType
 
 private val shortDateFormatter: DateTimeFormatter = DateTimeFormatter.ofPattern("dd.MM")
 
+enum class RouteFlowStepState {
+    Todo,
+    LocalComplete,
+    Syncing,
+    Confirmed,
+    NeedsAttention,
+}
+
+enum class RouteLifecycleAction {
+    Start,
+    Finish,
+}
+
+data class RouteFlowStepUi(
+    val key: String,
+    val title: String,
+    val state: RouteFlowStepState,
+    val stateLabel: String,
+)
+
+data class RouteLifecycleActionUi(
+    val label: String,
+    val action: RouteLifecycleAction,
+)
+
+data class RouteSyncCalloutUi(
+    val text: String,
+    val isConflict: Boolean,
+)
+
 fun canManageRoutePhotos(selectedDate: String, today: LocalDate = LocalDate.now()): Boolean =
     runCatching { LocalDate.parse(selectedDate).isEqual(today) }.getOrDefault(false)
 
@@ -24,6 +57,151 @@ fun canCompleteRouteFromDriverApp(
     canManageRoutePhotos(selectedDate, today)
         && route.status in setOf("ZAPLANOWANA", "W TRAKCIE")
 
+fun canStartRouteFromDriverApp(
+    route: DriverRouteDto,
+    selectedDate: String,
+    today: LocalDate = LocalDate.now(),
+): Boolean =
+    canManageRoutePhotos(selectedDate, today)
+        && route.status == "ZAPLANOWANA"
+
+fun canFinishRouteFromDriverApp(
+    route: DriverRouteDto,
+    selectedDate: String,
+    today: LocalDate = LocalDate.now(),
+): Boolean =
+    canManageRoutePhotos(selectedDate, today)
+        && route.status == "W TRAKCIE"
+
+fun canSubmitRouteStageForm(weightText: String, serverPhotoCount: Int, localUploadCount: Int): Boolean {
+    return routeStageSubmitBlocker(weightText, serverPhotoCount, localUploadCount) == null
+}
+
+fun routeStageSubmitBlocker(weightText: String, serverPhotoCount: Int, localUploadCount: Int): String? {
+    val trimmed = weightText.trim()
+    val normalizedWeight = trimmed.replace(',', '.').toDoubleOrNull()
+
+    return when {
+        trimmed.isBlank() -> "Podaj wagę."
+        normalizedWeight == null -> "Podaj poprawną wagę."
+        normalizedWeight <= 0.0 -> "Waga musi być większa od zera."
+        visiblePhotoAttachmentCount(serverPhotoCount, localUploadCount) <= 0 -> "Dodaj co najmniej jedno zdjęcie etapu."
+        else -> null
+    }
+}
+
+fun routeLifecyclePrimaryAction(
+    route: DriverRouteDto,
+    selectedDate: String,
+    today: LocalDate = LocalDate.now(),
+): RouteLifecycleActionUi? =
+    when {
+        canStartRouteFromDriverApp(route, selectedDate, today) -> RouteLifecycleActionUi("Rozpocznij kurs", RouteLifecycleAction.Start)
+        canFinishRouteFromDriverApp(route, selectedDate, today) -> RouteLifecycleActionUi("Zakończ kurs", RouteLifecycleAction.Finish)
+        else -> null
+    }
+
+fun routeSyncCallout(actions: List<RouteActionEntity>): RouteSyncCalloutUi? {
+    val unresolved = actions
+        .filter { it.status in routeActionVisibleStatuses }
+        .maxByOrNull { it.createdAtEpochMillis }
+        ?: return null
+    val isConflict = routeActionNeedsAttention(unresolved.status)
+
+    return RouteSyncCalloutUi(
+        text = if (isConflict) {
+            "Kurs wymaga obsługi. Dane wpisane w telefonie zostały zachowane."
+        } else {
+            when (unresolved.status) {
+                RouteActionStatus.WaitingForPhotos -> "Czekam na wysłanie zdjęć etapu, potem wyślę zmianę statusu."
+                RouteActionStatus.FailedRetryable -> "Nie udało się wysłać. Aplikacja spróbuje ponownie."
+                else -> "Zmiana zapisana w telefonie. Wyślemy ją po odzyskaniu internetu."
+            }
+        },
+        isConflict = isConflict,
+    )
+}
+
+fun routeFlowSteps(route: DriverRouteDto, actions: List<RouteActionEntity>): List<RouteFlowStepUi> {
+    val startOverride = routeActionStepState(actions, RouteActionType.Start)
+    val finishOverride = routeActionStepState(actions, RouteActionType.Finish)
+    val loadingState = startOverride ?: when {
+        route.status == "ZAKOŃCZONA" -> RouteFlowStepState.Confirmed
+        route.status == "W TRAKCIE" -> RouteFlowStepState.Confirmed
+        route.loadingWeight != null -> RouteFlowStepState.LocalComplete
+        else -> RouteFlowStepState.Todo
+    }
+    val transitState = when {
+        route.status == "ZAKOŃCZONA" -> RouteFlowStepState.Confirmed
+        finishOverride == RouteFlowStepState.NeedsAttention -> RouteFlowStepState.LocalComplete
+        finishOverride == RouteFlowStepState.Syncing -> RouteFlowStepState.LocalComplete
+        route.status == "W TRAKCIE" -> RouteFlowStepState.LocalComplete
+        else -> RouteFlowStepState.Todo
+    }
+    val unloadingState = finishOverride ?: when {
+        route.status == "ZAKOŃCZONA" -> RouteFlowStepState.Confirmed
+        route.unloadingWeight != null -> RouteFlowStepState.LocalComplete
+        else -> RouteFlowStepState.Todo
+    }
+
+    return listOf(
+        RouteFlowStepUi("loading", "Załadunek", loadingState, routeFlowStateLabel(loadingState)),
+        RouteFlowStepUi("transit", "W trasie", transitState, routeFlowStateLabel(transitState)),
+        RouteFlowStepUi("unloading", "Rozładunek", unloadingState, routeFlowStateLabel(unloadingState)),
+    )
+}
+
+fun routePhotosForStage(photos: List<RoutePhotoDto>, stage: String): List<RoutePhotoDto> {
+    val normalized = normalizedRoutePhotoStage(stage)
+    return photos.filter { normalizedRoutePhotoStage(it.stage) == normalized }
+}
+
+fun normalizedRoutePhotoStage(stage: String?): String =
+    when (stage) {
+        "loading", "unloading" -> stage
+        else -> "other"
+    }
+
+fun activeRouteUploadIntervalSeconds(
+    isMoving: Boolean,
+    isUrbanOrTurning: Boolean = false,
+    isNearDestination: Boolean = false,
+    isHighwayStable: Boolean = false,
+    isLikelyOffRoute: Boolean = false,
+): Int =
+    when {
+        isLikelyOffRoute -> 3
+        !isMoving -> 45
+        isUrbanOrTurning || isNearDestination -> 5
+        isHighwayStable -> 20
+        else -> 20
+    }
+
+fun activeRouteNotificationTarget(arrived: Boolean): DriverScreen =
+    if (arrived) DriverScreen.FinishRoute else DriverScreen.Detail
+
+private fun routeActionStepState(actions: List<RouteActionEntity>, actionType: String): RouteFlowStepState? {
+    val action = actions
+        .filter { it.action == actionType && it.status in routeActionVisibleStatuses }
+        .maxByOrNull { it.createdAtEpochMillis }
+        ?: return null
+
+    return when (action.status) {
+        RouteActionStatus.FailedConflict,
+        RouteActionStatus.FailedPermanent -> RouteFlowStepState.NeedsAttention
+        else -> RouteFlowStepState.Syncing
+    }
+}
+
+private fun routeFlowStateLabel(state: RouteFlowStepState): String =
+    when (state) {
+        RouteFlowStepState.Todo -> "do zrobienia"
+        RouteFlowStepState.LocalComplete -> "uzupełnione lokalnie"
+        RouteFlowStepState.Syncing -> "synchronizacja"
+        RouteFlowStepState.Confirmed -> "potwierdzone"
+        RouteFlowStepState.NeedsAttention -> "wymaga uwagi"
+    }
+
 fun shouldShowRouteDayLiveUpdate(viewedDate: String, hintDate: String?): Boolean =
     viewedDate.isNotBlank() && (hintDate == null || hintDate == viewedDate)
 
@@ -59,6 +237,18 @@ private fun polishWeekdayPhrase(day: DayOfWeek): String =
 fun inlinePhotoGridRows(photoCount: Int): Int =
     if (photoCount <= 0) 0 else (photoCount + 1) / 2
 
+fun shouldShowPhotoPreviewLoadingState(hasPhoto: Boolean, isLoading: Boolean, isError: Boolean): Boolean =
+    hasPhoto && isLoading && !isError
+
+fun shouldShowPhotoPreviewErrorState(hasPhoto: Boolean, isError: Boolean): Boolean =
+    hasPhoto && isError
+
+fun shouldShowPhotoTileLoadingState(hasPhoto: Boolean, isLoading: Boolean, isError: Boolean): Boolean =
+    hasPhoto && isLoading && !isError
+
+fun shouldShowPhotoTileErrorState(hasPhoto: Boolean, isError: Boolean): Boolean =
+    hasPhoto && isError
+
 fun authBrandBannerHeightDp(screenHeightDp: Int): Int =
     when {
         screenHeightDp < 640 -> 118
@@ -126,6 +316,7 @@ fun localUploadPreviewPhoto(upload: PhotoUploadEntity): RoutePhotoDto? {
         clientRequestId = upload.clientRequestId,
         contentSha256 = upload.contentSha256,
         source = upload.source,
+        stage = normalizedRoutePhotoStage(upload.stage),
         mimeType = upload.mimeType,
         size = upload.size,
         url = File(upload.localPath).toURI().toString(),
@@ -152,6 +343,15 @@ fun dispatchSheetPrimaryActionLabel(reminder: DispatchSheetReminderDto?, hasQueu
         else -> "Zrób zdjęcie"
     }
 
+fun offlineStaleBannerMessage(isOnline: Boolean, isStale: Boolean, syncLabel: String): String? =
+    when {
+        isOnline && !isStale -> null
+        !isOnline && syncLabel == "brak zapisanej synchronizacji" ->
+            "Brak połączenia z serwerem. Sprawdź internet i spróbuj ponownie."
+        !isOnline -> "Brak połączenia z serwerem. Dane z $syncLabel mogą być nieaktualne."
+        else -> "Dane mogą być nieaktualne. Ostatnia synchronizacja: $syncLabel."
+    }
+
 private fun parseIsoOffsetEpochMillis(value: String?): Long? =
     value?.takeIf { it.isNotBlank() }?.let {
         runCatching { OffsetDateTime.parse(it).toInstant().toEpochMilli() }.getOrNull()

app/src/main/java/pl/firmatpp/kierowca/ui/DriverViewModel.kt

@@ -11,6 +11,8 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import java.time.LocalDate
+import java.time.Instant
+import pl.firmatpp.kierowca.data.AppPreferencesStore
 import pl.firmatpp.kierowca.data.ApiErrorMapper
 import pl.firmatpp.kierowca.data.ApiErrorKind
 import pl.firmatpp.kierowca.data.DriverRepository
@@ -26,12 +28,16 @@ import pl.firmatpp.kierowca.data.upload.DispatchSheetUploadEntity
 import pl.firmatpp.kierowca.data.upload.DispatchSheetUploadOutbox
 import pl.firmatpp.kierowca.data.upload.PhotoUploadEntity
 import pl.firmatpp.kierowca.data.upload.PhotoUploadOutbox
+import pl.firmatpp.kierowca.data.upload.RouteActionEntity
+import pl.firmatpp.kierowca.data.upload.RouteActionOutbox
 import pl.firmatpp.kierowca.diagnostics.AppDiagnostics
 import pl.firmatpp.kierowca.sync.DriverLiveSyncClient
 import pl.firmatpp.kierowca.sync.DriverSyncHint
 import pl.firmatpp.kierowca.sync.DriverSyncWorker
+import pl.firmatpp.kierowca.tracking.ActiveRouteTrackingService
+import pl.firmatpp.kierowca.ui.theme.AppThemeMode
 
-enum class DriverScreen { Initializing, Phone, Otp, Routes, Profile, Detail, Photo, PhotoQueue, LeaveRequests, LeaveRequestDetail, AddLeaveRequest }
+enum class DriverScreen { Initializing, Phone, Otp, Routes, Profile, Detail, StartRoute, FinishRoute, Photo, PhotoQueue, LeaveRequests, LeaveRequestDetail, AddLeaveRequest }
 
 data class DriverUiState(
     val screen: DriverScreen = DriverScreen.Initializing,
@@ -50,9 +56,13 @@ data class DriverUiState(
     val allowRouteCompletion: Boolean = false,
     val requirePreciseLocationForPhotos: Boolean = false,
     val notifyNewRoutes: Boolean = false,
+    val routeProgressNotificationEnabled: Boolean = true,
     val notificationPermissionDenied: Boolean = false,
     val selectedRoute: DriverRouteDto? = null,
     val selectedPhoto: RoutePhotoDto? = null,
+    val routeStageWeightText: String = "",
+    val routeActions: List<RouteActionEntity> = emptyList(),
+    val visibleRouteActions: List<RouteActionEntity> = emptyList(),
     val photoUploads: List<PhotoUploadEntity> = emptyList(),
     val queuedPhotoUploads: List<PhotoUploadEntity> = emptyList(),
     val dispatchSheetReminder: DispatchSheetReminderDto? = null,
@@ -71,15 +81,54 @@ data class DriverUiState(
     val isStale: Boolean = false,
     val lastSuccessfulSyncAtEpochMillis: Long? = null,
     val routeDayLiveUpdateMessage: String? = null,
+    val themeMode: AppThemeMode = AppThemeMode.Default,
     val feedback: String? = null,
     val error: String? = null,
+) {
+    private val projectionActions: List<RouteActionEntity>
+        get() = (visibleRouteActions + routeActions).distinctBy { it.clientActionId }
+
+    val displayRoutes: List<DriverRouteDto>
+        get() = projectDriverRoutes(routes, projectionActions)
+
+    val selectedRouteProjection: ProjectedDriverRoute?
+        get() = selectedRoute?.let { projectDriverRoute(it, projectionActions) }
+
+    val displaySelectedRoute: DriverRouteDto?
+        get() = selectedRouteProjection?.route
+}
+
+private fun DriverUiState.withApiError(throwable: Throwable): DriverUiState {
+    val apiError = ApiErrorMapper.map(throwable)
+    return copy(
+        isOnline = if (apiError.kind == ApiErrorKind.Network) false else isOnline,
+        isStale = if (apiError.kind == ApiErrorKind.Network && lastSuccessfulSyncAtEpochMillis != null) true else isStale,
+        error = apiError.message,
     )
+}
+
+internal fun DriverUiState.withLoadedLeaveRequests(
+    requests: List<DriverLeaveRequestDto>,
+    navigateToList: Boolean,
+): DriverUiState {
+    val refreshedSelectedRequest = selectedLeaveRequest?.let { selected ->
+        requests.firstOrNull { request -> request.id == selected.id } ?: selected
+    }
+    return copy(
+        screen = if (navigateToList) DriverScreen.LeaveRequests else screen,
+        leaveRequests = requests,
+        selectedLeaveRequest = refreshedSelectedRequest,
+        error = null,
+    )
+}
 
 class DriverViewModel(application: Application) : AndroidViewModel(application) {
+    private val appPreferencesStore = AppPreferencesStore(application)
     private val repository = DriverRepository(application)
     private val syncRepository = DriverSyncRepository(application, repository)
     private val networkMonitor = NetworkMonitor(application)
     private val photoUploadOutbox = PhotoUploadOutbox(application)
+    private val routeActionOutbox = RouteActionOutbox(application)
     private val dispatchSheetUploadOutbox = DispatchSheetUploadOutbox(application)
     private val _state = MutableStateFlow(DriverUiState(loading = true))
     private val otpAutoSubmitPolicy = OtpAutoSubmitPolicy()
@@ -89,18 +138,35 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         onHint = { hint -> viewModelScope.launch { handleSyncHint(hint) } },
     )
     private var photoUploadsJob: Job? = null
+    private var routeActionsJob: Job? = null
     private var dispatchSheetUploadsJob: Job? = null
     private var pushTokenRegisteredForDriverId: String? = null
     val state: StateFlow<DriverUiState> = _state
 
     init {
+        viewModelScope.launch {
+            appPreferencesStore.themeMode.collect { themeMode ->
+                _state.update { it.copy(themeMode = themeMode) }
+            }
+        }
+        viewModelScope.launch {
+            appPreferencesStore.routeProgressNotificationEnabled.collect { enabled ->
+                _state.update { it.copy(routeProgressNotificationEnabled = enabled) }
+            }
+        }
         viewModelScope.launch {
             photoUploadOutbox.observeQueuedUploads().collect { uploads ->
                 _state.update { it.copy(queuedPhotoUploads = uploads) }
             }
         }
+        viewModelScope.launch {
+            routeActionOutbox.observeVisibleActions().collect { actions ->
+                _state.update { it.copy(visibleRouteActions = actions) }
+            }
+        }
         viewModelScope.launch {
             networkMonitor.isOnline.collect { online ->
+                liveSyncClient.onNetworkAvailable(online)
                 _state.update {
                     it.copy(
                         isOnline = online,
@@ -108,6 +174,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                     )
                 }
                 if (online && repository.hasToken()) {
+                    liveSyncClient.ensureConnected()
                     refreshCurrentScopeFromSyncState()
                 }
             }
@@ -155,6 +222,14 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
 
     fun refreshRoutesSilently() = loadRoutes(date = _state.value.selectedDate, showLoading = false, navigateToRoutes = false)
 
+    fun onAppForegrounded() {
+        liveSyncClient.ensureConnected()
+        viewModelScope.launch { checkRemoteSyncState() }
+        if (_state.value.screen == DriverScreen.Routes) {
+            refreshRoutesSilently()
+        }
+    }
+
     fun selectRouteDate(date: String) {
         _state.update { it.copy(routeDayLiveUpdateMessage = null) }
         loadRoutes(date = date, showLoading = true, navigateToRoutes = true)
@@ -209,14 +284,12 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                 reportHandledException("load_routes", throwable, mapOf("date" to date))
                 _state.update {
                     val apiError = ApiErrorMapper.map(throwable)
-                    it.copy(
+                    it.withApiError(throwable).copy(
                         screen = when {
                             apiError.kind == ApiErrorKind.Auth -> DriverScreen.Phone
                             it.screen == DriverScreen.Initializing -> DriverScreen.Routes
                             else -> it.screen
                         },
-                        isStale = it.lastSuccessfulSyncAtEpochMillis != null,
-                        error = apiError.message,
                     )
                 }
             }
@@ -227,14 +300,21 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         }
     }
 
-    fun openRoute(routeId: String) = runLoading("open_route", mapOf("route_id" to routeId)) {
+    fun openRoute(routeId: String) = openRouteWithTarget(routeId, DriverScreen.Detail)
+
+    private fun openRouteWithTarget(routeId: String, targetScreen: DriverScreen) = runLoading("open_route", mapOf("route_id" to routeId)) {
         val cached = syncRepository.route(routeId)
         val response = cached.value
         photoUploadOutbox.discardConfirmedServerPhotos(response.route)
         _state.update {
             it.copy(
-                screen = DriverScreen.Detail,
+                screen = targetScreen,
                 selectedRoute = response.route,
+                routeStageWeightText = when (targetScreen) {
+                    DriverScreen.StartRoute -> response.route.loadingWeight?.toString().orEmpty()
+                    DriverScreen.FinishRoute -> response.route.unloadingWeight?.toString().orEmpty()
+                    else -> it.routeStageWeightText
+                },
                 feedback = null,
                 isStale = cached.stale || !it.isOnline,
                 lastSuccessfulSyncAtEpochMillis = cached.syncedAtEpochMillis ?: it.lastSuccessfulSyncAtEpochMillis,
@@ -242,6 +322,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
             )
         }
         observePhotoUploads(routeId)
+        observeRouteActions(routeId)
     }
 
     fun refreshSelectedRoute() {
@@ -265,7 +346,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                     }
                 }
                 .onFailure { throwable ->
-                    _state.update { it.copy(error = throwable.message ?: "Wystapil blad.") }
+                    _state.update { it.withApiError(throwable) }
                 }
 
             _state.update { it.copy(refreshing = false) }
@@ -290,7 +371,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                     }
                 }
                 .onFailure { throwable ->
-                    _state.update { it.copy(error = ApiErrorMapper.map(throwable).message) }
+                    _state.update { it.withApiError(throwable) }
                 }
             _state.update { it.copy(refreshing = false) }
         }
@@ -306,35 +387,44 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         }
     }
 
+    fun setThemeMode(themeMode: AppThemeMode) {
+        _state.update { it.copy(themeMode = themeMode) }
+        viewModelScope.launch {
+            runCatching { appPreferencesStore.setThemeMode(themeMode) }
+                .onFailure { throwable -> _state.update { it.withApiError(throwable) } }
+        }
+    }
+
+    fun setRouteProgressNotificationEnabled(enabled: Boolean) {
+        _state.update { it.copy(routeProgressNotificationEnabled = enabled) }
+        viewModelScope.launch {
+            runCatching { appPreferencesStore.setRouteProgressNotificationEnabled(enabled) }
+                .onFailure { throwable -> _state.update { it.withApiError(throwable) } }
+        }
+    }
+
     fun openPhotoQueue() {
         _state.update { it.copy(screen = DriverScreen.PhotoQueue, error = null) }
     }
 
     fun openLeaveRequests() {
         if (!DriverLeaveRequestUiRules.isFeatureVisible(_state.value.leaveRequestsConfig)) return
-        loadLeaveRequests(showLoading = true)
+        loadLeaveRequests(showLoading = true, navigateToList = true)
     }
 
     fun refreshLeaveRequests() {
         if (!DriverLeaveRequestUiRules.isFeatureVisible(_state.value.leaveRequestsConfig)) return
-        loadLeaveRequests(showLoading = false)
+        loadLeaveRequests(showLoading = false, navigateToList = false)
     }
 
-    private fun loadLeaveRequests(showLoading: Boolean) {
+    private fun loadLeaveRequests(showLoading: Boolean, navigateToList: Boolean) {
         viewModelScope.launch {
             _state.update { it.copy(loading = showLoading, refreshing = !showLoading, error = null, feedback = null) }
             runCatching { repository.leaveRequests() }
                 .onSuccess { requests ->
-                    _state.update {
-                        it.copy(
-                            screen = DriverScreen.LeaveRequests,
-                            leaveRequests = requests,
-                            selectedLeaveRequest = requests.firstOrNull { request -> request.id == it.selectedLeaveRequest?.id } ?: it.selectedLeaveRequest,
-                            error = null,
-                        )
+                    _state.update { it.withLoadedLeaveRequests(requests, navigateToList) }
                 }
-                }
-                .onFailure { throwable -> _state.update { it.copy(error = ApiErrorMapper.map(throwable).message) } }
+                .onFailure { throwable -> _state.update { it.withApiError(throwable) } }
             _state.update { it.copy(loading = false, refreshing = false) }
         }
     }
@@ -347,7 +437,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                 .onSuccess { request ->
                     _state.update { it.copy(screen = DriverScreen.LeaveRequestDetail, selectedLeaveRequest = request, error = null) }
                 }
-                .onFailure { throwable -> _state.update { it.copy(error = ApiErrorMapper.map(throwable).message) } }
+                .onFailure { throwable -> _state.update { it.withApiError(throwable) } }
             _state.update { it.copy(loading = false) }
         }
     }
@@ -411,7 +501,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                     )
                 }
             }.onFailure { throwable ->
-                _state.update { it.copy(error = ApiErrorMapper.map(throwable).message) }
+                _state.update { it.withApiError(throwable) }
             }
             _state.update { it.copy(loading = false) }
         }
@@ -434,22 +524,148 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                         )
                     }
                 }
-                .onFailure { throwable -> _state.update { it.copy(error = ApiErrorMapper.map(throwable).message) } }
+                .onFailure { throwable -> _state.update { it.withApiError(throwable) } }
             _state.update { it.copy(loading = false) }
         }
     }
 
-    fun uploadPhoto(uri: Uri, source: String, metadata: PhotoUploadMetadata = PhotoUploadMetadata()) {
+    fun uploadPhoto(uri: Uri, source: String, metadata: PhotoUploadMetadata = PhotoUploadMetadata(), stage: String = "other") {
         val route = _state.value.selectedRoute ?: return
         viewModelScope.launch {
             _state.update { it.copy(error = null) }
-            runCatching { photoUploadOutbox.enqueue(route.id, uri, source, metadata) }
+            runCatching { photoUploadOutbox.enqueue(route.id, uri, source, metadata, stage) }
                 .onFailure { throwable ->
-                    _state.update { it.copy(error = ApiErrorMapper.map(throwable).message) }
+                    _state.update { it.withApiError(throwable) }
                 }
         }
     }
 
+    fun openStartRoute() {
+        val route = _state.value.selectedRoute ?: return
+        _state.update {
+            it.copy(
+                screen = DriverScreen.StartRoute,
+                routeStageWeightText = route.loadingWeight?.toString().orEmpty(),
+                feedback = null,
+                error = null,
+            )
+        }
+    }
+
+    fun openFinishRoute() {
+        val route = _state.value.selectedRoute ?: return
+        _state.update {
+            it.copy(
+                screen = DriverScreen.FinishRoute,
+                routeStageWeightText = route.unloadingWeight?.toString().orEmpty(),
+                feedback = null,
+                error = null,
+            )
+        }
+    }
+
+    fun updateRouteStageWeight(value: String) {
+        val normalized = value.filter { it.isDigit() || it == ',' || it == '.' }.take(8)
+        _state.update { it.copy(routeStageWeightText = normalized) }
+    }
+
+    fun submitStartRoute() {
+        submitRouteStage(stage = "loading")
+    }
+
+    fun submitFinishRoute() {
+        submitRouteStage(stage = "unloading")
+    }
+
+    private fun submitRouteStage(stage: String) {
+        val snapshot = _state.value
+        val route = snapshot.selectedRoute ?: return
+        val driver = snapshot.driver
+        val weight = snapshot.routeStageWeightText.trim().replace(',', '.').toDoubleOrNull()
+        val stagePhotos = routePhotosForStage(route.photos, stage)
+        val stageUploads = snapshot.photoUploads.filter { normalizedRoutePhotoStage(it.stage) == stage }
+
+        if (
+            weight == null ||
+            !canSubmitRouteStageForm(
+                weightText = snapshot.routeStageWeightText,
+                serverPhotoCount = stagePhotos.size,
+                localUploadCount = stageUploads.size,
+            )
+        ) {
+            _state.update { it.copy(error = "Podaj wagę i dodaj co najmniej jedno zdjęcie.") }
+            return
+        }
+
+        val photoClientRequestIds = (stagePhotos.mapNotNull { it.clientRequestId } + stageUploads.map { it.clientRequestId })
+            .map { it.trim() }
+            .filter { it.isNotBlank() }
+            .distinct()
+
+        if (photoClientRequestIds.isEmpty()) {
+            _state.update { it.copy(error = "Zdjęcie musi mieć lokalny identyfikator synchronizacji.") }
+            return
+        }
+
+        viewModelScope.launch {
+            _state.update { it.copy(loading = true, error = null, feedback = null) }
+            runCatching {
+                val updatedRoute = when (stage) {
+                    "loading" -> {
+                        routeActionOutbox.enqueueStart(route.id, weight, photoClientRequestIds)
+                        route.copy(
+                            status = "W TRAKCIE",
+                            loadingWeight = weight,
+                            trackingStatus = "active",
+                        )
+                    }
+                    "unloading" -> {
+                        routeActionOutbox.enqueueFinish(route.id, weight, photoClientRequestIds)
+                        route.copy(
+                            status = "ZAKOŃCZONA",
+                            unloadingWeight = weight,
+                            trackingStatus = "finished",
+                            completedAt = Instant.now().toString(),
+                        )
+                    }
+                    else -> route
+                }
+
+                syncRepository.cacheConfirmedRoute(updatedRoute, snapshot.selectedDate)
+                _state.update {
+                    it.copy(
+                        screen = DriverScreen.Detail,
+                        selectedRoute = updatedRoute,
+                        routes = it.routes.map { item -> if (item.id == route.id) updatedRoute else item },
+                        routeStageWeightText = "",
+                        feedback = if (stage == "loading") {
+                            "Kurs rozpoczęty lokalnie. Synchronizacja pójdzie w tle."
+                        } else {
+                            "Kurs zakończony lokalnie. Synchronizacja pójdzie w tle."
+                        },
+                        error = null,
+                    )
+                }
+
+                if (stage == "loading" && driver != null) {
+                    ActiveRouteTrackingService.start(
+                        context = getApplication(),
+                        route = updatedRoute,
+                        driver = driver,
+                        progressEnabled = snapshot.routeProgressNotificationEnabled,
+                    )
+                }
+                if (stage == "unloading") {
+                    ActiveRouteTrackingService.stop(getApplication())
+                }
+            }.onFailure { throwable ->
+                reportHandledException("submit_route_stage", throwable, mapOf("route_id" to route.id, "stage" to stage))
+                _state.update { it.withApiError(throwable) }
+            }
+            _state.update { it.copy(loading = false) }
+        }
+    }
+
     fun uploadDispatchSheetPhoto(uri: Uri, source: String, metadata: PhotoUploadMetadata = PhotoUploadMetadata()) {
         val reminder = _state.value.dispatchSheetReminder ?: return
         val workDate = reminder.workDate ?: return
@@ -466,7 +682,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                     metadata = metadata,
                 )
             }.onFailure { throwable ->
-                _state.update { it.copy(error = ApiErrorMapper.map(throwable).message) }
+                _state.update { it.withApiError(throwable) }
             }
         }
     }
@@ -475,7 +691,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         viewModelScope.launch {
             runCatching { photoUploadOutbox.retry(upload.clientRequestId) }
                 .onFailure { throwable ->
-                    _state.update { it.copy(error = ApiErrorMapper.map(throwable).message) }
+                    _state.update { it.withApiError(throwable) }
                 }
         }
     }
@@ -496,7 +712,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                     )
                 }
             }.onFailure { throwable ->
-                _state.update { it.copy(error = ApiErrorMapper.map(throwable).message) }
+                _state.update { it.withApiError(throwable) }
             }
             _state.update { it.copy(deletingPhotoIds = it.deletingPhotoIds - photo.id) }
         }
@@ -521,7 +737,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                     )
                 }
             }.onFailure { throwable ->
-                _state.update { it.copy(error = ApiErrorMapper.map(throwable).message) }
+                _state.update { it.withApiError(throwable) }
             }
             _state.update { it.copy(deletingPhotoIds = it.deletingPhotoIds - serverPhotoId) }
         }
@@ -552,7 +768,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                     )
                 }
             }.onFailure { throwable ->
-                _state.update { it.copy(feedback = null, error = ApiErrorMapper.map(throwable).message) }
+                _state.update { it.withApiError(throwable).copy(feedback = null) }
             }
             _state.update { it.copy(completingRoute = false) }
         }
@@ -562,9 +778,10 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         _state.update { it.copy(screen = DriverScreen.Photo, selectedPhoto = photo) }
     }
 
-    fun openRouteFromNotification(routeId: String?) {
+    fun openRouteFromNotification(routeId: String?, target: String? = null) {
         if (routeId.isNullOrBlank()) return
-        openRoute(routeId)
+        val targetScreen = if (target == "finish") DriverScreen.FinishRoute else DriverScreen.Detail
+        openRouteWithTarget(routeId, targetScreen)
     }
 
     fun back() {
@@ -572,12 +789,15 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
             when (it.screen) {
                 DriverScreen.Photo -> it.copy(screen = DriverScreen.Detail, selectedPhoto = null)
                 DriverScreen.PhotoQueue -> it.copy(screen = DriverScreen.Routes)
+                DriverScreen.StartRoute -> it.copy(screen = DriverScreen.Detail, routeStageWeightText = "", feedback = null)
+                DriverScreen.FinishRoute -> it.copy(screen = DriverScreen.Detail, routeStageWeightText = "", feedback = null)
                 DriverScreen.LeaveRequests -> it.copy(screen = DriverScreen.Routes)
                 DriverScreen.LeaveRequestDetail -> it.copy(screen = DriverScreen.LeaveRequests, selectedLeaveRequest = null, feedback = null)
                 DriverScreen.AddLeaveRequest -> it.copy(screen = DriverScreen.LeaveRequests, feedback = null)
                 DriverScreen.Detail -> {
                     photoUploadsJob?.cancel()
-                    it.copy(screen = DriverScreen.Routes, selectedRoute = null, photoUploads = emptyList(), feedback = null)
+                    routeActionsJob?.cancel()
+                    it.copy(screen = DriverScreen.Routes, selectedRoute = null, routeActions = emptyList(), photoUploads = emptyList(), feedback = null)
                 }
                 DriverScreen.Profile -> it.copy(screen = DriverScreen.Routes)
                 DriverScreen.Otp -> it.copy(screen = DriverScreen.Phone)
@@ -588,6 +808,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
 
     fun logout() = runLoading("logout") {
         photoUploadsJob?.cancel()
+        routeActionsJob?.cancel()
         dispatchSheetUploadsJob?.cancel()
         liveSyncClient.stop()
         repository.logout()
@@ -607,7 +828,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
             runCatching { block() }
                 .onFailure { throwable ->
                     reportHandledException(operation, throwable, keys)
-                    _state.update { it.copy(error = ApiErrorMapper.map(throwable).message) }
+                    _state.update { it.withApiError(throwable) }
                 }
             _state.update { it.copy(loading = false) }
         }
@@ -622,6 +843,15 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         }
     }
 
+    private fun observeRouteActions(routeId: String) {
+        routeActionsJob?.cancel()
+        routeActionsJob = viewModelScope.launch {
+            routeActionOutbox.observeUnresolvedForRoute(routeId).collect { actions ->
+                _state.update { it.copy(routeActions = actions) }
+            }
+        }
+    }
+
     private fun observeDispatchSheetUploads(workDate: String?) {
         dispatchSheetUploadsJob?.cancel()
         if (workDate.isNullOrBlank()) {
@@ -724,6 +954,10 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         keys: Map<String, Any?> = emptyMap(),
     ) {
         val apiError = ApiErrorMapper.map(throwable)
+        if (!ApiErrorMapper.shouldReportNonFatal(throwable)) {
+            AppDiagnostics.log("network_failure: $operation: ${throwable.message ?: throwable::class.java.simpleName}")
+            return
+        }
         AppDiagnostics.reportNonFatal(
             throwable = throwable,
             operation = operation,
@@ -739,6 +973,8 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
 
     override fun onCleared() {
         liveSyncClient.close()
+        photoUploadsJob?.cancel()
+        routeActionsJob?.cancel()
         dispatchSheetUploadsJob?.cancel()
         super.onCleared()
     }

app/src/main/java/pl/firmatpp/kierowca/ui/theme/AppThemeMode.kt

@@ -0,0 +1,13 @@
+package pl.firmatpp.kierowca.ui.theme
+
+enum class AppThemeMode(val storedValue: String) {
+    Current("current"),
+    Material3("material3");
+
+    companion object {
+        val Default: AppThemeMode = Material3
+
+        fun fromStoredValue(value: String?): AppThemeMode =
+            entries.firstOrNull { it.storedValue == value } ?: Default
+    }
+}

app/src/main/java/pl/firmatpp/kierowca/ui/theme/Theme.kt

@@ -1,9 +1,20 @@
 package pl.firmatpp.kierowca.ui.theme
 
+import android.app.Activity
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Shapes
 import androidx.compose.material3.lightColorScheme
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.ReadOnlyComposable
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.unit.dp
+import androidx.core.view.WindowCompat
 
 object TppColors {
     val Forest = Color(0xFF154212)
@@ -18,7 +29,71 @@ object TppColors {
     val Error = Color(0xFFBA1A1A)
 }
 
-private val TppScheme = lightColorScheme(
+@Immutable
+data class TppColorTokens(
+    val forest: Color,
+    val containerGreen: Color,
+    val logoLeaf: Color,
+    val navy: Color,
+    val surface: Color,
+    val panel: Color,
+    val ink: Color,
+    val muted: Color,
+    val outline: Color,
+    val error: Color,
+    val card: Color,
+    val successContainer: Color,
+    val successOutline: Color,
+    val warningContainer: Color,
+    val warningOutline: Color,
+)
+
+object TppTheme {
+    val colors: TppColorTokens
+        @Composable
+        @ReadOnlyComposable
+        get() = LocalTppColorTokens.current
+}
+
+private val CurrentColorTokens = TppColorTokens(
+    forest = TppColors.Forest,
+    containerGreen = TppColors.ContainerGreen,
+    logoLeaf = TppColors.LogoLeaf,
+    navy = TppColors.Navy,
+    surface = TppColors.Surface,
+    panel = TppColors.Panel,
+    ink = TppColors.Ink,
+    muted = TppColors.Muted,
+    outline = TppColors.Outline,
+    error = TppColors.Error,
+    card = Color.White,
+    successContainer = Color(0xFFEAF7EF),
+    successOutline = Color(0xFF9BD1AD),
+    warningContainer = Color(0xFFFFF7E6),
+    warningOutline = Color(0xFFE6B85C),
+)
+
+private val Material3ColorTokens = TppColorTokens(
+    forest = Color(0xFF226C2C),
+    containerGreen = Color(0xFF2F7D32),
+    logoLeaf = Color(0xFF5FA642),
+    navy = Color(0xFF225A86),
+    surface = Color(0xFFF8FBF6),
+    panel = Color(0xFFEAF1E6),
+    ink = Color(0xFF172018),
+    muted = Color(0xFF566252),
+    outline = Color(0xFFBAC8B5),
+    error = Color(0xFFBA1A1A),
+    card = Color(0xFFFFFFFF),
+    successContainer = Color(0xFFDFF4E2),
+    successOutline = Color(0xFF8EC69A),
+    warningContainer = Color(0xFFFFF1D6),
+    warningOutline = Color(0xFFE4B45B),
+)
+
+private val LocalTppColorTokens = staticCompositionLocalOf { CurrentColorTokens }
+
+private val CurrentScheme = lightColorScheme(
     primary = TppColors.Forest,
     onPrimary = Color.White,
     primaryContainer = TppColors.ContainerGreen,
@@ -33,10 +108,71 @@ private val TppScheme = lightColorScheme(
     error = TppColors.Error,
 )
 
+private val Material3Scheme = lightColorScheme(
+    primary = Material3ColorTokens.forest,
+    onPrimary = Color.White,
+    primaryContainer = Material3ColorTokens.containerGreen,
+    onPrimaryContainer = Color.White,
+    secondary = Material3ColorTokens.navy,
+    onSecondary = Color.White,
+    secondaryContainer = Color(0xFFD2E7F7),
+    onSecondaryContainer = Color(0xFF071E30),
+    tertiary = Color(0xFF7A5D00),
+    onTertiary = Color.White,
+    tertiaryContainer = Color(0xFFFFE08A),
+    background = Material3ColorTokens.surface,
+    onBackground = Material3ColorTokens.ink,
+    surface = Material3ColorTokens.surface,
+    onSurface = Material3ColorTokens.ink,
+    surfaceVariant = Material3ColorTokens.panel,
+    onSurfaceVariant = Material3ColorTokens.muted,
+    outline = Material3ColorTokens.outline,
+    outlineVariant = Color(0xFFD5DED1),
+    error = Material3ColorTokens.error,
+)
+
+private val CurrentShapes = Shapes(
+    extraSmall = androidx.compose.foundation.shape.RoundedCornerShape(2.dp),
+    small = androidx.compose.foundation.shape.RoundedCornerShape(4.dp),
+    medium = androidx.compose.foundation.shape.RoundedCornerShape(8.dp),
+    large = androidx.compose.foundation.shape.RoundedCornerShape(8.dp),
+    extraLarge = androidx.compose.foundation.shape.RoundedCornerShape(12.dp),
+)
+
+private val Material3Shapes = Shapes(
+    extraSmall = androidx.compose.foundation.shape.RoundedCornerShape(8.dp),
+    small = androidx.compose.foundation.shape.RoundedCornerShape(12.dp),
+    medium = androidx.compose.foundation.shape.RoundedCornerShape(20.dp),
+    large = androidx.compose.foundation.shape.RoundedCornerShape(28.dp),
+    extraLarge = androidx.compose.foundation.shape.RoundedCornerShape(32.dp),
+)
+
 @Composable
-fun TppKierowcaTheme(content: @Composable () -> Unit) {
+@Suppress("DEPRECATION")
+fun TppKierowcaTheme(
+    themeMode: AppThemeMode = AppThemeMode.Default,
+    content: @Composable () -> Unit,
+) {
+    val colorTokens = if (themeMode == AppThemeMode.Material3) Material3ColorTokens else CurrentColorTokens
+    val colorScheme = if (themeMode == AppThemeMode.Material3) Material3Scheme else CurrentScheme
+    val shapes = if (themeMode == AppThemeMode.Material3) Material3Shapes else CurrentShapes
+    val view = LocalView.current
+
+    if (!view.isInEditMode) {
+        SideEffect {
+            val window = (view.context as? Activity)?.window ?: return@SideEffect
+            window.statusBarColor = colorTokens.surface.toArgb()
+            window.navigationBarColor = colorTokens.surface.toArgb()
+            WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = true
+            WindowCompat.getInsetsController(window, view).isAppearanceLightNavigationBars = true
+        }
+    }
+
+    CompositionLocalProvider(LocalTppColorTokens provides colorTokens) {
         MaterialTheme(
-        colorScheme = TppScheme,
+            colorScheme = colorScheme,
+            shapes = shapes,
             content = content,
         )
     }
+}

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

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="Theme.ITSTransport" parent="android:Theme.Material.Light.NoActionBar" />
+</resources>

app/src/test/java/pl/firmatpp/kierowca/data/ApiErrorMapperTest.kt

@@ -1,6 +1,7 @@
 package pl.firmatpp.kierowca.data
 
 import java.io.IOException
+import java.net.UnknownHostException
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
@@ -16,6 +17,23 @@ class ApiErrorMapperTest {
         assertEquals("Nie udało się połączyć z serwerem. Operacja nie została potwierdzona.", error.message)
     }
 
+    @Test
+    fun mapsUnknownHostToActionableOfflineMessage() {
+        val error = ApiErrorMapper.map(UnknownHostException("api-intranet.firmatpp.pl"))
+
+        assertEquals(ApiErrorKind.Network, error.kind)
+        assertTrue(error.retryable)
+        assertEquals(
+            "Brak internetu lub połączenia z serwerem. Sprawdź zasięg i spróbuj ponownie.",
+            error.message,
+        )
+    }
+
+    @Test
+    fun doesNotReportExpectedNetworkFailuresAsNonFatal() {
+        assertFalse(ApiErrorMapper.shouldReportNonFatal(UnknownHostException("api-intranet.firmatpp.pl")))
+    }
+
     @Test
     fun mapsMobileApiProblemCodes() {
         val error = ApiErrorMapper.mapProblem(

app/src/test/java/pl/firmatpp/kierowca/data/AppPreferencesStoreTest.kt

@@ -0,0 +1,44 @@
+package pl.firmatpp.kierowca.data
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import java.io.File
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import pl.firmatpp.kierowca.ui.theme.AppThemeMode
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class AppPreferencesStoreTest {
+    @get:Rule
+    val temporaryFolder = TemporaryFolder()
+
+    @Test
+    fun startsWithMaterial3ThemeMode() = runTest {
+        val store = preferencesStore("default.preferences_pb")
+
+        assertEquals(AppThemeMode.Material3, store.themeMode.first())
+    }
+
+    @Test
+    fun persistsSelectedThemeMode() = runTest {
+        val file = temporaryFolder.newFile("theme.preferences_pb")
+        val store = preferencesStore(file)
+
+        store.setThemeMode(AppThemeMode.Material3)
+
+        assertEquals(AppThemeMode.Material3, store.themeMode.first())
+    }
+
+    private fun TestScope.preferencesStore(fileName: String): AppPreferencesStore =
+        preferencesStore(temporaryFolder.newFile(fileName))
+
+    private fun TestScope.preferencesStore(file: File): AppPreferencesStore {
+        val dataStore = PreferenceDataStoreFactory.create(scope = backgroundScope) { file }
+        return AppPreferencesStore(dataStore)
+    }
+}

app/src/test/java/pl/firmatpp/kierowca/sync/DriverLiveSyncClientTest.kt

@@ -0,0 +1,217 @@
+package pl.firmatpp.kierowca.sync
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.runCurrent
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import okio.ByteString
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import pl.firmatpp.kierowca.data.model.BroadcastAuthResponse
+import pl.firmatpp.kierowca.data.model.RealtimeConfigDto
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class DriverLiveSyncClientTest {
+    private val config = RealtimeConfigDto(
+        reverbEnabled = true,
+        reverbAppKey = "app-key",
+        reverbWsBaseUrl = "wss://example.test/app",
+    )
+
+    @Test
+    fun reconnectsWithBackoffAfterSocketFailure() = runTest {
+        val factory = FakeWebSocketFactory()
+        val client = liveClient(factory = factory, scope = backgroundScope)
+
+        client.start("driver-1", config)
+        factory.sockets.single().fail()
+
+        advanceTimeBy(999)
+        assertEquals(1, factory.sockets.size)
+
+        advanceTimeBy(1)
+        runCurrent()
+        assertEquals(2, factory.sockets.size)
+
+        factory.sockets.last().fail()
+        advanceTimeBy(1_999)
+        assertEquals(2, factory.sockets.size)
+
+        advanceTimeBy(1)
+        runCurrent()
+        assertEquals(3, factory.sockets.size)
+    }
+
+    @Test
+    fun pausesReconnectWhileOfflineAndReconnectsImmediatelyWhenNetworkReturns() = runTest {
+        val factory = FakeWebSocketFactory()
+        val client = liveClient(factory = factory, scope = backgroundScope)
+
+        client.start("driver-1", config)
+        client.onNetworkAvailable(false)
+        factory.sockets.single().fail()
+
+        advanceTimeBy(10_000)
+        assertEquals(1, factory.sockets.size)
+        assertTrue(factory.sockets.single().closed)
+
+        client.onNetworkAvailable(true)
+        advanceUntilIdle()
+
+        assertEquals(2, factory.sockets.size)
+    }
+
+    @Test
+    fun foregroundEnsureConnectedRestartsWhenSocketIsDisconnected() = runTest {
+        val factory = FakeWebSocketFactory()
+        val client = liveClient(factory = factory, scope = backgroundScope)
+
+        client.start("driver-1", config)
+        factory.sockets.single().fail()
+        client.ensureConnected()
+        advanceUntilIdle()
+
+        assertEquals(2, factory.sockets.size)
+    }
+
+    @Test
+    fun retriesWhenPrivateChannelSubscriptionAuthFails() = runTest {
+        val gateway = FakeLiveSyncGateway(authFailure = RuntimeException("offline"))
+        val factory = FakeWebSocketFactory()
+        val client = liveClient(gateway = gateway, factory = factory, scope = backgroundScope)
+
+        client.start("driver-1", config)
+        factory.sockets.single().message(connectionEstablished("socket-1"))
+        advanceUntilIdle()
+        advanceTimeBy(1_000)
+        runCurrent()
+
+        assertEquals(2, factory.sockets.size)
+    }
+
+    @Test
+    fun respondsToPusherPingWithPong() = runTest {
+        val factory = FakeWebSocketFactory()
+        val client = liveClient(factory = factory, scope = backgroundScope)
+
+        client.start("driver-1", config)
+        factory.sockets.single().message("""{"event":"pusher:ping"}""")
+
+        assertTrue(factory.sockets.single().sent.any { it.contains("pusher:pong") })
+    }
+
+    @Test
+    fun closesAndReconnectsWhenConnectedSocketStopsReceivingMessages() = runTest {
+        val factory = FakeWebSocketFactory()
+        val client = liveClient(factory = factory, scope = backgroundScope)
+
+        client.start("driver-1", config)
+        factory.sockets.single().message(connectionEstablished("socket-1"))
+        advanceUntilIdle()
+        factory.sockets.single().message("""{"event":"pusher_internal:subscription_succeeded","channel":"private-driver-mobile.driver-1"}""")
+
+        advanceTimeBy(30_000)
+        runCurrent()
+
+        assertTrue(factory.sockets.first().closed)
+        assertEquals(2, factory.sockets.size)
+    }
+
+    @Test
+    fun ignoresCallbacksFromOldSocketAfterReconnect() = runTest {
+        val factory = FakeWebSocketFactory()
+        val client = liveClient(factory = factory, scope = backgroundScope)
+
+        client.start("driver-1", config)
+        val oldSocket = factory.sockets.single()
+        oldSocket.fail()
+        client.ensureConnected()
+        assertEquals(2, factory.sockets.size)
+
+        oldSocket.fail()
+        client.ensureConnected()
+
+        assertEquals(2, factory.sockets.size)
+    }
+
+    private fun liveClient(
+        gateway: FakeLiveSyncGateway = FakeLiveSyncGateway(),
+        factory: FakeWebSocketFactory,
+        scope: CoroutineScope,
+    ): DriverLiveSyncClient =
+        DriverLiveSyncClient(
+            gateway = gateway,
+            onConnected = {},
+            onHint = {},
+            webSocketFactory = factory,
+            scope = scope,
+            reconnectDelaysMs = listOf(1_000L, 2_000L),
+            staleTimeoutMs = 30_000L,
+        )
+
+    private fun connectionEstablished(socketId: String): String =
+        """{"event":"pusher:connection_established","data":"{\"socket_id\":\"$socketId\"}"}"""
+
+    private class FakeLiveSyncGateway(
+        private val authFailure: Throwable? = null,
+    ) : DriverLiveSyncGateway {
+        override suspend fun broadcastAuth(socketId: String, channelName: String): BroadcastAuthResponse {
+            authFailure?.let { throw it }
+            return BroadcastAuthResponse(auth = "auth-token")
+        }
+
+        override suspend fun storeRealtimeStatus(status: String, socketId: String?, error: String?) = Unit
+    }
+
+    private class FakeWebSocketFactory : LiveWebSocketFactory {
+        val sockets = mutableListOf<FakeWebSocket>()
+
+        override fun newWebSocket(url: String, listener: WebSocketListener): WebSocket {
+            val socket = FakeWebSocket(listener)
+            sockets += socket
+            return socket
+        }
+    }
+
+    private class FakeWebSocket(
+        private val listener: WebSocketListener,
+    ) : WebSocket {
+        val sent = mutableListOf<String>()
+        var closed = false
+
+        fun fail() {
+            listener.onFailure(this, RuntimeException("boom"), null)
+        }
+
+        fun message(text: String) {
+            listener.onMessage(this, text)
+        }
+
+        override fun request(): Request = Request.Builder().url("wss://example.test/app").build()
+
+        override fun queueSize(): Long = 0L
+
+        override fun send(text: String): Boolean {
+            sent += text
+            return true
+        }
+
+        override fun send(bytes: ByteString): Boolean = true
+
+        override fun close(code: Int, reason: String?): Boolean {
+            closed = true
+            return true
+        }
+
+        override fun cancel() {
+            closed = true
+        }
+    }
+}

app/src/test/java/pl/firmatpp/kierowca/ui/DriverRouteProjectionTest.kt

@@ -0,0 +1,159 @@
+package pl.firmatpp.kierowca.ui
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import pl.firmatpp.kierowca.data.model.DriverRouteDto
+import pl.firmatpp.kierowca.data.upload.RouteActionEntity
+import pl.firmatpp.kierowca.data.upload.RouteActionStatus
+import pl.firmatpp.kierowca.data.upload.RouteActionType
+
+class DriverRouteProjectionTest {
+    @Test
+    fun pendingStartProjectsPlannedRouteAsActiveWithLoadingWeight() {
+        val projection = projectDriverRoute(
+            route = route(status = "ZAPLANOWANA"),
+            actions = listOf(action(RouteActionType.Start, RouteActionStatus.Pending, weight = 12.5)),
+        )
+
+        assertEquals("W TRAKCIE", projection.route.status)
+        assertEquals(12.5, projection.route.loadingWeight)
+        assertEquals("active", projection.route.trackingStatus)
+        assertTrue(projection.loadingWeightPending)
+        assertFalse(projection.unloadingWeightPending)
+        assertEquals(RouteLifecycleAction.Finish, routeLifecyclePrimaryAction(projection.route, "2026-06-30", today)?.action)
+    }
+
+    @Test
+    fun pendingFinishProjectsActiveRouteAsFinishedWithUnloadingWeight() {
+        val projection = projectDriverRoute(
+            route = route(status = "W TRAKCIE", loadingWeight = 12.5),
+            actions = listOf(action(RouteActionType.Finish, RouteActionStatus.Syncing, weight = 11.8, occurredAt = "2026-06-30T09:10:00Z")),
+        )
+
+        assertEquals("ZAKOŃCZONA", projection.route.status)
+        assertEquals(11.8, projection.route.unloadingWeight)
+        assertEquals("finished", projection.route.trackingStatus)
+        assertEquals("2026-06-30T09:10:00Z", projection.route.completedAt)
+        assertTrue(projection.unloadingWeightPending)
+        assertNull(routeLifecyclePrimaryAction(projection.route, "2026-06-30", today))
+    }
+
+    @Test
+    fun startAndFinishAreAppliedChronologicallySoFinishWins() {
+        val projection = projectDriverRoute(
+            route = route(status = "ZAPLANOWANA"),
+            actions = listOf(
+                action(RouteActionType.Finish, RouteActionStatus.Pending, weight = 11.8, createdAt = 2000),
+                action(RouteActionType.Start, RouteActionStatus.Pending, weight = 12.5, createdAt = 1000),
+            ),
+        )
+
+        assertEquals("ZAKOŃCZONA", projection.route.status)
+        assertEquals(12.5, projection.route.loadingWeight)
+        assertEquals(11.8, projection.route.unloadingWeight)
+        assertEquals("finished", projection.route.trackingStatus)
+    }
+
+    @Test
+    fun confirmedFinishStillProjectsPlannedRouteAsFinishedWithoutSyncCallout() {
+        val projection = projectDriverRoute(
+            route = route(status = "ZAPLANOWANA"),
+            actions = listOf(
+                action(RouteActionType.Finish, RouteActionStatus.Confirmed, weight = 11.8, createdAt = 2000),
+            ),
+        )
+
+        assertEquals("ZAKOŃCZONA", projection.route.status)
+        assertEquals(11.8, projection.route.unloadingWeight)
+        assertEquals("finished", projection.route.trackingStatus)
+        assertFalse(projection.unloadingWeightPending)
+        assertEquals(emptyList<RouteActionEntity>(), projection.visibleActions)
+    }
+
+    @Test
+    fun conflictKeepsLocalRouteValuesAndMarksStageAsAttention() {
+        val projection = projectDriverRoute(
+            route = route(status = "W TRAKCIE", loadingWeight = 12.5),
+            actions = listOf(action(RouteActionType.Finish, RouteActionStatus.FailedConflict, weight = 11.8)),
+        )
+        val steps = routeFlowSteps(projection.route, projection.visibleActions)
+        val callout = routeSyncCallout(projection.visibleActions)
+
+        assertEquals("ZAKOŃCZONA", projection.route.status)
+        assertEquals(11.8, projection.route.unloadingWeight)
+        assertEquals(RouteFlowStepState.NeedsAttention, steps[2].state)
+        assertEquals("Kurs wymaga obsługi. Dane wpisane w telefonie zostały zachowane.", callout?.text)
+        assertTrue(callout?.isConflict ?: false)
+    }
+
+    @Test
+    fun failedPermanentIsVisibleAndNeedsAttention() {
+        val projection = projectDriverRoute(
+            route = route(status = "ZAPLANOWANA"),
+            actions = listOf(action(RouteActionType.Start, RouteActionStatus.FailedPermanent, weight = 12.5)),
+        )
+        val steps = routeFlowSteps(projection.route, projection.visibleActions)
+
+        assertEquals("W TRAKCIE", projection.route.status)
+        assertEquals(12.5, projection.route.loadingWeight)
+        assertEquals(RouteFlowStepState.NeedsAttention, steps[0].state)
+    }
+
+    @Test
+    fun noLocalActionsLeavesRouteUnchanged() {
+        val route = route(status = "ZAPLANOWANA")
+        val projection = projectDriverRoute(route, emptyList())
+
+        assertEquals(route, projection.route)
+        assertFalse(projection.loadingWeightPending)
+        assertFalse(projection.unloadingWeightPending)
+        assertEquals(emptyList<RouteActionEntity>(), projection.visibleActions)
+    }
+
+    private fun route(
+        status: String,
+        loadingWeight: Double? = null,
+        unloadingWeight: Double? = null,
+    ): DriverRouteDto =
+        DriverRouteDto(
+            id = "1",
+            startsAt = "",
+            originName = "Baza",
+            destinationName = "Instalacja",
+            contractorName = "TPP",
+            contractName = "Kontrakt",
+            contractCode = "TPP-1",
+            relationLabel = "Baza -> Instalacja",
+            status = status,
+            loadingWeight = loadingWeight,
+            unloadingWeight = unloadingWeight,
+            distanceKm = 1.0,
+            notes = null,
+            truck = null,
+        )
+
+    private fun action(
+        type: String,
+        status: String,
+        weight: Double,
+        occurredAt: String = "2026-06-30T07:40:00Z",
+        createdAt: Long = 1000,
+    ): RouteActionEntity =
+        RouteActionEntity(
+            clientActionId = "action-$type-$status-$createdAt",
+            routeId = "1",
+            action = type,
+            weight = weight,
+            occurredAt = occurredAt,
+            photoClientRequestIdsJson = "[]",
+            status = status,
+            createdAtEpochMillis = createdAt,
+        )
+
+    private companion object {
+        val today = java.time.LocalDate.parse("2026-06-30")
+    }
+}

app/src/test/java/pl/firmatpp/kierowca/ui/DriverUiRulesTest.kt

@@ -7,7 +7,11 @@ import org.junit.Assert.assertTrue
 import org.junit.Test
 import pl.firmatpp.kierowca.data.model.DriverRouteDto
 import pl.firmatpp.kierowca.data.model.DispatchSheetReminderDto
+import pl.firmatpp.kierowca.data.model.RoutePhotoDto
 import pl.firmatpp.kierowca.data.upload.PhotoUploadEntity
+import pl.firmatpp.kierowca.data.upload.RouteActionEntity
+import pl.firmatpp.kierowca.data.upload.RouteActionStatus
+import pl.firmatpp.kierowca.data.upload.RouteActionType
 
 class DriverUiRulesTest {
     private val today = LocalDate.parse("2026-06-30")
@@ -61,6 +65,30 @@ class DriverUiRulesTest {
         assertEquals(3, inlinePhotoGridRows(5))
     }
 
+    @Test
+    fun keepsPhotoPreviewFeedbackVisibleUntilImageLoadsOrFails() {
+        assertTrue(shouldShowPhotoPreviewLoadingState(hasPhoto = true, isLoading = true, isError = false))
+        assertFalse(shouldShowPhotoPreviewLoadingState(hasPhoto = true, isLoading = false, isError = false))
+        assertFalse(shouldShowPhotoPreviewLoadingState(hasPhoto = true, isLoading = true, isError = true))
+        assertFalse(shouldShowPhotoPreviewLoadingState(hasPhoto = false, isLoading = true, isError = false))
+
+        assertTrue(shouldShowPhotoPreviewErrorState(hasPhoto = true, isError = true))
+        assertFalse(shouldShowPhotoPreviewErrorState(hasPhoto = true, isError = false))
+        assertFalse(shouldShowPhotoPreviewErrorState(hasPhoto = false, isError = true))
+    }
+
+    @Test
+    fun keepsPhotoTileFeedbackVisibleUntilThumbnailLoadsOrFails() {
+        assertTrue(shouldShowPhotoTileLoadingState(hasPhoto = true, isLoading = true, isError = false))
+        assertFalse(shouldShowPhotoTileLoadingState(hasPhoto = true, isLoading = false, isError = false))
+        assertFalse(shouldShowPhotoTileLoadingState(hasPhoto = true, isLoading = true, isError = true))
+        assertFalse(shouldShowPhotoTileLoadingState(hasPhoto = false, isLoading = true, isError = false))
+
+        assertTrue(shouldShowPhotoTileErrorState(hasPhoto = true, isError = true))
+        assertFalse(shouldShowPhotoTileErrorState(hasPhoto = true, isError = false))
+        assertFalse(shouldShowPhotoTileErrorState(hasPhoto = false, isError = true))
+    }
+
     @Test
     fun usesShorterChromeOnCompactScreens() {
         assertEquals(118, authBrandBannerHeightDp(600))
@@ -199,6 +227,22 @@ class DriverUiRulesTest {
         assertFalse(shouldShowDispatchSheetReminderCard(null))
     }
 
+    @Test
+    fun explainsOfflineStateWithoutCachedSync() {
+        assertEquals(
+            "Brak połączenia z serwerem. Sprawdź internet i spróbuj ponownie.",
+            offlineStaleBannerMessage(isOnline = false, isStale = false, syncLabel = "brak zapisanej synchronizacji"),
+        )
+    }
+
+    @Test
+    fun explainsStaleCachedDataWhenOnline() {
+        assertEquals(
+            "Dane mogą być nieaktualne. Ostatnia synchronizacja: 12:30.",
+            offlineStaleBannerMessage(isOnline = true, isStale = true, syncLabel = "12:30"),
+        )
+    }
+
     @Test
     fun labelsDispatchSheetActionByStatusAndLocalUploadQueue() {
         assertEquals("Zrób zdjęcie", dispatchSheetPrimaryActionLabel(dispatchReminder(status = "missing"), hasQueuedUpload = false))
@@ -206,7 +250,124 @@ class DriverUiRulesTest {
         assertEquals("Popraw", dispatchSheetPrimaryActionLabel(dispatchReminder(status = "uploaded"), hasQueuedUpload = false))
     }
 
-    private fun route(status: String): DriverRouteDto =
+    @Test
+    fun routeStageFormRequiresPositiveWeightAndAtLeastOnePhotoOrQueuedUpload() {
+        assertTrue(canSubmitRouteStageForm(weightText = "12,5", serverPhotoCount = 1, localUploadCount = 0))
+        assertTrue(canSubmitRouteStageForm(weightText = "12.5", serverPhotoCount = 0, localUploadCount = 1))
+        assertFalse(canSubmitRouteStageForm(weightText = "", serverPhotoCount = 1, localUploadCount = 0))
+        assertFalse(canSubmitRouteStageForm(weightText = "0", serverPhotoCount = 1, localUploadCount = 0))
+        assertFalse(canSubmitRouteStageForm(weightText = "12.5", serverPhotoCount = 0, localUploadCount = 0))
+    }
+
+    @Test
+    fun filtersRoutePhotosByStageWithOtherFallback() {
+        val photos = listOf(
+            photo("1", stage = "loading"),
+            photo("2", stage = "unloading"),
+            photo("3", stage = null),
+        )
+
+        assertEquals(listOf("1"), routePhotosForStage(photos, "loading").map { it.id })
+        assertEquals(listOf("2"), routePhotosForStage(photos, "unloading").map { it.id })
+        assertEquals(listOf("3"), routePhotosForStage(photos, "other").map { it.id })
+    }
+
+    @Test
+    fun choosesAdaptiveGpsUploadIntervalForActiveRoute() {
+        assertEquals(45, activeRouteUploadIntervalSeconds(isMoving = false))
+        assertEquals(20, activeRouteUploadIntervalSeconds(isMoving = true))
+        assertEquals(5, activeRouteUploadIntervalSeconds(isMoving = true, isUrbanOrTurning = true))
+        assertEquals(5, activeRouteUploadIntervalSeconds(isMoving = true, isNearDestination = true))
+        assertEquals(20, activeRouteUploadIntervalSeconds(isMoving = true, isHighwayStable = true))
+        assertEquals(3, activeRouteUploadIntervalSeconds(isMoving = true, isLikelyOffRoute = true))
+    }
+
+    @Test
+    fun notificationTapTargetsFinishScreenOnlyAfterArrival() {
+        assertEquals(DriverScreen.Detail, activeRouteNotificationTarget(arrived = false))
+        assertEquals(DriverScreen.FinishRoute, activeRouteNotificationTarget(arrived = true))
+    }
+
+    @Test
+    fun plannedRouteShowsLoadingAsNextStepAndStartAction() {
+        val route = route(status = "ZAPLANOWANA")
+
+        val steps = routeFlowSteps(route, emptyList())
+        val action = routeLifecyclePrimaryAction(route, "2026-06-30", today)
+
+        assertEquals(listOf("Załadunek", "W trasie", "Rozładunek"), steps.map { it.title })
+        assertEquals(RouteFlowStepState.Todo, steps[0].state)
+        assertEquals(RouteFlowStepState.Todo, steps[1].state)
+        assertEquals(RouteFlowStepState.Todo, steps[2].state)
+        assertEquals("Rozpocznij kurs", action?.label)
+        assertEquals(RouteLifecycleAction.Start, action?.action)
+    }
+
+    @Test
+    fun activeRouteShowsTransitStateAndFinishAction() {
+        val route = route(status = "W TRAKCIE", loadingWeight = 12.5)
+
+        val steps = routeFlowSteps(route, emptyList())
+        val action = routeLifecyclePrimaryAction(route, "2026-06-30", today)
+
+        assertEquals(RouteFlowStepState.Confirmed, steps[0].state)
+        assertEquals(RouteFlowStepState.LocalComplete, steps[1].state)
+        assertEquals(RouteFlowStepState.Todo, steps[2].state)
+        assertEquals("Zakończ kurs", action?.label)
+        assertEquals(RouteLifecycleAction.Finish, action?.action)
+    }
+
+    @Test
+    fun finishedRouteShowsCompletedStagesAndNoPrimaryAction() {
+        val route = route(status = "ZAKOŃCZONA", loadingWeight = 12.5, unloadingWeight = 11.8)
+
+        val steps = routeFlowSteps(route, emptyList())
+        val action = routeLifecyclePrimaryAction(route, "2026-06-30", today)
+
+        assertEquals(RouteFlowStepState.Confirmed, steps[0].state)
+        assertEquals(RouteFlowStepState.Confirmed, steps[1].state)
+        assertEquals(RouteFlowStepState.Confirmed, steps[2].state)
+        assertEquals(null, action)
+    }
+
+    @Test
+    fun pendingLocalRouteActionShowsSyncingCallout() {
+        val actions = listOf(action(RouteActionType.Start, RouteActionStatus.WaitingForPhotos))
+
+        val steps = routeFlowSteps(route(status = "W TRAKCIE", loadingWeight = 12.5), actions)
+        val callout = routeSyncCallout(actions)
+
+        assertEquals(RouteFlowStepState.Syncing, steps[0].state)
+        assertEquals("Czekam na wysłanie zdjęć etapu, potem wyślę zmianę statusu.", callout?.text)
+        assertFalse(callout?.isConflict ?: true)
+    }
+
+    @Test
+    fun failedConflictRouteActionRequiresAttention() {
+        val actions = listOf(action(RouteActionType.Finish, RouteActionStatus.FailedConflict, "Kurs został przepisany."))
+
+        val steps = routeFlowSteps(route(status = "W TRAKCIE", loadingWeight = 12.5), actions)
+        val callout = routeSyncCallout(actions)
+
+        assertEquals(RouteFlowStepState.NeedsAttention, steps[2].state)
+        assertEquals("Kurs wymaga obsługi. Dane wpisane w telefonie zostały zachowane.", callout?.text)
+        assertTrue(callout?.isConflict ?: false)
+    }
+
+    @Test
+    fun routeStageSubmitBlockerExplainsMissingRequirements() {
+        assertEquals("Podaj wagę.", routeStageSubmitBlocker("", serverPhotoCount = 1, localUploadCount = 0))
+        assertEquals("Waga musi być większa od zera.", routeStageSubmitBlocker("0", serverPhotoCount = 1, localUploadCount = 0))
+        assertEquals("Dodaj co najmniej jedno zdjęcie etapu.", routeStageSubmitBlocker("12,5", serverPhotoCount = 0, localUploadCount = 0))
+        assertEquals(null, routeStageSubmitBlocker("12,5", serverPhotoCount = 0, localUploadCount = 1))
+    }
+
+    private fun route(
+        status: String,
+        loadingWeight: Double? = null,
+        unloadingWeight: Double? = null,
+        photos: List<RoutePhotoDto> = emptyList(),
+    ): DriverRouteDto =
         DriverRouteDto(
             id = "1",
             startsAt = "",
@@ -217,9 +378,24 @@ class DriverUiRulesTest {
             contractCode = "TPP-1",
             relationLabel = "Baza -> Instalacja",
             status = status,
+            loadingWeight = loadingWeight,
+            unloadingWeight = unloadingWeight,
             distanceKm = 1.0,
             notes = null,
             truck = null,
+            photos = photos,
+        )
+
+    private fun action(type: String, status: String, lastError: String? = null): RouteActionEntity =
+        RouteActionEntity(
+            clientActionId = "action-$type-$status",
+            routeId = "1",
+            action = type,
+            weight = 12.5,
+            occurredAt = "2026-06-30T07:40:00Z",
+            photoClientRequestIdsJson = "[]",
+            status = status,
+            lastError = lastError,
         )
 
     private fun upload(status: String, serverPhotoId: String? = null): PhotoUploadEntity =
@@ -239,6 +415,24 @@ class DriverUiRulesTest {
             serverPhotoId = serverPhotoId,
         )
 
+    private fun photo(id: String, stage: String?): RoutePhotoDto =
+        RoutePhotoDto(
+            id = id,
+            routeId = "10",
+            clientRequestId = null,
+            contentSha256 = null,
+            source = "camera",
+            stage = stage ?: "other",
+            mimeType = "image/jpeg",
+            size = 1200,
+            url = "https://example.test/$id.jpg",
+            takenAt = null,
+            latitude = null,
+            longitude = null,
+            locationAccuracyMeters = null,
+            createdAt = null,
+        )
+
     private fun dispatchReminder(status: String, dueToday: Boolean = true): DispatchSheetReminderDto =
         DispatchSheetReminderDto(
             enabled = dueToday,

app/src/test/java/pl/firmatpp/kierowca/ui/DriverUiStateTest.kt

@@ -3,6 +3,12 @@ package pl.firmatpp.kierowca.ui
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Test
+import pl.firmatpp.kierowca.data.model.DriverLeaveRequestDto
+import pl.firmatpp.kierowca.data.model.DriverRouteDto
+import pl.firmatpp.kierowca.data.upload.RouteActionEntity
+import pl.firmatpp.kierowca.data.upload.RouteActionStatus
+import pl.firmatpp.kierowca.data.upload.RouteActionType
+import pl.firmatpp.kierowca.ui.theme.AppThemeMode
 
 class DriverUiStateTest {
     @Test
@@ -12,4 +18,91 @@ class DriverUiStateTest {
         assertEquals(DriverScreen.Initializing, state.screen)
         assertTrue(state.loading)
     }
+
+    @Test
+    fun startsWithMaterial3ThemeMode() {
+        val state = DriverUiState()
+
+        assertEquals(AppThemeMode.Material3, state.themeMode)
+    }
+
+    @Test
+    fun refreshingLeaveRequestsKeepsDetailScreenOpenAndUpdatesSelectedRequest() {
+        val state = DriverUiState(
+            screen = DriverScreen.LeaveRequestDetail,
+            selectedLeaveRequest = leaveRequest(id = "leave-1", status = "pending"),
+        )
+
+        val refreshed = state.withLoadedLeaveRequests(
+            requests = listOf(leaveRequest(id = "leave-1", status = "approved")),
+            navigateToList = false,
+        )
+
+        assertEquals(DriverScreen.LeaveRequestDetail, refreshed.screen)
+        assertEquals("approved", refreshed.selectedLeaveRequest?.status)
+    }
+
+    @Test
+    fun openingLeaveRequestsNavigatesToList() {
+        val state = DriverUiState(screen = DriverScreen.Routes)
+
+        val refreshed = state.withLoadedLeaveRequests(
+            requests = listOf(leaveRequest(id = "leave-1", status = "pending")),
+            navigateToList = true,
+        )
+
+        assertEquals(DriverScreen.LeaveRequests, refreshed.screen)
+        assertEquals(1, refreshed.leaveRequests.size)
+    }
+
+    @Test
+    fun displayRoutesAndSelectedRouteUseLocalRouteActionsProjection() {
+        val route = route(status = "ZAPLANOWANA")
+        val state = DriverUiState(
+            routes = listOf(route),
+            selectedRoute = route,
+            visibleRouteActions = listOf(action(RouteActionType.Start, RouteActionStatus.Pending, weight = 12.5)),
+        )
+
+        assertEquals("W TRAKCIE", state.displayRoutes.single().status)
+        assertEquals(12.5, state.displayRoutes.single().loadingWeight)
+        assertEquals("W TRAKCIE", state.displaySelectedRoute?.status)
+        assertEquals(12.5, state.displaySelectedRoute?.loadingWeight)
+    }
+
+    private fun leaveRequest(id: String, status: String): DriverLeaveRequestDto =
+        DriverLeaveRequestDto(
+            id = id,
+            dateFrom = "2026-07-10",
+            dateTo = "2026-07-12",
+            type = "URLOP",
+            status = status,
+        )
+
+    private fun route(status: String): DriverRouteDto =
+        DriverRouteDto(
+            id = "1",
+            startsAt = "",
+            originName = "Baza",
+            destinationName = "Instalacja",
+            contractorName = "TPP",
+            contractName = "Kontrakt",
+            contractCode = "TPP-1",
+            relationLabel = "Baza -> Instalacja",
+            status = status,
+            distanceKm = 1.0,
+            notes = null,
+            truck = null,
+        )
+
+    private fun action(type: String, status: String, weight: Double): RouteActionEntity =
+        RouteActionEntity(
+            clientActionId = "action-$type-$status",
+            routeId = "1",
+            action = type,
+            weight = weight,
+            occurredAt = "2026-06-30T07:40:00Z",
+            photoClientRequestIdsJson = "[]",
+            status = status,
+        )
 }

app/src/test/java/pl/firmatpp/kierowca/ui/theme/AppThemeModeTest.kt

@@ -0,0 +1,23 @@
+package pl.firmatpp.kierowca.ui.theme
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class AppThemeModeTest {
+    @Test
+    fun parsesStoredMaterial3Value() {
+        assertEquals(AppThemeMode.Material3, AppThemeMode.fromStoredValue("material3"))
+    }
+
+    @Test
+    fun fallsBackToCurrentForUnknownStoredValue() {
+        assertEquals(AppThemeMode.Material3, AppThemeMode.fromStoredValue("future-theme"))
+        assertEquals(AppThemeMode.Material3, AppThemeMode.fromStoredValue(null))
+    }
+
+    @Test
+    fun storesStablePreferenceValues() {
+        assertEquals("current", AppThemeMode.Current.storedValue)
+        assertEquals("material3", AppThemeMode.Material3.storedValue)
+    }
+}