chore: release android driver 1.0.60 (113)

.gitignore

@@ -7,3 +7,5 @@ app/google-services.json:Zone.Identifier
 *.iml
 keystore.properties
 *.jks
+release-artifacts/
+app/src/main/res_bak/

README.md

@@ -21,3 +21,23 @@ Natywna aplikacja Android Jetpack Compose dla kierowcow TPP.
 ```bash
 ./gradlew :app:testDebugUnitTest
 ```
+
+## Release Gitea i Google Play
+
+Przed wydaniem zapisz wszystkie zmiany źródłowe w commicie. Następnie uruchom:
+
+```bash
+./scripts/release-android.sh
+```
+
+Skrypt automatycznie zwiększa `versionCode` i ostatni człon `versionName`, uruchamia testy,
+buduje podpisany APK dla Gitea oraz AAB dla Google Play Console, tworzy commit wersji,
+tag, push i Gitea Release. Artefakty zostają również zapisane lokalnie w
+`release-artifacts/<tag>/`.
+
+Do autoryzacji Gitea używany jest `GITEA_TOKEN` albo dane zapisane w Git credential helper.
+Jeśli publikacja została przerwana już po utworzeniu commita wersji, można ją wznowić:
+
+```bash
+./scripts/release-android.sh --reuse-current
+```

app/build.gradle.kts

@@ -34,8 +34,8 @@ android {
         applicationId = "pl.firmatpp.kierowca"
         minSdk = 26
         targetSdk = 35
-        versionCode = 44
-        versionName = "1.0.42"
+        versionCode = 113
+        versionName = "1.0.60"
         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/DriverApplication.kt

@@ -1,12 +1,26 @@
 package pl.firmatpp.kierowca
 
 import android.app.Application
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import pl.firmatpp.kierowca.data.upload.OfflineOutboxManager
 import pl.firmatpp.kierowca.diagnostics.AppDiagnostics
 
 class DriverApplication : Application() {
+    private val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
     override fun onCreate() {
         super.onCreate()
         AppDiagnostics.installFirebaseCrashlytics()
         AppDiagnostics.log("app_started")
+        applicationScope.launch {
+            val outboxManager = OfflineOutboxManager(this@DriverApplication)
+            runCatching { outboxManager.repairOperationalQueues() }
+                .onFailure { AppDiagnostics.reportNonFatal(it, "repair_operational_queues") }
+            runCatching { outboxManager.repairGpsQueue() }
+                .onFailure { AppDiagnostics.reportNonFatal(it, "repair_gps_queue") }
+        }
     }
 }

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

@@ -14,11 +14,13 @@ 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 {
             val viewModel: DriverViewModel = viewModel()
@@ -28,6 +30,7 @@ class MainActivity : ComponentActivity() {
                 DriverApp(
                     viewModel = viewModel,
                     initialRouteId = notificationRouteId,
+                    initialRouteTarget = notificationRouteTarget,
                     initialLeaveRequestId = notificationLeaveRequestId,
                 )
             }
@@ -38,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

@@ -2,6 +2,7 @@ package pl.firmatpp.kierowca.data
 
 import java.io.IOException
 import java.net.UnknownHostException
+import kotlin.coroutines.cancellation.CancellationException
 import retrofit2.HttpException
 
 enum class ApiErrorKind {
@@ -106,3 +107,7 @@ object ApiErrorMapper {
         return mapHttpStatus(exception.code(), body)
     }
 }
+
+fun Throwable.rethrowIfCancellation() {
+    if (this is CancellationException) throw this
+}

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

@@ -3,6 +3,7 @@ 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
@@ -18,13 +19,23 @@ class AppPreferencesStore(
     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

@@ -18,7 +18,9 @@ import pl.firmatpp.kierowca.data.model.CancelLeaveRequestBody
 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.DriverLeaveCalendarEntryDto
 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 +28,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
@@ -57,18 +62,30 @@ class DriverRepository(
     suspend fun leaveRequests(): List<DriverLeaveRequestDto> =
         api.leaveRequests(authHeader(requireToken())).data
 
+    suspend fun leaveCalendar(from: String, to: String): List<DriverLeaveCalendarEntryDto> =
+        api.leaveCalendar(authHeader(requireToken()), from, to).data
+
     suspend fun leaveRequest(id: String): DriverLeaveRequestDto =
         api.leaveRequest(authHeader(requireToken()), id).data
 
     suspend fun createLeaveRequest(dateFrom: String, dateTo: String, type: String, note: String?): DriverLeaveRequestDto =
         api.createLeaveRequest(authHeader(requireToken()), CreateLeaveRequestBody(dateFrom, dateTo, type, note)).data
 
-    suspend fun cancelLeaveRequest(id: String, comment: String? = null): DriverLeaveRequestDto =
-        api.cancelLeaveRequest(authHeader(requireToken()), id, CancelLeaveRequestBody(comment)).data
+    suspend fun cancelLeaveRequest(id: String, expectedVersion: Long, comment: String? = null): DriverLeaveRequestDto =
+        api.cancelLeaveRequest(authHeader(requireToken()), id, CancelLeaveRequestBody(comment, expectedVersion)).data
 
     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 +112,7 @@ class DriverRepository(
         routeId: String,
         uri: Uri,
         source: String,
+        stage: String = "other",
         metadata: PhotoUploadMetadata = PhotoUploadMetadata(),
     ): PhotoUploadResponse {
         val resolver = context.contentResolver
@@ -115,6 +133,7 @@ class DriverRepository(
             clientRequestId.toPlainTextBody(),
             contentSha256.toPlainTextBody(),
             sourceBody,
+            stage.toPlainTextBody(),
             metadataParts["takenAt"],
             metadataParts["latitude"],
             metadataParts["longitude"],
@@ -141,6 +160,7 @@ class DriverRepository(
             upload.clientRequestId.toPlainTextBody(),
             upload.contentSha256.toPlainTextBody(),
             upload.source.toPlainTextBody(),
+            upload.stage.toPlainTextBody(),
             metadataParts["takenAt"],
             metadataParts["latitude"],
             metadataParts["longitude"],
@@ -178,9 +198,9 @@ class DriverRepository(
         api.deletePhoto(authHeader(requireToken()), photoId)
     }
 
-    suspend fun logout() {
+    suspend fun logout(notifyServer: Boolean = true) {
         val token = tokenStore.read()
-        if (token != null) {
+        if (token != null && notifyServer) {
             runCatching { api.deletePushToken(authHeader(token)) }
             runCatching { api.logout(authHeader(token)) }
         }

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

@@ -9,6 +9,8 @@ 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.LeaveCalendarResponse
 import pl.firmatpp.kierowca.data.model.LeaveRequestListResponse
 import pl.firmatpp.kierowca.data.model.LeaveRequestResponse
 import pl.firmatpp.kierowca.data.model.LeaveRequestTypesResponse
@@ -19,7 +21,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
@@ -71,6 +77,13 @@ interface MobileDriverApi {
         @Header("Authorization") authorization: String,
     ): LeaveRequestListResponse
 
+    @GET("mobile/driver/leave-requests/calendar")
+    suspend fun leaveCalendar(
+        @Header("Authorization") authorization: String,
+        @Query("from") from: String,
+        @Query("to") to: String,
+    ): LeaveCalendarResponse
+
     @POST("mobile/driver/leave-requests")
     suspend fun createLeaveRequest(
         @Header("Authorization") authorization: String,
@@ -102,6 +115,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 +176,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

@@ -62,6 +62,10 @@ data class DriverAppSettingsDto(
     val allowGalleryUploads: Boolean?,
     val allowRouteCompletion: Boolean?,
     val requirePreciseLocationForPhotos: Boolean?,
+    val loadingPhotoRequirement: String? = null,
+    val loadingWeightRequirement: String? = null,
+    val unloadingPhotoRequirement: String? = null,
+    val unloadingWeightRequirement: String? = null,
     val dispatchSheetRemindersEnabled: Boolean? = null,
     val dispatchSheetOnFridays: Boolean? = null,
     val dispatchSheetOnLastWorkingDay: Boolean? = null,
@@ -113,6 +117,7 @@ data class RealtimeConfigDto(
     val reverbEnabled: Boolean = false,
     val reverbAppKey: String? = null,
     val reverbWsBaseUrl: String? = null,
+    val reverbOrigin: String? = null,
 )
 
 data class RoutesBucketDto(
@@ -167,6 +172,10 @@ data class LeaveRequestListResponse(
     val data: List<DriverLeaveRequestDto> = emptyList(),
 )
 
+data class LeaveCalendarResponse(
+    val data: List<DriverLeaveCalendarEntryDto> = emptyList(),
+)
+
 data class LeaveRequestResponse(
     val data: DriverLeaveRequestDto,
 )
@@ -189,6 +198,7 @@ data class CreateLeaveRequestBody(
 
 data class CancelLeaveRequestBody(
     val comment: String? = null,
+    val expectedVersion: Long? = null,
 )
 
 data class DriverLeaveRequestDto(
@@ -200,12 +210,32 @@ data class DriverLeaveRequestDto(
     val typeLabel: String? = null,
     val note: String? = null,
     val status: String,
+    val version: Long = 1,
+    val updatedAt: String? = null,
+    val allowedDecisions: List<String> = emptyList(),
+    val canCancel: Boolean = false,
     val submittedAt: String? = null,
     val decidedAt: String? = null,
     val decisionComment: String? = null,
     val events: List<DriverLeaveRequestEventDto> = emptyList(),
 )
 
+data class DriverLeaveCalendarEntryDto(
+    val id: String,
+    val dateFrom: String?,
+    val dateTo: String?,
+    val type: String,
+    val typeLabel: String? = null,
+    val status: String,
+    val driver: DriverLeaveCalendarDriverDto,
+)
+
+data class DriverLeaveCalendarDriverDto(
+    val id: String,
+    val displayName: String?,
+    val phoneNumber: String?,
+)
+
 data class DriverLeaveRequestEventDto(
     val id: String,
     val action: String,
@@ -224,6 +254,9 @@ data class RealtimeStatusBody(
 data class DriverRouteDto(
     val id: String,
     val routeDate: String? = null,
+    val unloadingDate: String? = null,
+    val ordering: Int? = null,
+    val dayOrderings: Map<String, Int>? = emptyMap(),
     val startsAt: String,
     val originName: String,
     val destinationName: String,
@@ -232,14 +265,31 @@ data class DriverRouteDto(
     val contractCode: String?,
     val relationLabel: String,
     val status: String,
+    val driverStatus: String? = null,
+    val operationalStatus: String? = null,
+    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?,
     val completedAt: String? = null,
+    val operationalCompletedAt: String? = null,
     val completedByDriver: DriverDto? = null,
     val originNavigation: NavigationPointDto? = null,
     val destinationNavigation: NavigationPointDto? = null,
     val photos: List<RoutePhotoDto> = emptyList(),
+    val photosByStage: RoutePhotosByStageDto? = null,
+)
+
+fun DriverRouteDto.driverLifecycleStatus(): String =
+    driverStatus?.takeIf { it in setOf("ZAPLANOWANA", "W TRAKCIE", "ZAKOŃCZONA") } ?: status
+
+data class RoutePhotosByStageDto(
+    val loading: List<RoutePhotoDto> = emptyList(),
+    val unloading: List<RoutePhotoDto> = emptyList(),
+    val other: List<RoutePhotoDto> = emptyList(),
 )
 
 data class TruckDto(
@@ -262,6 +312,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 +337,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/sync/DriverCacheDao.kt

@@ -13,18 +13,27 @@ interface DriverCacheDao {
     @Query("SELECT * FROM driver_bootstrap_cache WHERE date = :date LIMIT 1")
     suspend fun bootstrap(date: String): DriverBootstrapCacheEntity?
 
+    @Query("SELECT * FROM driver_bootstrap_cache ORDER BY syncedAtEpochMillis DESC")
+    suspend fun allBootstrapCaches(): List<DriverBootstrapCacheEntity>
+
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun upsertRoute(cache: DriverRouteCacheEntity)
 
     @Query("SELECT * FROM driver_route_cache WHERE routeId = :routeId LIMIT 1")
     suspend fun route(routeId: String): DriverRouteCacheEntity?
 
+    @Query("SELECT * FROM driver_route_cache ORDER BY syncedAtEpochMillis DESC")
+    suspend fun allRouteCaches(): List<DriverRouteCacheEntity>
+
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun upsertSyncState(state: DriverSyncStateEntity)
 
     @Query("SELECT * FROM driver_sync_states WHERE scope = :scope AND ifnull(date, '-') = ifnull(:date, '-') AND ifnull(routeId, '-') = ifnull(:routeId, '-') LIMIT 1")
     suspend fun syncState(scope: String, date: String?, routeId: String?): DriverSyncStateEntity?
 
+    @Query("SELECT * FROM driver_sync_states ORDER BY syncedAtEpochMillis DESC")
+    suspend fun allSyncStates(): List<DriverSyncStateEntity>
+
     @Query("DELETE FROM driver_bootstrap_cache")
     suspend fun clearBootstrap()
 

app/src/main/java/pl/firmatpp/kierowca/data/sync/DriverSyncRepository.kt

@@ -3,6 +3,7 @@ package pl.firmatpp.kierowca.data.sync
 import android.content.Context
 import com.google.gson.Gson
 import java.io.IOException
+import java.time.LocalDate
 import pl.firmatpp.kierowca.data.DriverRepository
 import pl.firmatpp.kierowca.data.model.BootstrapResponse
 import pl.firmatpp.kierowca.data.model.DriverRouteDto
@@ -60,6 +61,27 @@ class DriverSyncRepository(
             cachedRoute(routeId, throwable)
         }
 
+    suspend fun bootstrapFromCache(date: String?): CachedValue<BootstrapResponse>? {
+        val cached = dao.bootstrap(date ?: currentDateFallback()) ?: return null
+        return CachedValue(
+            value = gson.fromJson(cached.payloadJson, BootstrapResponse::class.java),
+            stale = true,
+            syncedAtEpochMillis = cached.syncedAtEpochMillis,
+        )
+    }
+
+    suspend fun hasBootstrapCache(date: String?): Boolean =
+        dao.bootstrap(date ?: currentDateFallback()) != null
+
+    suspend fun routeFromCache(routeId: String): CachedValue<RouteResponse>? {
+        val cached = dao.route(routeId) ?: return null
+        return CachedValue(
+            value = gson.fromJson(cached.payloadJson, RouteResponse::class.java),
+            stale = true,
+            syncedAtEpochMillis = cached.syncedAtEpochMillis,
+        )
+    }
+
     suspend fun cacheConfirmedRoute(route: DriverRouteDto, date: String?) {
         val syncedAt = System.currentTimeMillis()
         dao.upsertRoute(
@@ -72,8 +94,8 @@ class DriverSyncRepository(
             ),
         )
 
-        val selectedDate = date ?: return
-        val cachedBootstrap = dao.bootstrap(selectedDate) ?: return
+        (routeVisibleDates(route) + listOfNotNull(date)).distinct().forEach { selectedDate ->
+            val cachedBootstrap = dao.bootstrap(selectedDate) ?: return@forEach
             val response = gson.fromJson(cachedBootstrap.payloadJson, BootstrapResponse::class.java)
             val updatedRoutes = response.routes.today.map { item -> if (item.id == route.id) route else item }
             dao.upsertBootstrap(
@@ -85,6 +107,7 @@ class DriverSyncRepository(
                 ),
             )
         }
+    }
 
     suspend fun fetchSyncState(date: String?, routeId: String?): SyncStateResponse =
         repository.syncState(date, routeId)
@@ -96,6 +119,11 @@ class DriverSyncRepository(
 
     suspend fun saveSyncStates(response: SyncStateResponse?) {
         response?.scopes.orEmpty().forEach { scope ->
+            saveSyncScope(scope)
+        }
+    }
+
+    suspend fun saveSyncScope(scope: SyncScopeDto) {
         dao.upsertSyncState(
             DriverSyncStateEntity(
                 key = syncStateKey(scope.scope, scope.date, scope.routeId),
@@ -109,7 +137,6 @@ class DriverSyncRepository(
             ),
         )
     }
-    }
 
     suspend fun clearCache() {
         dao.clearBootstrap()
@@ -142,15 +169,29 @@ class DriverSyncRepository(
     }
 
     private fun Throwable.isReadFallbackAllowed(): Boolean =
-        this is IOException || (this is HttpException && code() != 401 && code() != 403)
+        this is IOException || (this is HttpException && code() in 500..599)
 
     private fun currentDateFallback(): String = java.time.LocalDate.now().toString()
 
+    private fun routeVisibleDates(route: DriverRouteDto): List<String> {
+        val start = route.routeDate?.let { runCatching { LocalDate.parse(it) }.getOrNull() } ?: return emptyList()
+        val end = route.unloadingDate
+            ?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
+            ?.takeUnless { it.isBefore(start) }
+            ?: start
+
+        return generateSequence(start) { date -> date.plusDays(1).takeIf { !it.isAfter(end) } }
+            .map(LocalDate::toString)
+            .toList()
+    }
+
     companion object {
         const val SCOPE_ROUTES = "routes"
         const val SCOPE_ROUTE_DETAIL = "route_detail"
         const val SCOPE_SETTINGS = "settings"
         const val SCOPE_DISPATCH_SHEET = "dispatch_sheet"
         const val SCOPE_LEAVE_REQUESTS = "leave_requests"
+        const val SCOPE_LEAVE_CALENDAR = "leave_calendar"
+        const val SCOPE_SESSION = "session"
     }
 }

app/src/main/java/pl/firmatpp/kierowca/data/sync/NetworkMonitor.kt

@@ -13,9 +13,7 @@ class NetworkMonitor(context: Context) {
     private val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
 
     val isOnline: Flow<Boolean> = callbackFlow {
-        fun current(): Boolean = connectivityManager.activeNetwork
-            ?.let(connectivityManager::getNetworkCapabilities)
-            ?.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) == true
+        fun current(): Boolean = isCurrentlyValidated()
 
         val callback = object : ConnectivityManager.NetworkCallback() {
             override fun onAvailable(network: Network) {
@@ -35,4 +33,17 @@ class NetworkMonitor(context: Context) {
         connectivityManager.registerDefaultNetworkCallback(callback)
         awaitClose { connectivityManager.unregisterNetworkCallback(callback) }
     }.distinctUntilChanged()
+
+    fun isCurrentlyValidated(): Boolean = connectivityManager.activeNetwork
+        ?.let(connectivityManager::getNetworkCapabilities)
+        ?.let(::hasValidatedInternet) == true
 }
+
+internal fun hasValidatedInternet(capabilities: NetworkCapabilities): Boolean =
+    hasValidatedInternetCapabilities(
+        hasInternet = capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET),
+        hasValidated = capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED),
+    )
+
+internal fun hasValidatedInternetCapabilities(hasInternet: Boolean, hasValidated: Boolean): Boolean =
+    hasInternet && hasValidated

app/src/main/java/pl/firmatpp/kierowca/data/sync/StartupOfflineFallbackLoader.kt

@@ -0,0 +1,27 @@
+package pl.firmatpp.kierowca.data.sync
+
+import java.io.IOException
+import kotlinx.coroutines.withTimeoutOrNull
+import pl.firmatpp.kierowca.domain.StartupSessionPolicy
+
+class StartupOfflineFallbackLoader(
+    private val timeoutMillis: Long = StartupSessionPolicy.OFFLINE_FALLBACK_MILLIS,
+) {
+    suspend fun <T> load(
+        onlineLoad: suspend () -> T,
+        offlineLoad: suspend () -> T?,
+    ): T {
+        val onlineValue = withTimeoutOrNull(timeoutMillis) {
+            onlineLoad()
+        }
+        if (onlineValue != null) {
+            return onlineValue
+        }
+
+        return offlineLoad()
+            ?: throw IOException(
+                "Serwer nie odpowiedział w ciągu ${StartupSessionPolicy.OFFLINE_FALLBACK_SECONDS} sekund " +
+                    "i w telefonie nie ma zapisanych danych offline.",
+            )
+    }
+}

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

@@ -14,6 +14,15 @@ interface DispatchSheetUploadDao {
     @Query("SELECT * FROM dispatch_sheet_uploads WHERE clientRequestId = :clientRequestId LIMIT 1")
     suspend fun find(clientRequestId: String): DispatchSheetUploadEntity?
 
+    @Query("SELECT * FROM dispatch_sheet_uploads WHERE status != 'CONFIRMED' AND status != 'CANCELLED'")
+    suspend fun allUnsent(): List<DispatchSheetUploadEntity>
+
+    @Query("SELECT * FROM dispatch_sheet_uploads")
+    suspend fun allRecords(): List<DispatchSheetUploadEntity>
+
+    @Query("SELECT COUNT(*) FROM dispatch_sheet_uploads WHERE status != 'CONFIRMED' AND status != 'CANCELLED'")
+    fun observeUnsentCount(): Flow<Int>
+
     @Query(
         """
         SELECT * FROM dispatch_sheet_uploads
@@ -63,4 +72,7 @@ interface DispatchSheetUploadDao {
 
     @Query("DELETE FROM dispatch_sheet_uploads WHERE clientRequestId = :clientRequestId")
     suspend fun delete(clientRequestId: String)
+
+    @Query("DELETE FROM dispatch_sheet_uploads")
+    suspend fun deleteAll()
 }

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

@@ -63,12 +63,26 @@ class DispatchSheetUploadOutbox(
     }
 
     suspend fun discard(clientRequestId: String) {
+        workManager.cancelUniqueWork(DispatchSheetUploadWorker.uniqueWorkName(clientRequestId))
         dao.find(clientRequestId)?.let { upload ->
             File(upload.localPath).delete()
             dao.delete(upload.clientRequestId)
         }
     }
 
+    suspend fun retry(clientRequestId: String) {
+        val existing = dao.find(clientRequestId) ?: return
+        dao.upsert(
+            existing.copy(
+                status = PhotoUploadStatus.Pending.storageValue,
+                progress = 0,
+                lastError = null,
+                updatedAtEpochMillis = System.currentTimeMillis(),
+            ),
+        )
+        enqueueWorker(clientRequestId)
+    }
+
     private fun enqueueWorker(clientRequestId: String) {
         val request = OneTimeWorkRequestBuilder<DispatchSheetUploadWorker>()
             .setInputData(workDataOf(DispatchSheetUploadWorker.KEY_CLIENT_REQUEST_ID to clientRequestId))

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

@@ -8,7 +8,9 @@ import java.io.File
 import pl.firmatpp.kierowca.data.ApiErrorKind
 import pl.firmatpp.kierowca.data.ApiErrorMapper
 import pl.firmatpp.kierowca.data.DriverRepository
+import pl.firmatpp.kierowca.data.rethrowIfCancellation
 import pl.firmatpp.kierowca.diagnostics.AppDiagnostics
+import pl.firmatpp.kierowca.data.sync.NetworkMonitor
 
 class DispatchSheetUploadWorker(
     appContext: Context,
@@ -18,6 +20,7 @@ class DispatchSheetUploadWorker(
     private val repository = DriverRepository(appContext)
 
     override suspend fun doWork(): Result {
+        if (!NetworkMonitor(applicationContext).isCurrentlyValidated()) return Result.retry()
         val clientRequestId = inputData.getString(KEY_CLIENT_REQUEST_ID) ?: return Result.failure()
         val upload = dao.find(clientRequestId) ?: return Result.failure()
         val file = File(upload.localPath)
@@ -62,8 +65,11 @@ class DispatchSheetUploadWorker(
             }
 
             dao.markConfirmed(clientRequestId, receipt.serverPhotoId)
+            file.delete()
+            dao.delete(clientRequestId)
             Result.success()
         }.getOrElse { throwable ->
+            throwable.rethrowIfCancellation()
             val error = ApiErrorMapper.map(throwable)
             AppDiagnostics.reportNonFatal(
                 throwable = throwable,

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 = 6,
     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,106 @@ 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)")
+            }
+        }
+
+        private val migration5To6 = object : Migration(5, 6) {
+            override fun migrate(db: SupportSQLiteDatabase) {
+                db.execSQL(
+                    """
+                    CREATE TABLE route_actions_new (
+                        clientActionId TEXT NOT NULL PRIMARY KEY,
+                        routeId TEXT NOT NULL,
+                        action TEXT NOT NULL,
+                        weight REAL,
+                        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(
+                    """
+                    INSERT INTO route_actions_new (
+                        clientActionId, routeId, action, weight, occurredAt, photoClientRequestIdsJson,
+                        status, attemptCount, lastError, createdAtEpochMillis, updatedAtEpochMillis
+                    )
+                    SELECT
+                        clientActionId, routeId, action, weight, occurredAt, photoClientRequestIdsJson,
+                        status, attemptCount, lastError, createdAtEpochMillis, updatedAtEpochMillis
+                    FROM route_actions
+                    """.trimIndent(),
+                )
+                db.execSQL("DROP TABLE route_actions")
+                db.execSQL("ALTER TABLE route_actions_new RENAME TO route_actions")
+                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)")
+            }
+        }
+
         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, migration5To6).build().also { instance = it }
             }
     }
 }

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

@@ -0,0 +1,109 @@
+package pl.firmatpp.kierowca.data.upload
+
+import android.content.Context
+import androidx.work.WorkManager
+import java.io.File
+import java.util.concurrent.TimeUnit
+
+class OfflineOutboxManager(private val context: Context) {
+    private val database = DriverDatabase.get(context)
+    private val workManager = WorkManager.getInstance(context)
+
+    suspend fun pendingCount(): Int =
+        database.photoUploadDao().allUnsent().size +
+            database.dispatchSheetUploadDao().allUnsent().size +
+            database.routeActionDao().allUnsent().size +
+            database.routePointDao().allUnsent().size
+
+    suspend fun repairGpsQueue() {
+        val retryableStatuses = setOf(
+            RoutePointStatus.Pending,
+            RoutePointStatus.Syncing,
+            RoutePointStatus.FailedRetryable,
+        )
+        val routeIds = database.routePointDao().allUnsent()
+            .filter { it.status in retryableStatuses }
+            .map { it.routeId }
+            .distinct()
+
+        routeIds.forEach { routeId ->
+            runCatching {
+                workManager.cancelUniqueWork(RoutePointWorker.uniqueWorkName(routeId))
+                    .result
+                    .get(5, TimeUnit.SECONDS)
+            }
+            RoutePointOutbox(context).enqueueWorker(routeId, delaySeconds = 0L)
+        }
+    }
+
+    suspend fun repairOperationalQueues() {
+        val photoOutbox = PhotoUploadOutbox(context)
+        val dispatchSheetOutbox = DispatchSheetUploadOutbox(context)
+        val routeActionOutbox = RouteActionOutbox(context)
+
+        database.photoUploadDao().allUnsent()
+            .filter { shouldRepairPhotoUpload(it.status, it.lastError) }
+            .forEach { photoOutbox.retry(it.clientRequestId) }
+
+        database.dispatchSheetUploadDao().allUnsent()
+            .filter { shouldRepairPhotoUpload(it.status, it.lastError) }
+            .forEach { dispatchSheetOutbox.retry(it.clientRequestId) }
+
+        database.routeActionDao().allUnsent()
+            .filter { shouldRepairRouteAction(it.status, it.lastError) }
+            .forEach { routeActionOutbox.retry(it.clientActionId) }
+    }
+
+    suspend fun clearAll() {
+        val photos = database.photoUploadDao().allRecords()
+        val dispatchSheets = database.dispatchSheetUploadDao().allRecords()
+        val actions = database.routeActionDao().allUnsent()
+        val points = database.routePointDao().allUnsent()
+
+        photos.forEach {
+            workManager.cancelUniqueWork(PhotoUploadWorker.uniqueWorkName(it.clientRequestId))
+            File(it.localPath).delete()
+        }
+        dispatchSheets.forEach {
+            workManager.cancelUniqueWork(DispatchSheetUploadWorker.uniqueWorkName(it.clientRequestId))
+            File(it.localPath).delete()
+        }
+        actions.forEach { workManager.cancelUniqueWork(RouteActionWorker.uniqueWorkName(it.clientActionId)) }
+        points.map { it.routeId }.distinct().forEach {
+            workManager.cancelUniqueWork(RoutePointWorker.uniqueWorkName(it))
+        }
+
+        database.photoUploadDao().deleteAll()
+        database.dispatchSheetUploadDao().deleteAll()
+        database.routeActionDao().deleteAll()
+        database.routePointDao().deleteAll()
+    }
+}
+
+internal fun isWorkerCancellationFailure(lastError: String?): Boolean =
+    lastError?.let { error ->
+        error.contains("Job was cancelled", ignoreCase = true) ||
+            error.contains("CancellationException", ignoreCase = true)
+    } == true
+
+internal fun isPhotoDependencyFailure(lastError: String?): Boolean =
+    lastError?.contains("Wymagane zdjęcie nie zostało wysłane", ignoreCase = true) == true
+
+internal fun shouldRepairPhotoUpload(status: String, lastError: String?): Boolean =
+    status in setOf(
+        PhotoUploadStatus.Pending.storageValue,
+        PhotoUploadStatus.Uploading.storageValue,
+        PhotoUploadStatus.Verifying.storageValue,
+        PhotoUploadStatus.FailedRetryable.storageValue,
+    ) || (status == PhotoUploadStatus.FailedPermanent.storageValue && isWorkerCancellationFailure(lastError))
+
+internal fun shouldRepairRouteAction(status: String, lastError: String?): Boolean =
+    status in setOf(
+        RouteActionStatus.Pending,
+        RouteActionStatus.WaitingForPhotos,
+        RouteActionStatus.Syncing,
+        RouteActionStatus.FailedRetryable,
+    ) || (
+        status == RouteActionStatus.FailedPermanent &&
+            (isWorkerCancellationFailure(lastError) || isPhotoDependencyFailure(lastError))
+    )

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

@@ -43,6 +43,12 @@ interface PhotoUploadDao {
     )
     suspend fun confirmedForRoute(routeId: String): List<PhotoUploadEntity>
 
+    @Query("SELECT * FROM photo_uploads WHERE status != 'CONFIRMED' AND status != 'CANCELLED'")
+    suspend fun allUnsent(): List<PhotoUploadEntity>
+
+    @Query("SELECT * FROM photo_uploads")
+    suspend fun allRecords(): List<PhotoUploadEntity>
+
     @Query(
         """
         UPDATE photo_uploads
@@ -82,4 +88,7 @@ interface PhotoUploadDao {
 
     @Query("DELETE FROM photo_uploads WHERE clientRequestId = :clientRequestId")
     suspend fun delete(clientRequestId: String)
+
+    @Query("DELETE FROM photo_uploads")
+    suspend fun deleteAll()
 }

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

@@ -16,6 +16,7 @@ import java.util.concurrent.TimeUnit
 import kotlinx.coroutines.flow.Flow
 import pl.firmatpp.kierowca.data.PhotoUploadMetadata
 import pl.firmatpp.kierowca.data.model.DriverRouteDto
+import pl.firmatpp.kierowca.data.model.RoutePhotoDto
 
 class PhotoUploadOutbox(
     private val context: Context,
@@ -28,7 +29,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 +45,7 @@ class PhotoUploadOutbox(
             routeId = routeId,
             localPath = localFile.absolutePath,
             source = source,
+            stage = stage,
             takenAt = metadata.takenAt,
             latitude = metadata.latitude,
             longitude = metadata.longitude,
@@ -73,6 +75,7 @@ class PhotoUploadOutbox(
     }
 
     suspend fun discard(clientRequestId: String) {
+        workManager.cancelUniqueWork(PhotoUploadWorker.uniqueWorkName(clientRequestId))
         dao.find(clientRequestId)?.let { upload ->
             File(upload.localPath).delete()
             dao.delete(upload.clientRequestId)
@@ -80,10 +83,13 @@ class PhotoUploadOutbox(
     }
 
     suspend fun discardConfirmedServerPhotos(route: DriverRouteDto) {
-        dao.confirmedForRoute(route.id).forEach { upload ->
-            File(upload.localPath).delete()
-            dao.delete(upload.clientRequestId)
+        dao.allRecords()
+            .filter { it.routeId == route.id }
+            .filter { upload ->
+                upload.status == PhotoUploadStatus.Confirmed.storageValue ||
+                    route.photos.orEmpty().any { serverPhoto -> serverPhotoConfirmsUpload(upload, serverPhoto) }
             }
+            .forEach { upload -> discard(upload.clientRequestId) }
     }
 
     private fun enqueueWorker(clientRequestId: String) {
@@ -117,3 +123,9 @@ class PhotoUploadOutbox(
         return digest.digest().joinToString("") { "%02x".format(it) }
     }
 }
+
+internal fun serverPhotoConfirmsUpload(upload: PhotoUploadEntity, serverPhoto: RoutePhotoDto): Boolean =
+    serverPhoto.clientRequestId == upload.clientRequestId && (
+        serverPhoto.contentSha256.isNullOrBlank() ||
+            serverPhoto.contentSha256.equals(upload.contentSha256, ignoreCase = true)
+    )

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

@@ -8,16 +8,22 @@ import java.io.File
 import pl.firmatpp.kierowca.data.ApiErrorKind
 import pl.firmatpp.kierowca.data.ApiErrorMapper
 import pl.firmatpp.kierowca.data.DriverRepository
+import pl.firmatpp.kierowca.data.rethrowIfCancellation
 import pl.firmatpp.kierowca.diagnostics.AppDiagnostics
+import pl.firmatpp.kierowca.data.sync.NetworkMonitor
 
 class PhotoUploadWorker(
     appContext: Context,
     params: WorkerParameters,
 ) : CoroutineWorker(appContext, params) {
-    private val dao = DriverDatabase.get(appContext).photoUploadDao()
+    private val database = DriverDatabase.get(appContext)
+    private val dao = database.photoUploadDao()
+    private val routeActionDao = database.routeActionDao()
+    private val routeActionOutbox = RouteActionOutbox(appContext)
     private val repository = DriverRepository(appContext)
 
     override suspend fun doWork(): Result {
+        if (!NetworkMonitor(applicationContext).isCurrentlyValidated()) return Result.retry()
         val clientRequestId = inputData.getString(KEY_CLIENT_REQUEST_ID) ?: return Result.failure()
         val upload = dao.find(clientRequestId) ?: return Result.failure()
         val file = File(upload.localPath)
@@ -62,8 +68,10 @@ class PhotoUploadWorker(
             }
 
             dao.markConfirmed(clientRequestId, receipt.serverPhotoId)
+            enqueueRouteActionsWaitingForPhoto(clientRequestId)
             Result.success()
         }.getOrElse { throwable ->
+            throwable.rethrowIfCancellation()
             val error = ApiErrorMapper.map(throwable)
             AppDiagnostics.reportNonFatal(
                 throwable = throwable,
@@ -90,6 +98,12 @@ class PhotoUploadWorker(
         }
     }
 
+    private suspend fun enqueueRouteActionsWaitingForPhoto(clientRequestId: String) {
+        routeActionDao.waitingForPhotosActions()
+            .filter { routeActionReferencesPhotoClientRequest(it, clientRequestId) }
+            .forEach { routeActionOutbox.enqueueWorker(it.clientActionId) }
+    }
+
     companion object {
         const val KEY_CLIENT_REQUEST_ID = "clientRequestId"
         const val KEY_PROGRESS = "progress"

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

@@ -0,0 +1,76 @@
+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 status != 'CONFIRMED'")
+    suspend fun allUnsent(): List<RouteActionEntity>
+
+    @Query("DELETE FROM route_actions WHERE clientActionId = :clientActionId")
+    suspend fun delete(clientActionId: String)
+
+    @Query("DELETE FROM route_actions")
+    suspend fun deleteAll()
+
+    @Query("DELETE FROM route_actions WHERE status = 'CONFIRMED' AND updatedAtEpochMillis < :beforeEpochMillis")
+    suspend fun pruneConfirmed(beforeEpochMillis: Long)
+
+    @Query("SELECT * FROM route_actions WHERE status = 'WAITING_FOR_PHOTOS'")
+    suspend fun waitingForPhotosActions(): List<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', 'FAILED_RETRYABLE', 'FAILED_CONFLICT', 'FAILED_PERMANENT')
+        OR clientActionId IN (
+            SELECT confirmed.clientActionId
+            FROM route_actions AS confirmed
+            WHERE confirmed.status = 'CONFIRMED'
+            AND confirmed.routeId = route_actions.routeId
+            ORDER BY confirmed.createdAtEpochMillis DESC
+            LIMIT 2
+        )
+        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,87 @@
+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 discard(clientActionId: String) {
+        workManager.cancelUniqueWork(RouteActionWorker.uniqueWorkName(clientActionId))
+        dao.delete(clientActionId)
+    }
+
+    suspend fun retry(clientActionId: String) {
+        val existing = dao.find(clientActionId) ?: return
+        dao.upsert(
+            existing.copy(
+                status = RouteActionStatus.Pending,
+                lastError = null,
+                updatedAtEpochMillis = System.currentTimeMillis(),
+            ),
+        )
+        enqueueWorker(clientActionId)
+    }
+
+    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 {
+        dao.pruneConfirmed(System.currentTimeMillis() - TimeUnit.DAYS.toMillis(7))
+        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
+    }
+
+    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/RouteActionPhotoDependencies.kt

@@ -0,0 +1,17 @@
+package pl.firmatpp.kierowca.data.upload
+
+import com.google.gson.Gson
+
+private val routeActionPhotoDependencyGson = Gson()
+
+fun routeActionReferencesPhotoClientRequest(action: RouteActionEntity, clientRequestId: String): Boolean {
+    val needle = clientRequestId.trim()
+    if (needle.isBlank()) return false
+
+    return runCatching {
+        routeActionPhotoDependencyGson
+            .fromJson(action.photoClientRequestIdsJson, Array<String>::class.java)
+            ?.any { it.trim() == needle }
+            ?: false
+    }.getOrDefault(false)
+}

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

@@ -0,0 +1,146 @@
+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.rethrowIfCancellation
+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.data.sync.NetworkMonitor
+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 {
+        if (!NetworkMonitor(applicationContext).isCurrentlyValidated()) return Result.retry()
+        val clientActionId = inputData.getString(KEY_CLIENT_ACTION_ID) ?: return Result.failure()
+        val action = dao.find(clientActionId) ?: return Result.failure()
+        val photoClientRequestIds = photoClientRequestIds(action)
+
+        val photoDependencies = photoClientRequestIds.mapNotNull { photoDao.find(it) }
+        val permanentlyFailedPhoto = photoDependencies.firstOrNull { it.status == PhotoUploadStatus.FailedPermanent.storageValue }
+        if (permanentlyFailedPhoto != null) {
+            dao.updateStatus(
+                clientActionId = clientActionId,
+                status = RouteActionStatus.FailedPermanent,
+                lastError = "Wymagane zdjęcie nie zostało wysłane. Popraw zdjęcie i ponów potwierdzenie etapu.",
+                attemptIncrement = 0,
+            )
+            return Result.failure()
+        }
+
+        val waitingForPhotos = photoDependencies.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 ->
+            throwable.rethrowIfCancellation()
+            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,66 @@
+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 RoutePointDao {
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun upsert(point: RoutePointEntity)
+
+    @Query(
+        """
+        SELECT * FROM route_points
+        WHERE routeId = :routeId
+        AND status IN ('PENDING', 'SYNCING', 'FAILED_RETRYABLE')
+        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 IN ('PENDING', 'SYNCING', 'FAILED_RETRYABLE')
+        """,
+    )
+    suspend fun pendingCount(routeId: String): Int
+
+    @Query("SELECT * FROM route_points WHERE status != 'CONFIRMED'")
+    suspend fun allUnsent(): List<RoutePointEntity>
+
+    @Query("SELECT COUNT(*) FROM route_points WHERE status IN ('PENDING', 'SYNCING', 'FAILED_RETRYABLE')")
+    fun observeUnsentCount(): Flow<Int>
+
+    @Query("SELECT MIN(createdAtEpochMillis) FROM route_points WHERE status IN ('PENDING', 'SYNCING', 'FAILED_RETRYABLE')")
+    fun observeOldestUnsentAt(): Flow<Long?>
+
+    @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(),
+    )
+
+    @Query("DELETE FROM route_points WHERE clientPointId IN (:clientPointIds)")
+    suspend fun delete(clientPointIds: List<String>)
+
+    @Query("DELETE FROM route_points")
+    suspend fun deleteAll()
+}

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,107 @@
+package pl.firmatpp.kierowca.data.upload
+
+import android.content.Context
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import java.util.UUID
+import kotlinx.coroutines.delay
+import pl.firmatpp.kierowca.data.ApiErrorKind
+import pl.firmatpp.kierowca.data.ApiErrorMapper
+import pl.firmatpp.kierowca.data.DriverRepository
+import pl.firmatpp.kierowca.data.rethrowIfCancellation
+import pl.firmatpp.kierowca.data.model.RoutePointBatchBody
+import pl.firmatpp.kierowca.data.model.RoutePointDto
+import pl.firmatpp.kierowca.diagnostics.AppDiagnostics
+import pl.firmatpp.kierowca.data.sync.NetworkMonitor
+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 {
+        if (!NetworkMonitor(applicationContext).isCurrentlyValidated()) return Result.retry()
+        val routeId = inputData.getString(KEY_ROUTE_ID) ?: return Result.failure()
+        while (!isStopped) {
+            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)
+
+            val outcome = runCatching {
+                repository.storeRoutePoints(
+                    routeId = routeId,
+                    body = RoutePointBatchBody(
+                        clientBatchId = UUID.randomUUID().toString(),
+                        points = points.map { it.toDto() },
+                    ),
+                )
+            }
+            val response = outcome.getOrNull()
+            if (response != null) {
+                dao.delete(pointIds)
+                if (response.arrived) ActiveRouteTrackingService.markArrived(applicationContext, routeId)
+                if (dao.pendingCount(routeId) == 0) {
+                    delay(750L)
+                    if (dao.pendingCount(routeId) == 0) return Result.success()
+                }
+                continue
+            }
+
+            val throwable = outcome.exceptionOrNull() ?: return Result.retry()
+            throwable.rethrowIfCancellation()
+            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,
+                ),
+            )
+            if (isInactiveRoutePointError(error.code)) {
+                dao.delete(pointIds)
+                ActiveRouteTrackingService.stop(applicationContext, routeId)
+                continue
+            }
+
+            val status = if (error.retryable) RoutePointStatus.FailedRetryable else RoutePointStatus.FailedPermanent
+            dao.updateStatus(pointIds, status, error.message, attemptIncrement = 0)
+            return if (error.retryable && error.kind != ApiErrorKind.Auth) Result.retry() else Result.failure()
+        }
+
+        return Result.retry()
+    }
+
+    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"
+    }
+}
+
+internal fun isInactiveRoutePointError(code: String?): Boolean = code == "ROUTE_POINTS_INVALID_STATUS"

app/src/main/java/pl/firmatpp/kierowca/diagnostics/DiagnosticSnapshotProvider.kt

@@ -0,0 +1,349 @@
+package pl.firmatpp.kierowca.diagnostics
+
+import android.Manifest
+import android.app.ActivityManager
+import android.app.NotificationManager
+import android.content.Context
+import android.content.pm.PackageManager
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import android.os.Build
+import android.os.BatteryManager
+import android.os.Environment
+import android.os.PowerManager
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.ContextCompat
+import androidx.work.WorkInfo
+import androidx.work.WorkManager
+import androidx.work.WorkQuery
+import com.google.firebase.FirebaseApp
+import com.google.firebase.messaging.FirebaseMessaging
+import java.io.File
+import java.security.MessageDigest
+import java.time.Instant
+import java.util.concurrent.TimeUnit
+import kotlin.coroutines.resume
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
+import pl.firmatpp.kierowca.BuildConfig
+import pl.firmatpp.kierowca.data.DeviceInfoProvider
+import pl.firmatpp.kierowca.data.TokenStore
+import pl.firmatpp.kierowca.data.upload.DriverDatabase
+
+data class DiagnosticEntry(
+    val label: String,
+    val value: String,
+    val severity: DiagnosticSeverity = DiagnosticSeverity.Neutral,
+)
+
+enum class DiagnosticSeverity { Neutral, Good, Warning, Error }
+
+data class DiagnosticSection(
+    val title: String,
+    val entries: List<DiagnosticEntry>,
+)
+
+data class DiagnosticSnapshot(
+    val generatedAtEpochMillis: Long,
+    val sections: List<DiagnosticSection>,
+) {
+    fun asPlainText(): String = buildString {
+        appendLine("TPP Kierowca, raport diagnostyczny")
+        appendLine("Wygenerowano: ${Instant.ofEpochMilli(generatedAtEpochMillis)}")
+        sections.forEach { section ->
+            appendLine()
+            appendLine("[${section.title}]")
+            section.entries.forEach { entry -> appendLine("${entry.label}: ${entry.value}") }
+        }
+        appendLine()
+        append("Tokeny są celowo przedstawione jako fingerprinty, raport nie zawiera danych pozwalających przejąć sesję.")
+    }
+}
+
+class DiagnosticSnapshotProvider(private val context: Context) {
+    private val database = DriverDatabase.get(context)
+    private val tokenStore = TokenStore(context)
+
+    suspend fun capture(runtimeSections: List<DiagnosticSection>): DiagnosticSnapshot = withContext(Dispatchers.IO) {
+        val token = tokenStore.read()
+        val fcmToken = withTimeoutOrNull(5_000L) { readFirebaseToken() }
+            ?: Result.failure(IllegalStateException("timeout po 5 s"))
+        val device = DeviceInfoProvider(context, tokenStore).currentDeviceInfo()
+        val network = currentNetworkEntries()
+        val photos = database.photoUploadDao().allRecords()
+        val dispatchSheets = database.dispatchSheetUploadDao().allRecords()
+        val actions = database.routeActionDao().allUnsent()
+        val points = database.routePointDao().allUnsent()
+        val cacheDao = database.driverCacheDao()
+        val bootstrapCaches = cacheDao.allBootstrapCaches()
+        val routeCaches = cacheDao.allRouteCaches()
+        val syncStates = cacheDao.allSyncStates()
+        val queuedFiles = (photos.map { it.localPath } + dispatchSheets.map { it.localPath }).map(::File)
+        val activeWork = activeWorkInfo()
+        val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
+        val firebaseOptions = FirebaseApp.getApps(context).firstOrNull()?.options
+        val databaseFile = context.getDatabasePath("driver-local-outbox.db")
+
+        val sections = buildList {
+            add(
+                DiagnosticSection(
+                    "Aplikacja",
+                    listOf(
+                        DiagnosticEntry("Pakiet", BuildConfig.APPLICATION_ID),
+                        DiagnosticEntry("Wersja", "${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE})"),
+                        DiagnosticEntry("Typ buildu", BuildConfig.BUILD_TYPE),
+                        DiagnosticEntry("Debug", yesNo(BuildConfig.DEBUG)),
+                        DiagnosticEntry("API", BuildConfig.API_BASE_URL),
+                        DiagnosticEntry("Reverb URL", BuildConfig.REVERB_WS_BASE_URL),
+                        DiagnosticEntry("Reverb app key", secureIdentifierSummary(BuildConfig.REVERB_APP_KEY)),
+                        DiagnosticEntry("Firebase App ID", firebaseOptions?.applicationId ?: "brak"),
+                        DiagnosticEntry("Firebase Project ID", firebaseOptions?.projectId ?: "brak"),
+                        DiagnosticEntry("Firebase Sender ID", firebaseOptions?.gcmSenderId ?: "brak"),
+                        DiagnosticEntry("Pierwsza instalacja", Instant.ofEpochMilli(packageInfo.firstInstallTime).toString()),
+                        DiagnosticEntry("Ostatnia aktualizacja", Instant.ofEpochMilli(packageInfo.lastUpdateTime).toString()),
+                    ),
+                ),
+            )
+            add(
+                DiagnosticSection(
+                    "Sesja i identyfikatory",
+                    listOf(
+                        DiagnosticEntry("Token sesji", secureIdentifierSummary(token), if (token == null) DiagnosticSeverity.Error else DiagnosticSeverity.Good),
+                        DiagnosticEntry("Token FCM", fcmToken.fold(::secureIdentifierSummary) { "Błąd odczytu: ${it.message ?: it::class.java.simpleName}" }),
+                        DiagnosticEntry("Device ID", secureIdentifierSummary(device.deviceId)),
+                        DiagnosticEntry("Android ID", secureIdentifierSummary(device.androidId)),
+                        DiagnosticEntry("Numer seryjny", secureIdentifierSummary(device.serialNumber)),
+                    ),
+                ),
+            )
+            add(
+                DiagnosticSection(
+                    "Urządzenie",
+                    listOf(
+                        DiagnosticEntry("Producent", device.manufacturer.orEmpty().ifBlank { "brak" }),
+                        DiagnosticEntry("Marka / model", listOfNotNull(device.brand, device.model).joinToString(" ").ifBlank { "brak" }),
+                        DiagnosticEntry("Device / product", listOfNotNull(device.device, device.product).joinToString(" / ").ifBlank { "brak" }),
+                        DiagnosticEntry("Android", "${device.androidVersion ?: "?"}, API ${device.sdkInt}"),
+                        DiagnosticEntry("Build fingerprint", Build.FINGERPRINT),
+                        DiagnosticEntry("Sprzęt / bootloader", "${Build.HARDWARE} / ${Build.BOOTLOADER}"),
+                        DiagnosticEntry("ABI", Build.SUPPORTED_ABIS.joinToString()),
+                        DiagnosticEntry("Język", context.resources.configuration.locales.toLanguageTags().ifBlank { "brak" }),
+                        DiagnosticEntry("Strefa czasowa", java.util.TimeZone.getDefault().id),
+                        DiagnosticEntry("Pamięć aplikacji", storageSummary(context.filesDir)),
+                        DiagnosticEntry("Pamięć współdzielona", storageSummary(Environment.getExternalStorageDirectory())),
+                        DiagnosticEntry("RAM", memorySummary()),
+                        DiagnosticEntry("Bateria", batterySummary()),
+                    ),
+                ),
+            )
+            add(DiagnosticSection("Sieć urządzenia", network))
+            add(
+                DiagnosticSection(
+                    "Uprawnienia i system",
+                    listOf(
+                        permissionEntry("Aparat", Manifest.permission.CAMERA),
+                        permissionEntry("Lokalizacja dokładna", Manifest.permission.ACCESS_FINE_LOCATION),
+                        permissionEntry("Lokalizacja przybliżona", Manifest.permission.ACCESS_COARSE_LOCATION),
+                        notificationPermissionEntry(),
+                        DiagnosticEntry("Powiadomienia systemowe", yesNo(NotificationManagerCompat.from(context).areNotificationsEnabled())),
+                        DiagnosticEntry("Optymalizacja baterii wyłączona", yesNo(isIgnoringBatteryOptimizations())),
+                        DiagnosticEntry("Kanały powiadomień", notificationChannelSummary()),
+                    ),
+                ),
+            )
+            addAll(runtimeSections)
+            add(
+                DiagnosticSection(
+                    "WorkManager",
+                    buildList {
+                        add(DiagnosticEntry("Aktywne zadania", activeWork.size.toString(), if (activeWork.isEmpty()) DiagnosticSeverity.Good else DiagnosticSeverity.Warning))
+                        activeWork.forEach { work ->
+                            add(
+                                DiagnosticEntry(
+                                    work.tags.map { it.substringAfterLast('.') }.sorted().joinToString().ifBlank { work.id.toString() },
+                                    "${work.state}, próba ${work.runAttemptCount}, id ${work.id}",
+                                ),
+                            )
+                        }
+                    },
+                ),
+            )
+            add(
+                DiagnosticSection(
+                    "Lokalna kolejka",
+                    buildList {
+                        add(DiagnosticEntry("Zdjęcia", statusSummary(photos.map { it.status }), queueSeverity(photos.map { it.status })))
+                        add(DiagnosticEntry("Karty spedycyjne", statusSummary(dispatchSheets.map { it.status }), queueSeverity(dispatchSheets.map { it.status })))
+                        add(DiagnosticEntry("Akcje kursu", statusSummary(actions.map { it.status }), queueSeverity(actions.map { it.status })))
+                        add(DiagnosticEntry("Punkty GPS", statusSummary(points.map { it.status }), queueSeverity(points.map { it.status })))
+                        add(DiagnosticEntry("Pliki lokalne", "${queuedFiles.count(File::exists)}/${queuedFiles.size} obecnych, ${formatBytes(queuedFiles.filter(File::exists).sumOf(File::length))}"))
+                        add(DiagnosticEntry("Brakujące pliki", queuedFiles.filterNot(File::exists).joinToString { it.name }.ifBlank { "brak" }, if (queuedFiles.any { !it.exists() }) DiagnosticSeverity.Error else DiagnosticSeverity.Good))
+                        val errors = (photos.mapNotNull { it.lastError } + dispatchSheets.mapNotNull { it.lastError } + actions.mapNotNull { it.lastError } + points.mapNotNull { it.lastError }).distinct()
+                        add(DiagnosticEntry("Błędy kolejki", errors.joinToString(" | ").ifBlank { "brak" }, if (errors.isEmpty()) DiagnosticSeverity.Good else DiagnosticSeverity.Warning))
+                    },
+                ),
+            )
+            add(
+                DiagnosticSection(
+                    "Cache i rewizje",
+                    buildList {
+                        add(DiagnosticEntry("Wersja schematu Room", databaseSchemaVersion().toString()))
+                        add(DiagnosticEntry("Plik bazy", "${if (databaseFile.exists()) formatBytes(databaseFile.length()) else "brak"}, ${databaseFile.absolutePath}"))
+                        add(DiagnosticEntry("Snapshoty list tras", "${bootstrapCaches.size}: ${bootstrapCaches.joinToString { "${it.date}@v${it.version ?: "?"}" }.ifBlank { "brak" }}"))
+                        add(DiagnosticEntry("Snapshoty tras", "${routeCaches.size}: ${routeCaches.joinToString { "${it.routeId}@v${it.version ?: "?"}" }.ifBlank { "brak" }}"))
+                        add(DiagnosticEntry("Scope synchronizacji", syncStates.size.toString()))
+                        syncStates.forEach { sync ->
+                            add(
+                                DiagnosticEntry(
+                                    sync.scope,
+                                    listOfNotNull(sync.date, sync.routeId).joinToString(" / ").let { target ->
+                                        "${target.ifBlank { "globalny" }}, v${sync.version}, checksum ${shortFingerprint(sync.checksum)}, zapis ${Instant.ofEpochMilli(sync.syncedAtEpochMillis)}"
+                                    },
+                                ),
+                            )
+                        }
+                    },
+                ),
+            )
+        }
+
+        DiagnosticSnapshot(System.currentTimeMillis(), sections)
+    }
+
+    private fun currentNetworkEntries(): List<DiagnosticEntry> {
+        val manager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+        val activeNetwork = manager.activeNetwork
+        val capabilities = activeNetwork?.let(manager::getNetworkCapabilities)
+        if (capabilities == null) {
+            return listOf(DiagnosticEntry("Aktywna sieć", "brak", DiagnosticSeverity.Error))
+        }
+        val transports = buildList {
+            if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) add("Wi-Fi")
+            if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) add("sieć komórkowa")
+            if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)) add("Ethernet")
+            if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN)) add("VPN")
+            if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_BLUETOOTH)) add("Bluetooth")
+        }.ifEmpty { listOf("inny") }
+        val validated = capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) &&
+            capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+        val links = activeNetwork?.let(manager::getLinkProperties)
+        return listOf(
+            DiagnosticEntry("Transport", transports.joinToString()),
+            DiagnosticEntry("Internet zweryfikowany", yesNo(validated), if (validated) DiagnosticSeverity.Good else DiagnosticSeverity.Error),
+            DiagnosticEntry("NET_CAPABILITY_INTERNET", yesNo(capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET))),
+            DiagnosticEntry("NET_CAPABILITY_VALIDATED", yesNo(capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED))),
+            DiagnosticEntry("Sieć mierzona", yesNo(!capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED))),
+            DiagnosticEntry("Roaming", yesNo(!capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING))),
+            DiagnosticEntry("Pasmo downstream / upstream", "${capabilities.linkDownstreamBandwidthKbps} / ${capabilities.linkUpstreamBandwidthKbps} kb/s"),
+            DiagnosticEntry("Interfejs", links?.interfaceName ?: "brak"),
+            DiagnosticEntry("Adresy IP", links?.linkAddresses?.joinToString { it.toString() }?.ifBlank { "brak" } ?: "brak"),
+            DiagnosticEntry("DNS", links?.dnsServers?.joinToString { it.hostAddress ?: it.toString() }?.ifBlank { "brak" } ?: "brak"),
+            DiagnosticEntry("MTU", links?.mtu?.toString() ?: "brak"),
+            DiagnosticEntry("Proxy", links?.httpProxy?.toString() ?: "brak"),
+        )
+    }
+
+    private fun activeWorkInfo(): List<WorkInfo> = runCatching {
+        val query = WorkQuery.Builder.fromStates(
+            listOf(WorkInfo.State.ENQUEUED, WorkInfo.State.RUNNING, WorkInfo.State.BLOCKED),
+        ).build()
+        WorkManager.getInstance(context).getWorkInfos(query).get(3, TimeUnit.SECONDS)
+    }.getOrDefault(emptyList())
+
+    private fun databaseSchemaVersion(): Int = runCatching {
+        database.openHelper.readableDatabase.query("PRAGMA user_version").use { cursor ->
+            if (cursor.moveToFirst()) cursor.getInt(0) else -1
+        }
+    }.getOrDefault(-1)
+
+    private fun memorySummary(): String {
+        val manager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+        val info = ActivityManager.MemoryInfo()
+        manager.getMemoryInfo(info)
+        return "wolne ${formatBytes(info.availMem)} z ${formatBytes(info.totalMem)}, niski stan: ${yesNo(info.lowMemory)}"
+    }
+
+    private fun batterySummary(): String {
+        val manager = context.getSystemService(Context.BATTERY_SERVICE) as BatteryManager
+        val level = manager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY).takeIf { it >= 0 }?.let { "$it%" } ?: "brak"
+        return "$level, ładowanie: ${yesNo(manager.isCharging)}"
+    }
+
+    private fun notificationChannelSummary(): String {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return "niewspierane"
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        val channels = manager.notificationChannels
+        return if (channels.isEmpty()) "0" else channels.joinToString { "${it.id}:${it.importance}" }
+    }
+
+    private fun permissionEntry(label: String, permission: String): DiagnosticEntry {
+        val granted = ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED
+        return DiagnosticEntry(label, if (granted) "przyznane" else "brak", if (granted) DiagnosticSeverity.Good else DiagnosticSeverity.Warning)
+    }
+
+    private fun notificationPermissionEntry(): DiagnosticEntry =
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            DiagnosticEntry("Uprawnienie powiadomień", "niewymagane na tej wersji Androida")
+        } else {
+            permissionEntry("Uprawnienie powiadomień", Manifest.permission.POST_NOTIFICATIONS)
+        }
+
+    private fun isIgnoringBatteryOptimizations(): Boolean {
+        val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
+        return powerManager.isIgnoringBatteryOptimizations(context.packageName)
+    }
+
+    private suspend fun readFirebaseToken(): Result<String?> = suspendCancellableCoroutine { continuation ->
+        runCatching { FirebaseMessaging.getInstance().token }
+            .onFailure { continuation.resume(Result.failure(it)) }
+            .onSuccess { task ->
+                task.addOnCompleteListener { completed ->
+                    if (!continuation.isActive) return@addOnCompleteListener
+                    if (completed.isSuccessful) continuation.resume(Result.success(completed.result))
+                    else continuation.resume(Result.failure(completed.exception ?: IllegalStateException("Nieznany błąd FCM")))
+                }
+            }
+    }
+}
+
+internal fun secureIdentifierSummary(value: String?): String {
+    if (value.isNullOrBlank()) return "brak"
+    val fingerprint = MessageDigest.getInstance("SHA-256")
+        .digest(value.toByteArray())
+        .joinToString("") { "%02x".format(it) }
+        .take(12)
+    val suffix = value.takeLast(4)
+    return "obecny, długość ${value.length}, SHA-256 $fingerprint, końcówka …$suffix"
+}
+
+private fun shortFingerprint(value: String): String =
+    MessageDigest.getInstance("SHA-256").digest(value.toByteArray()).joinToString("") { "%02x".format(it) }.take(10)
+
+private fun statusSummary(statuses: List<String>): String =
+    if (statuses.isEmpty()) "0" else statuses.groupingBy { it }.eachCount().entries.sortedBy { it.key }.joinToString { "${it.key}: ${it.value}" }
+
+private fun queueSeverity(statuses: List<String>): DiagnosticSeverity = when {
+    statuses.any { it.contains("PERMANENT") || it.contains("CONFLICT") } -> DiagnosticSeverity.Error
+    statuses.any { it.contains("FAILED") } -> DiagnosticSeverity.Warning
+    statuses.isNotEmpty() -> DiagnosticSeverity.Warning
+    else -> DiagnosticSeverity.Good
+}
+
+private fun storageSummary(directory: File): String =
+    "wolne ${formatBytes(directory.usableSpace)} z ${formatBytes(directory.totalSpace)}"
+
+private fun formatBytes(bytes: Long): String {
+    if (bytes < 1024) return "$bytes B"
+    val units = listOf("KB", "MB", "GB", "TB")
+    var value = bytes.toDouble()
+    var unit = -1
+    while (value >= 1024 && unit < units.lastIndex) {
+        value /= 1024
+        unit++
+    }
+    return "%.1f %s".format(java.util.Locale.US, value, units[unit])
+}
+
+private fun yesNo(value: Boolean): String = if (value) "tak" else "nie"

app/src/main/java/pl/firmatpp/kierowca/domain/RouteDisplayMapper.kt

@@ -2,6 +2,7 @@ package pl.firmatpp.kierowca.domain
 
 import kotlin.math.roundToInt
 import pl.firmatpp.kierowca.data.model.DriverRouteDto
+import pl.firmatpp.kierowca.data.model.driverLifecycleStatus
 
 data class RouteCardDisplay(
     val id: String,
@@ -32,7 +33,7 @@ object RouteDisplayMapper {
             destination = route.destinationName.ifBlank { "Cel" },
             contractLabel = contract,
             time = route.startsAt.ifBlank { "--:--" },
-            status = route.status,
+            status = route.driverLifecycleStatus(),
             distanceLabel = distance,
         )
     }

app/src/main/java/pl/firmatpp/kierowca/domain/StartupSessionPolicy.kt

@@ -0,0 +1,51 @@
+package pl.firmatpp.kierowca.domain
+
+data class StartupSessionMessage(
+    val title: String,
+    val detail: String,
+)
+
+object StartupSessionPolicy {
+    const val OFFLINE_BUTTON_DELAY_SECONDS = 4
+    const val OFFLINE_FALLBACK_SECONDS = 15
+    const val OFFLINE_FALLBACK_MILLIS = OFFLINE_FALLBACK_SECONDS * 1_000L
+
+    fun remainingSeconds(elapsedSeconds: Int): Int =
+        (OFFLINE_FALLBACK_SECONDS - elapsedSeconds).coerceAtLeast(0)
+
+    fun shouldShowOfflineButton(elapsedSeconds: Int, offlineDataAvailable: Boolean): Boolean =
+        offlineDataAvailable && elapsedSeconds >= OFFLINE_BUTTON_DELAY_SECONDS
+
+    fun message(elapsedSeconds: Int): StartupSessionMessage = when {
+        elapsedSeconds < 3 -> StartupSessionMessage(
+            title = "Sprawdzamy zapisaną sesję",
+            detail = "Odczytujemy bezpieczne logowanie kierowcy.",
+        )
+        elapsedSeconds < 6 -> StartupSessionMessage(
+            title = "Potwierdzamy logowanie",
+            detail = "Łączymy telefon z serwerem.",
+        )
+        elapsedSeconds < 9 -> StartupSessionMessage(
+            title = "Pobieramy aktualne kursy",
+            detail = "Synchronizujemy plan dnia i ustawienia aplikacji.",
+        )
+        elapsedSeconds < 12 -> StartupSessionMessage(
+            title = "To trwa dłużej niż zwykle",
+            detail = "Przy słabym zasięgu skorzystamy z danych zapisanych w telefonie.",
+        )
+        else -> StartupSessionMessage(
+            title = "Przygotowujemy tryb offline",
+            detail = "Za chwilę pokażemy ostatnie zapisane kursy.",
+        )
+    }
+
+    fun countdownLabel(elapsedSeconds: Int): String {
+        val remaining = remainingSeconds(elapsedSeconds)
+
+        return if (remaining > 0) {
+            "Tryb offline najpóźniej za $remaining s"
+        } else {
+            "Otwieramy zapisane dane offline"
+        }
+    }
+}

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

@@ -7,6 +7,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
 import pl.firmatpp.kierowca.data.DriverRepository
+import pl.firmatpp.kierowca.data.sync.NetworkMonitor
 
 class DriverFirebaseMessagingService : FirebaseMessagingService() {
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
@@ -14,7 +15,7 @@ class DriverFirebaseMessagingService : FirebaseMessagingService() {
     override fun onNewToken(token: String) {
         scope.launch {
             val repository = DriverRepository(applicationContext)
-            if (repository.hasToken()) {
+            if (repository.hasToken() && NetworkMonitor(applicationContext).isCurrentlyValidated()) {
                 runCatching { repository.storePushToken(token) }
             }
         }
@@ -38,20 +39,26 @@ class DriverFirebaseMessagingService : FirebaseMessagingService() {
                 title = data["title"],
                 body = data["body"],
             )
+            if (!DriverRuntimeSyncState.websocketOwnsForegroundHints()) {
                 DriverSyncWorker.enqueue(
                     context = applicationContext,
                     date = data["date"],
                     routeId = data["routeId"],
                 )
+            }
             return
         }
 
         if (data["type"] != "driver_sync_hint") return
+        if (DriverRuntimeSyncState.websocketOwnsForegroundHints()) return
 
         DriverSyncWorker.enqueue(
             context = applicationContext,
             date = data["date"],
             routeId = data["routeId"],
+            scope = data["scope"],
+            version = data["version"]?.toLongOrNull(),
+            checksum = data["checksum"],
         )
     }
 }

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

@@ -3,6 +3,7 @@ package pl.firmatpp.kierowca.sync
 import com.google.gson.Gson
 import com.google.gson.JsonObject
 import com.google.gson.JsonParser
+import java.net.URI
 import java.util.concurrent.TimeUnit
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -11,6 +12,9 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.WebSocket
@@ -19,6 +23,8 @@ 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
+import pl.firmatpp.kierowca.data.ApiErrorKind
+import pl.firmatpp.kierowca.data.ApiErrorMapper
 
 interface DriverLiveSyncGateway {
     suspend fun broadcastAuth(socketId: String, channelName: String): BroadcastAuthResponse
@@ -37,17 +43,34 @@ class DriverRepositoryLiveSyncGateway(
 }
 
 interface LiveWebSocketFactory {
-    fun newWebSocket(url: String, listener: WebSocketListener): WebSocket
+    fun newWebSocket(url: String, origin: 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)
+    override fun newWebSocket(url: String, origin: String?, listener: WebSocketListener): WebSocket =
+        client.newWebSocket(
+            Request.Builder()
+                .url(url)
+                .header("Origin", origin?.takeIf { it.isNotBlank() } ?: websocketOrigin(url))
+                .build(),
+            listener,
+        )
 }
 
-private enum class LiveSyncConnectionState {
+internal fun websocketOrigin(url: String): String =
+    URI(
+        url
+        .replaceFirst("wss://", "https://")
+        .replaceFirst("ws://", "http://")
+    ).let { uri ->
+        val defaultPort = (uri.scheme == "https" && uri.port == 443) || (uri.scheme == "http" && uri.port == 80)
+        val port = if (uri.port > 0 && !defaultPort) ":${uri.port}" else ""
+        "${uri.scheme}://${uri.host}$port"
+    }
+
+enum class LiveSyncConnectionState {
     Stopped,
     WaitingForNetwork,
     Disconnected,
@@ -56,10 +79,24 @@ private enum class LiveSyncConnectionState {
     Connected,
 }
 
+data class LiveSyncDiagnostics(
+    val state: LiveSyncConnectionState,
+    val desiredActive: Boolean,
+    val networkAvailable: Boolean,
+    val foregroundActive: Boolean,
+    val configured: Boolean,
+    val socketId: String?,
+    val reconnectAttempt: Int,
+    val messageVersion: Long,
+    val lastMessageAtEpochMillis: Long?,
+    val lastDisconnectReason: String?,
+)
+
 class DriverLiveSyncClient(
     private val gateway: DriverLiveSyncGateway,
     private val onConnected: () -> Unit,
     private val onHint: (DriverSyncHint) -> Unit,
+    private val onAuthenticationFailed: () -> Unit = {},
     private val webSocketFactory: LiveWebSocketFactory = OkHttpLiveWebSocketFactory(defaultOkHttpClient()),
     private val gson: Gson = Gson(),
     private val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO),
@@ -70,12 +107,14 @@ class DriverLiveSyncClient(
         repository: DriverRepository,
         onConnected: () -> Unit,
         onHint: (DriverSyncHint) -> Unit,
+        onAuthenticationFailed: () -> Unit = {},
         client: OkHttpClient = defaultOkHttpClient(),
         gson: Gson = Gson(),
     ) : this(
         gateway = DriverRepositoryLiveSyncGateway(repository),
         onConnected = onConnected,
         onHint = onHint,
+        onAuthenticationFailed = onAuthenticationFailed,
         webSocketFactory = OkHttpLiveWebSocketFactory(client),
         gson = gson,
     )
@@ -104,6 +143,31 @@ class DriverLiveSyncClient(
     private var staleWatchdogJob: Job? = null
     private var reconnectAttempt: Int = 0
     private var messageVersion: Long = 0
+    private var lastMessageAtEpochMillis: Long? = null
+    private var lastDisconnectReason: String? = null
+    private var foregroundActive: Boolean = true
+    private val _connectionState = MutableStateFlow(LiveSyncConnectionState.Stopped)
+    val connectionState: StateFlow<LiveSyncConnectionState> = _connectionState.asStateFlow()
+
+    fun diagnostics(): LiveSyncDiagnostics = synchronized(lock) {
+        LiveSyncDiagnostics(
+            state = state,
+            desiredActive = desiredActive,
+            networkAvailable = networkAvailable,
+            foregroundActive = foregroundActive,
+            configured = realtimeConfig != null,
+            socketId = socketId,
+            reconnectAttempt = reconnectAttempt,
+            messageVersion = messageVersion,
+            lastMessageAtEpochMillis = lastMessageAtEpochMillis,
+            lastDisconnectReason = lastDisconnectReason,
+        )
+    }
+
+    private fun updateState(next: LiveSyncConnectionState) {
+        state = next
+        _connectionState.value = next
+    }
 
     fun start(driverId: String, config: RealtimeConfigDto?) {
         if (!isConfigUsable(config)) return
@@ -119,6 +183,7 @@ class DriverLiveSyncClient(
     fun ensureConnected() {
         val shouldConnect = synchronized(lock) {
             desiredActive &&
+                foregroundActive &&
                 networkAvailable &&
                 state !in setOf(
                     LiveSyncConnectionState.Connecting,
@@ -136,20 +201,30 @@ class DriverLiveSyncClient(
                 reconnectJob?.cancel()
                 reconnectJob = null
                 closeSocketLocked("network_lost")
-                state = if (desiredActive) LiveSyncConnectionState.WaitingForNetwork else LiveSyncConnectionState.Stopped
+                updateState(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)
     }
 
-        if (shouldReconnect) connectNow(resetAttempt = true)
+    fun setForeground(active: Boolean) {
+        val shouldConnect = synchronized(lock) {
+            foregroundActive = active
+            if (!active) {
+                reconnectJob?.cancel()
+                reconnectJob = null
+                closeSocketLocked("app_background")
+                updateState(LiveSyncConnectionState.Stopped)
+                false
+            } else {
+                desiredActive && networkAvailable
+            }
+        }
+        if (shouldConnect) connectNow(resetAttempt = true)
     }
 
     fun stop() {
@@ -162,7 +237,7 @@ class DriverLiveSyncClient(
             realtimeConfig = null
             socketId = null
             reconnectAttempt = 0
-            state = LiveSyncConnectionState.Stopped
+            updateState(LiveSyncConnectionState.Stopped)
         }
         reportRealtimeStatus("disconnected", "client_stop")
     }
@@ -173,25 +248,29 @@ class DriverLiveSyncClient(
     }
 
     private fun connectNow(resetAttempt: Boolean = false) {
-        val wsUrl = synchronized(lock) {
+        val (wsUrl, origin) = synchronized(lock) {
             val config = realtimeConfig ?: return
             val id = driverId ?: return
-            if (!desiredActive || !networkAvailable || !isConfigUsable(config)) return
+            if (!desiredActive || !foregroundActive || !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
+            updateState(LiveSyncConnectionState.Connecting)
 
             val appKey = config.reverbAppKey.orEmpty()
             val wsBaseUrl = config.reverbWsBaseUrl.orEmpty()
-            wsBaseUrl.trimEnd('/') + "/" + appKey + "?protocol=7&client=android&version=1.0&flash=false"
+            Pair(
+                wsBaseUrl.trimEnd('/') + "/" + appKey + "?protocol=7&client=android&version=1.0&flash=false",
+                config.reverbOrigin,
+            )
         }
 
         val socket = webSocketFactory.newWebSocket(
             wsUrl,
+            origin,
             object : WebSocketListener() {
                 override fun onMessage(webSocket: WebSocket, text: String) {
                     handleMessage(webSocket, text)
@@ -227,6 +306,7 @@ class DriverLiveSyncClient(
                 false
             } else {
                 messageVersion += 1
+                lastMessageAtEpochMillis = System.currentTimeMillis()
                 true
             }
         }
@@ -244,7 +324,7 @@ class DriverLiveSyncClient(
                 val nextSocketId = root.dataObject()?.string("socket_id") ?: return
                 synchronized(lock) {
                     socketId = nextSocketId
-                    state = LiveSyncConnectionState.Subscribing
+                    updateState(LiveSyncConnectionState.Subscribing)
                 }
                 subscribe(socket, nextSocketId)
             }
@@ -254,7 +334,7 @@ class DriverLiveSyncClient(
                 if (channel == "private-driver-mobile.$id") {
                     synchronized(lock) {
                         reconnectAttempt = 0
-                        state = LiveSyncConnectionState.Connected
+                        updateState(LiveSyncConnectionState.Connected)
                     }
                     reportRealtimeStatus("connected")
                     startHeartbeat()
@@ -272,10 +352,11 @@ class DriverLiveSyncClient(
 
     private fun subscribe(socket: WebSocket, socketId: String) {
         val id = synchronized(lock) { driverId } ?: return
-        val channel = "private-driver-mobile.$id"
+        val channels = listOf("private-driver-mobile.$id", "private-driver-mobile.0")
 
         scope.launch {
             runCatching {
+                channels.forEach { channel ->
                     val auth = gateway.broadcastAuth(socketId, channel).auth
                     if (!isCurrentSocket(socket)) return@launch
                     val payload = mapOf(
@@ -286,8 +367,13 @@ class DriverLiveSyncClient(
                         ),
                     )
                     check(socket.send(gson.toJson(payload))) { "WebSocket send returned false" }
+                }
             }.onFailure { throwable ->
                 AppDiagnostics.log("realtime_subscription_error: ${throwable.message ?: throwable::class.java.simpleName}")
+                if (ApiErrorMapper.map(throwable).kind == ApiErrorKind.Auth) {
+                    handleAuthenticationFailure(socket)
+                    return@onFailure
+                }
                 socket.close(1000, "subscription_failed")
                 handleDisconnect("error", "subscription_failed", socket)
             }
@@ -302,15 +388,16 @@ class DriverLiveSyncClient(
             stopStaleWatchdogLocked()
             webSocket = null
             socketId = null
+            lastDisconnectReason = reason
 
             if (!desiredActive) {
-                state = LiveSyncConnectionState.Stopped
+                updateState(LiveSyncConnectionState.Stopped)
                 false
             } else if (!networkAvailable) {
-                state = LiveSyncConnectionState.WaitingForNetwork
+                updateState(LiveSyncConnectionState.WaitingForNetwork)
                 false
             } else {
-                state = LiveSyncConnectionState.Disconnected
+                updateState(LiveSyncConnectionState.Disconnected)
                 true
             }
         }
@@ -321,7 +408,7 @@ class DriverLiveSyncClient(
 
     private fun scheduleReconnect() {
         val delayMs = synchronized(lock) {
-            if (!desiredActive || !networkAvailable || state == LiveSyncConnectionState.Stopped) return
+            if (!desiredActive || !foregroundActive || !networkAvailable || state == LiveSyncConnectionState.Stopped) return
             if (reconnectJob?.isActive == true) return
             val delay = reconnectDelaysMs.getOrElse(reconnectAttempt) { reconnectDelaysMs.last() }
             reconnectAttempt += 1
@@ -399,10 +486,26 @@ class DriverLiveSyncClient(
         scope.launch {
             runCatching {
                 gateway.storeRealtimeStatus(status, socketId, error)
+            }.onFailure { throwable ->
+                if (ApiErrorMapper.map(throwable).kind == ApiErrorKind.Auth) handleAuthenticationFailure()
             }
         }
     }
 
+    private fun handleAuthenticationFailure(socket: WebSocket? = null) {
+        val notify = synchronized(lock) {
+            if (socket != null && webSocket !== socket) return
+            val wasActive = desiredActive
+            desiredActive = false
+            reconnectJob?.cancel()
+            reconnectJob = null
+            closeSocketLocked("authentication_failed")
+            updateState(LiveSyncConnectionState.Stopped)
+            wasActive
+        }
+        if (notify) onAuthenticationFailed()
+    }
+
     private fun isConfigUsable(config: RealtimeConfigDto?): Boolean =
         config?.reverbEnabled == true &&
             !config.reverbAppKey.isNullOrBlank() &&

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

@@ -0,0 +1,8 @@
+package pl.firmatpp.kierowca.sync
+
+object DriverRuntimeSyncState {
+    @Volatile var foreground: Boolean = false
+    @Volatile var realtimeConnected: Boolean = false
+
+    fun websocketOwnsForegroundHints(): Boolean = foreground && realtimeConnected
+}

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

@@ -13,7 +13,10 @@ import androidx.work.workDataOf
 import java.util.concurrent.TimeUnit
 import pl.firmatpp.kierowca.data.ApiErrorKind
 import pl.firmatpp.kierowca.data.ApiErrorMapper
+import pl.firmatpp.kierowca.data.rethrowIfCancellation
 import pl.firmatpp.kierowca.data.sync.DriverSyncRepository
+import pl.firmatpp.kierowca.data.sync.NetworkMonitor
+import pl.firmatpp.kierowca.data.model.SyncScopeDto
 import pl.firmatpp.kierowca.diagnostics.AppDiagnostics
 
 class DriverSyncWorker(
@@ -23,9 +26,20 @@ class DriverSyncWorker(
     private val syncRepository = DriverSyncRepository(appContext)
 
     override suspend fun doWork(): Result =
+        if (!NetworkMonitor(applicationContext).isCurrentlyValidated()) Result.retry() else
         runCatching {
             val date = inputData.getString(KEY_DATE)
             val routeId = inputData.getString(KEY_ROUTE_ID)
+            val hintedScope = inputData.getString(KEY_SCOPE)?.let { scope ->
+                val version = inputData.getLong(KEY_VERSION, -1L)
+                val checksum = inputData.getString(KEY_CHECKSUM)
+                if (version >= 0L && !checksum.isNullOrBlank()) {
+                    SyncScopeDto(scope, date, routeId, version, checksum, computedAt = "")
+                } else null
+            }
+            if (hintedScope != null && !syncRepository.shouldRefresh(hintedScope)) {
+                return@runCatching Result.success()
+            }
             val response = syncRepository.fetchSyncState(date, routeId)
             var refreshed = false
 
@@ -52,6 +66,10 @@ class DriverSyncWorker(
                             syncRepository.saveSyncStates(response)
                             refreshed = true
                         }
+                        DriverSyncRepository.SCOPE_LEAVE_CALENDAR -> {
+                            syncRepository.saveSyncStates(response)
+                            refreshed = true
+                        }
                     }
                 }
             }
@@ -62,6 +80,7 @@ class DriverSyncWorker(
 
             Result.success()
         }.getOrElse { throwable ->
+            throwable.rethrowIfCancellation()
             val error = ApiErrorMapper.map(throwable)
             AppDiagnostics.reportNonFatal(
                 throwable = throwable,
@@ -81,17 +100,33 @@ class DriverSyncWorker(
     companion object {
         private const val KEY_DATE = "date"
         private const val KEY_ROUTE_ID = "routeId"
+        private const val KEY_SCOPE = "scope"
+        private const val KEY_VERSION = "version"
+        private const val KEY_CHECKSUM = "checksum"
 
-        fun enqueue(context: Context, date: String?, routeId: String?) {
+        fun enqueue(
+            context: Context,
+            date: String?,
+            routeId: String?,
+            scope: String? = null,
+            version: Long? = null,
+            checksum: String? = null,
+        ) {
             val request = OneTimeWorkRequestBuilder<DriverSyncWorker>()
-                .setInputData(workDataOf(KEY_DATE to date, KEY_ROUTE_ID to routeId))
+                .setInputData(workDataOf(
+                    KEY_DATE to date,
+                    KEY_ROUTE_ID to routeId,
+                    KEY_SCOPE to scope,
+                    KEY_VERSION to version,
+                    KEY_CHECKSUM to checksum,
+                ))
                 .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build())
                 .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
                 .build()
 
             WorkManager.getInstance(context).enqueueUniqueWork(
-                listOf("driver-sync", date ?: "-", routeId ?: "-").joinToString("-"),
-                ExistingWorkPolicy.REPLACE,
+                listOf("driver-sync", scope ?: "all", date ?: "-", routeId ?: "-").joinToString("-"),
+                ExistingWorkPolicy.KEEP,
                 request,
             )
         }

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

@@ -26,6 +26,8 @@ import pl.firmatpp.kierowca.R
 import pl.firmatpp.kierowca.data.ApiErrorKind
 import pl.firmatpp.kierowca.data.ApiErrorMapper
 import pl.firmatpp.kierowca.data.DriverRepository
+import pl.firmatpp.kierowca.data.rethrowIfCancellation
+import pl.firmatpp.kierowca.data.sync.NetworkMonitor
 import pl.firmatpp.kierowca.diagnostics.AppDiagnostics
 import retrofit2.HttpException
 
@@ -36,6 +38,7 @@ class NewRouteNotificationWorker(
     private val repository = DriverRepository(appContext)
 
     override suspend fun doWork(): Result {
+        if (!NetworkMonitor(applicationContext).isCurrentlyValidated()) return Result.retry()
         val routeId = inputData.getString(KEY_ROUTE_ID)?.takeIf(String::isNotBlank) ?: return Result.success()
 
         return runCatching {
@@ -73,6 +76,7 @@ class NewRouteNotificationWorker(
             NotificationManagerCompat.from(applicationContext).notify(route.id.hashCode(), notification)
             Result.success()
         }.getOrElse { throwable ->
+            throwable.rethrowIfCancellation()
             if (throwable is HttpException && throwable.code() == 404) {
                 Result.success()
             } else {

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

@@ -0,0 +1,328 @@
+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 -> {
+                val requestedRouteId = intent.getStringExtra(EXTRA_ROUTE_ID)
+                if (!requestedRouteId.isNullOrBlank() && routeId != requestedRouteId) {
+                    return START_NOT_STICKY
+                }
+                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
+                    runCatching { locationManager.removeUpdates(this) }
+                    startForegroundCompat(buildNotification())
+                }
+                return START_NOT_STICKY
+            }
+            else -> {
+                val nextRouteId = intent?.getStringExtra(EXTRA_ROUTE_ID) ?: routeId
+                val nextDriverId = intent?.getStringExtra(EXTRA_DRIVER_ID) ?: driverId
+                if (nextRouteId.isNullOrBlank() || nextDriverId.isNullOrBlank()) {
+                    stopSelf()
+                    return START_NOT_STICKY
+                }
+                val routeChanged = nextRouteId != routeId
+                routeId = nextRouteId
+                driverId = nextDriverId
+                getSharedPreferences(TRACKING_PREFERENCES, Context.MODE_PRIVATE)
+                    .edit()
+                    .putString(ACTIVE_ROUTE_ID, nextRouteId)
+                    .apply()
+                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
+                if (routeChanged) arrived = false
+                startForegroundCompat(buildNotification())
+                if (!arrived) requestLocationUpdates()
+                return START_NOT_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
+            runCatching { locationManager.removeUpdates(this) }
+            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) }
+        getSharedPreferences(TRACKING_PREFERENCES, Context.MODE_PRIVATE)
+            .edit()
+            .remove(ACTIVE_ROUTE_ID)
+            .apply()
+        scope.cancel()
+        super.onDestroy()
+    }
+
+    private fun requestLocationUpdates() {
+        if (!hasLocationPermission() || routeId.isNullOrBlank() || driverId.isNullOrBlank()) {
+            return
+        }
+        runCatching { locationManager.removeUpdates(this) }
+        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"
+        private const val TRACKING_PREFERENCES = "active_route_tracking"
+        private const val ACTIVE_ROUTE_ID = "active_route_id"
+
+        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, routeId: String? = null) {
+            val activeRouteId = context.getSharedPreferences(TRACKING_PREFERENCES, Context.MODE_PRIVATE)
+                .getString(ACTIVE_ROUTE_ID, null)
+            if (routeId == null || routeId == activeRouteId) {
+                context.stopService(Intent(context, ActiveRouteTrackingService::class.java))
+                context.getSharedPreferences(TRACKING_PREFERENCES, Context.MODE_PRIVATE)
+                    .edit()
+                    .remove(ACTIVE_ROUTE_ID)
+                    .apply()
+            }
+        }
+
+        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/DriverLeaveRequestUiRules.kt

@@ -1,6 +1,7 @@
 package pl.firmatpp.kierowca.ui
 
 import java.time.LocalDate
+import pl.firmatpp.kierowca.data.model.DriverLeaveCalendarEntryDto
 
 data class LeaveRequestsConfig(
     val enabled: Boolean = false,
@@ -52,4 +53,41 @@ object DriverLeaveRequestUiRules {
         val start = runCatching { LocalDate.parse(dateFrom) }.getOrNull() ?: return false
         return start.isAfter(today)
     }
+
+    fun calendarEntriesForDate(entries: List<DriverLeaveCalendarEntryDto>, date: LocalDate): List<DriverLeaveCalendarEntryDto> =
+        entries.filter { entry ->
+            val from = entry.dateFrom?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
+            val to = entry.dateTo?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
+            from != null && to != null && !date.isBefore(from) && !date.isAfter(to)
+        }
+
+    fun calendarEntriesForRange(entries: List<DriverLeaveCalendarEntryDto>, dateFrom: String, dateTo: String): List<DriverLeaveCalendarEntryDto> {
+        val selectedFrom = runCatching { LocalDate.parse(dateFrom) }.getOrNull() ?: return emptyList()
+        val selectedTo = runCatching { LocalDate.parse(dateTo) }.getOrNull() ?: return emptyList()
+        val from = minOf(selectedFrom, selectedTo)
+        val to = maxOf(selectedFrom, selectedTo)
+
+        return entries.filter { entry ->
+            val entryFrom = entry.dateFrom?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
+            val entryTo = entry.dateTo?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
+            entryFrom != null && entryTo != null && !entryTo.isBefore(from) && !entryFrom.isAfter(to)
+        }
+    }
+
+    fun phoneDialUri(phoneNumber: String?): String? {
+        val raw = phoneNumber?.trim().orEmpty()
+        if (raw.isBlank()) return null
+
+        val digits = raw.filter { it.isDigit() }
+        if (digits.isBlank()) return null
+
+        val normalized = when {
+            digits.startsWith("00") -> "+${digits.drop(2)}"
+            raw.startsWith("+") -> "+$digits"
+            digits.length == 9 -> "+48$digits"
+            else -> "+$digits"
+        }
+
+        return "tel:$normalized"
+    }
 }

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

@@ -0,0 +1,80 @@
+package pl.firmatpp.kierowca.ui
+
+import pl.firmatpp.kierowca.data.model.DriverRouteDto
+import pl.firmatpp.kierowca.data.model.RoutePhotoDto
+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",
+                        driverStatus = "W TRAKCIE",
+                        loadingWeight = action.weight,
+                        trackingStatus = "active",
+                        photos = projectedRoute.safePhotos(),
+                    )
+                    loadingWeightPending = action.status != RouteActionStatus.Confirmed
+                }
+                RouteActionType.Finish -> {
+                    projectedRoute = projectedRoute.copy(
+                        status = "ZAKOŃCZONA",
+                        driverStatus = "ZAKOŃCZONA",
+                        unloadingWeight = action.weight,
+                        trackingStatus = "finished",
+                        completedAt = action.occurredAt,
+                        photos = projectedRoute.safePhotos(),
+                    )
+                    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
+
+internal fun DriverRouteDto.safePhotos(): List<RoutePhotoDto> = photos.orEmpty()

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

@@ -1,28 +1,433 @@
 package pl.firmatpp.kierowca.ui
 
 import java.io.File
+import java.math.BigDecimal
+import java.math.RoundingMode
+import java.net.URLEncoder
 import java.time.DayOfWeek
 import java.time.LocalDate
 import java.time.OffsetDateTime
 import java.time.format.DateTimeFormatter
 import java.time.temporal.ChronoUnit
+import java.util.Locale
+import kotlin.math.abs
 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.model.driverLifecycleStatus
 import pl.firmatpp.kierowca.data.upload.PhotoUploadEntity
+import pl.firmatpp.kierowca.data.upload.PhotoUploadStatus
+import pl.firmatpp.kierowca.data.upload.isWorkerCancellationFailure
+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")
+private val routeWeightKilogramInputThreshold = BigDecimal("1000")
+private const val routeWeightMaxTons = 999.999
+private const val googleMapsPackage = "com.google.android.apps.maps"
+
+data class NavigationIntentCandidate(
+    val uri: String,
+    val packageName: String? = null,
+)
+
+fun hasValidNavigationCoordinates(latitude: Double?, longitude: Double?): Boolean =
+    latitude != null &&
+        longitude != null &&
+        latitude.isFinite() &&
+        longitude.isFinite() &&
+        latitude in -90.0..90.0 &&
+        longitude in -180.0..180.0
+
+fun navigationIntentCandidates(
+    latitude: Double?,
+    longitude: Double?,
+    label: String?,
+): List<NavigationIntentCandidate> {
+    if (!hasValidNavigationCoordinates(latitude, longitude)) return emptyList()
+
+    val coordinates = "$latitude,$longitude"
+    val encodedLabel = URLEncoder
+        .encode(label?.takeIf { it.isNotBlank() } ?: "Cel", Charsets.UTF_8.name())
+        .replace("+", "%20")
+
+    return listOf(
+        NavigationIntentCandidate(
+            uri = "google.navigation:q=$coordinates",
+            packageName = googleMapsPackage,
+        ),
+        NavigationIntentCandidate(uri = "geo:0,0?q=$coordinates($encodedLabel)"),
+        NavigationIntentCandidate(uri = "https://www.google.com/maps/dir/?api=1&destination=$coordinates"),
+    )
+}
+
+enum class RouteFlowStepState {
+    Todo,
+    ServerSaved,
+    InProgress,
+    Syncing,
+    Confirmed,
+    NeedsAttention,
+}
+
+enum class RouteLifecycleAction {
+    Start,
+    Finish,
+}
+
+data class RouteFlowStepUi(
+    val key: String,
+    val title: String,
+    val state: RouteFlowStepState,
+    val stateLabel: String,
+    val dateLabel: String? = null,
+)
+
+data class RouteLifecycleActionUi(
+    val label: String,
+    val action: RouteLifecycleAction,
+)
+
+data class RouteSyncCalloutUi(
+    val text: String,
+    val isConflict: Boolean,
+    val canCorrect: Boolean,
+)
 
 fun canManageRoutePhotos(selectedDate: String, today: LocalDate = LocalDate.now()): Boolean =
     runCatching { LocalDate.parse(selectedDate).isEqual(today) }.getOrDefault(false)
 
+fun routeIsActiveToday(
+    route: DriverRouteDto,
+    selectedDate: String,
+    today: LocalDate = LocalDate.now(),
+): Boolean {
+    val viewedDate = runCatching { LocalDate.parse(selectedDate) }.getOrNull() ?: return false
+    val loadingDate = route.routeDate?.let { runCatching { LocalDate.parse(it) }.getOrNull() } ?: return false
+    val unloadingDate = route.unloadingDate
+        ?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
+        ?: loadingDate
+
+    return viewedDate == today && !today.isBefore(loadingDate) && !today.isAfter(unloadingDate)
+}
+
+fun routeUnloadingDate(route: DriverRouteDto): String? = route.unloadingDate ?: route.routeDate
+
+fun routeDayOrdering(route: DriverRouteDto, date: String): Int =
+    route.dayOrderings?.get(date) ?: route.ordering ?: Int.MAX_VALUE
+
+fun routeScheduleDateLabel(date: String?): String =
+    date
+        ?.let { runCatching { LocalDate.parse(it).format(shortDateFormatter) }.getOrNull() }
+        ?: "—"
+
+fun routeScheduleSummary(route: DriverRouteDto): String {
+    val loading = routeScheduleDateLabel(route.routeDate)
+    val unloading = routeScheduleDateLabel(routeUnloadingDate(route))
+
+    return if (route.unloadingDate == null) {
+        "Załadunek: $loading · Rozładunek: ten sam dzień"
+    } else {
+        "Załadunek: $loading · Rozładunek: $unloading"
+    }
+}
+
+fun routeTodayInstruction(
+    route: DriverRouteDto,
+    selectedDate: String,
+    today: LocalDate = LocalDate.now(),
+): String? {
+    if (!routeIsActiveToday(route, selectedDate, today)) return null
+
+    val loadingDate = route.routeDate?.let { runCatching { LocalDate.parse(it) }.getOrNull() } ?: return null
+    val unloadingDate = routeUnloadingDate(route)?.let { runCatching { LocalDate.parse(it) }.getOrNull() } ?: loadingDate
+
+    return when {
+        route.driverLifecycleStatus() == "ZAKOŃCZONA" -> "Kurs zakończony."
+        loadingDate == unloadingDate -> "Dziś: załadunek i rozładunek."
+        today == loadingDate -> "Dziś: załadunek."
+        today == unloadingDate && route.driverLifecycleStatus() == "ZAPLANOWANA" -> "Dziś: rozładunek. Załadunek możesz potwierdzić dzisiaj."
+        today == unloadingDate -> "Dziś: rozładunek."
+        else -> "Kurs jest w trasie. Rozładunek: ${routeScheduleDateLabel(routeUnloadingDate(route))}."
+    }
+}
+
 fun canCompleteRouteFromDriverApp(
     route: DriverRouteDto,
     selectedDate: String,
     today: LocalDate = LocalDate.now(),
 ): Boolean =
-    canManageRoutePhotos(selectedDate, today)
-        && route.status in setOf("ZAPLANOWANA", "W TRAKCIE")
+    runCatching { LocalDate.parse(selectedDate) }.getOrNull() == today
+        && routeUnloadingDate(route)?.let { runCatching { LocalDate.parse(it) }.getOrNull() } == today
+        && route.driverLifecycleStatus() in setOf("ZAPLANOWANA", "W TRAKCIE")
+
+fun canStartRouteFromDriverApp(
+    route: DriverRouteDto,
+    selectedDate: String,
+    today: LocalDate = LocalDate.now(),
+): Boolean =
+    routeIsActiveToday(route, selectedDate, today)
+        && route.driverLifecycleStatus() == "ZAPLANOWANA"
+
+fun canFinishRouteFromDriverApp(
+    route: DriverRouteDto,
+    selectedDate: String,
+    today: LocalDate = LocalDate.now(),
+): Boolean =
+    route.driverLifecycleStatus() == "W TRAKCIE"
+        && runCatching { LocalDate.parse(selectedDate) }.getOrNull() == today
+        && routeUnloadingDate(route)?.let { runCatching { LocalDate.parse(it) }.getOrNull() } == today
+
+object RouteStageRequirement {
+    const val Required = "required"
+    const val Optional = "optional"
+    const val Disabled = "disabled"
+}
+
+fun normalizeRouteStageRequirement(value: String?): String = when (value) {
+    RouteStageRequirement.Optional -> RouteStageRequirement.Optional
+    RouteStageRequirement.Disabled -> RouteStageRequirement.Disabled
+    else -> RouteStageRequirement.Required
+}
+
+fun routeStageRequirementIsVisible(requirement: String): Boolean =
+    normalizeRouteStageRequirement(requirement) != RouteStageRequirement.Disabled
+
+fun routeStageRequirementIsRequired(requirement: String): Boolean =
+    normalizeRouteStageRequirement(requirement) == RouteStageRequirement.Required
+
+fun parseRouteWeightTons(weightText: String): Double? {
+    val enteredWeight = weightText.trim().replace(',', '.').toBigDecimalOrNull() ?: return null
+    val tons = if (enteredWeight.abs() >= routeWeightKilogramInputThreshold) {
+        enteredWeight.movePointLeft(3)
+    } else {
+        enteredWeight
+    }
+
+    return tons.setScale(3, RoundingMode.HALF_UP).toDouble()
+}
+
+fun routeWeightInputHelpText(weightText: String): String {
+    val enteredWeight = weightText.trim().replace(',', '.').toDoubleOrNull()
+    val tons = parseRouteWeightTons(weightText)
+    val enteredAsKilograms = enteredWeight != null &&
+        abs(enteredWeight) >= routeWeightKilogramInputThreshold.toDouble() &&
+        tons != null
+
+    return if (enteredAsKilograms) {
+        "Wpisano kilogramy — zapiszemy ${String.format(Locale("pl", "PL"), "%.3f", tons)} t."
+    } else {
+        "Wpisz tony (np. 23,4). Wartości od 1000 rozpoznajemy jako kilogramy (np. 23400)."
+    }
+}
+
+fun canSubmitRouteStageForm(
+    weightText: String,
+    serverPhotoCount: Int,
+    localUploadCount: Int,
+    weightRequirement: String = RouteStageRequirement.Required,
+    photoRequirement: String = RouteStageRequirement.Required,
+): Boolean {
+    return routeStageSubmitBlocker(
+        weightText,
+        serverPhotoCount,
+        localUploadCount,
+        weightRequirement,
+        photoRequirement,
+    ) == null
+}
+
+fun loadingPhotosSubmitBlocker(
+    serverPhotoCount: Int,
+    localUploadCount: Int,
+    photoRequirement: String = RouteStageRequirement.Required,
+): String? =
+    if (
+        routeStageRequirementIsRequired(photoRequirement) &&
+        visiblePhotoAttachmentCount(serverPhotoCount, localUploadCount) <= 0
+    ) {
+        "Dodaj co najmniej jedno zdjęcie załadunku."
+    } else {
+        null
+    }
+
+fun loadingWeightSubmitBlocker(
+    weightText: String,
+    serverPhotoCount: Int,
+    localUploadCount: Int,
+    weightRequirement: String = RouteStageRequirement.Required,
+    photoRequirement: String = RouteStageRequirement.Required,
+): String? {
+    val trimmed = weightText.trim()
+    val normalizedWeight = parseRouteWeightTons(trimmed)
+    val weightVisible = routeStageRequirementIsVisible(weightRequirement)
+
+    return when {
+        weightVisible && routeStageRequirementIsRequired(weightRequirement) && trimmed.isBlank() -> "Podaj tonaż."
+        weightVisible && trimmed.isNotBlank() && normalizedWeight == null -> "Podaj poprawny tonaż."
+        weightVisible && normalizedWeight != null && normalizedWeight <= 0.0 -> "Tonaż musi być większy od zera."
+        weightVisible && normalizedWeight != null && normalizedWeight > routeWeightMaxTons -> "Tonaż nie może przekraczać 999,999 t."
+        loadingPhotosSubmitBlocker(serverPhotoCount, localUploadCount, photoRequirement) != null -> "Dodaj co najmniej jedno zdjęcie załadunku."
+        else -> null
+    }
+}
+
+fun routeStageSubmitBlocker(
+    weightText: String,
+    serverPhotoCount: Int,
+    localUploadCount: Int,
+    weightRequirement: String = RouteStageRequirement.Required,
+    photoRequirement: String = RouteStageRequirement.Required,
+): String? {
+    val trimmed = weightText.trim()
+    val normalizedWeight = parseRouteWeightTons(trimmed)
+    val weightVisible = routeStageRequirementIsVisible(weightRequirement)
+
+    return when {
+        weightVisible && routeStageRequirementIsRequired(weightRequirement) && trimmed.isBlank() -> "Podaj tonaż."
+        weightVisible && trimmed.isNotBlank() && normalizedWeight == null -> "Podaj poprawny tonaż."
+        weightVisible && normalizedWeight != null && normalizedWeight <= 0.0 -> "Tonaż musi być większy od zera."
+        weightVisible && normalizedWeight != null && normalizedWeight > routeWeightMaxTons -> "Tonaż nie może przekraczać 999,999 t."
+        routeStageRequirementIsRequired(photoRequirement) && 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("Załaduj", RouteLifecycleAction.Start)
+        canFinishRouteFromDriverApp(route, selectedDate, today) -> RouteLifecycleActionUi("Rozładuj", 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.Pending,
+                RouteActionStatus.Syncing -> "Trwa wysyłanie zmiany statusu kursu."
+                RouteActionStatus.FailedRetryable -> "Nie udało się wysłać. Aplikacja spróbuje ponownie."
+                else -> "Zmiana zapisana w telefonie. Aplikacja wyśle ją automatycznie."
+            }
+        },
+        isConflict = isConflict,
+        canCorrect = unresolved.status == RouteActionStatus.FailedPermanent,
+    )
+}
+
+fun routeFlowSteps(
+    route: DriverRouteDto,
+    actions: List<RouteActionEntity>,
+    loadingPhotoRequirement: String = RouteStageRequirement.Required,
+    loadingWeightRequirement: String = RouteStageRequirement.Required,
+): List<RouteFlowStepUi> {
+    val startOverride = routeActionStepState(actions, RouteActionType.Start)
+    val finishOverride = routeActionStepState(actions, RouteActionType.Finish)
+    val loadingPhotoCount = routePhotosForStage(route.photos, "loading").size
+    val driverStatus = route.driverLifecycleStatus()
+    val loadingPhotosState = when {
+        startOverride != null -> startOverride
+        driverStatus == "ZAKOŃCZONA" -> RouteFlowStepState.Confirmed
+        driverStatus == "W TRAKCIE" -> RouteFlowStepState.Confirmed
+        loadingPhotoCount > 0 -> RouteFlowStepState.ServerSaved
+        else -> RouteFlowStepState.Todo
+    }
+    val loadingWeightState = startOverride ?: when {
+        driverStatus == "ZAKOŃCZONA" -> RouteFlowStepState.Confirmed
+        driverStatus == "W TRAKCIE" -> RouteFlowStepState.Confirmed
+        route.loadingWeight != null -> RouteFlowStepState.ServerSaved
+        else -> RouteFlowStepState.Todo
+    }
+    val transitState = when {
+        finishOverride != null -> RouteFlowStepState.InProgress
+        driverStatus == "ZAKOŃCZONA" -> RouteFlowStepState.Confirmed
+        startOverride != null -> startOverride
+        driverStatus == "W TRAKCIE" -> RouteFlowStepState.InProgress
+        else -> RouteFlowStepState.Todo
+    }
+    val unloadingState = finishOverride ?: when {
+        driverStatus == "ZAKOŃCZONA" -> RouteFlowStepState.Confirmed
+        route.unloadingWeight != null -> RouteFlowStepState.ServerSaved
+        else -> RouteFlowStepState.Todo
+    }
+
+    return buildList {
+        if (routeStageRequirementIsVisible(loadingPhotoRequirement)) {
+            add(RouteFlowStepUi("loading_photos", "Zdjęcia załadunku", loadingPhotosState, routeFlowStateLabel(loadingPhotosState), routeScheduleDateLabel(route.routeDate)))
+        }
+        if (routeStageRequirementIsVisible(loadingWeightRequirement)) {
+            add(RouteFlowStepUi("loading_weight", "Tonaż załadunku", loadingWeightState, routeFlowStateLabel(loadingWeightState), routeScheduleDateLabel(route.routeDate)))
+        }
+        add(RouteFlowStepUi("transit", "W trasie", transitState, routeFlowStateLabel(transitState)))
+        add(RouteFlowStepUi("unloading", "Rozładunek", unloadingState, routeFlowStateLabel(unloadingState), routeScheduleDateLabel(routeUnloadingDate(route))))
+    }
+}
+
+fun routePhotosForStage(photos: List<RoutePhotoDto>?, stage: String): List<RoutePhotoDto> {
+    val normalized = normalizedRoutePhotoStage(stage)
+    return photos.orEmpty().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.ServerSaved -> "zapisane na serwerze"
+        RouteFlowStepState.InProgress -> "w trakcie"
+        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 +464,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
@@ -100,6 +517,18 @@ fun routeFactColumns(screenWidthDp: Int): Int =
 fun visiblePhotoAttachmentCount(serverPhotoCount: Int, localUploadCount: Int): Int =
     serverPhotoCount.coerceAtLeast(0) + localUploadCount.coerceAtLeast(0)
 
+fun photoUploadCanSatisfyStage(status: String): Boolean =
+    status in setOf(
+        PhotoUploadStatus.Pending.storageValue,
+        PhotoUploadStatus.Uploading.storageValue,
+        PhotoUploadStatus.Verifying.storageValue,
+        PhotoUploadStatus.Confirmed.storageValue,
+        PhotoUploadStatus.FailedRetryable.storageValue,
+    )
+
+fun routeStageUsableUploads(uploads: List<PhotoUploadEntity>): List<PhotoUploadEntity> =
+    uploads.filter { photoUploadCanSatisfyStage(it.status) }
+
 fun queuedPhotoUploadCount(statuses: List<String>): Int =
     statuses.count { status -> status != "CONFIRMED" && status != "CANCELLED" }
 
@@ -111,8 +540,15 @@ fun routePhotoSortEpochMillis(createdAt: String?, takenAt: String?, fallback: Lo
 fun confirmedUploadServerPhotoId(status: String, serverPhotoId: String?): String? =
     serverPhotoId?.takeIf { status == "CONFIRMED" && it.isNotBlank() }
 
-fun canRetryPhotoUpload(status: String): Boolean =
-    status == "FAILED_RETRYABLE"
+fun canRetryPhotoUpload(status: String, lastError: String? = null): Boolean =
+    status == PhotoUploadStatus.FailedRetryable.storageValue ||
+        (status == PhotoUploadStatus.FailedPermanent.storageValue && isWorkerCancellationFailure(lastError))
+
+fun canDiscardLocalPhotoUpload(status: String, serverPhotoId: String?): Boolean =
+    serverPhotoId.isNullOrBlank() && status in setOf(
+        PhotoUploadStatus.FailedRetryable.storageValue,
+        PhotoUploadStatus.FailedPermanent.storageValue,
+    )
 
 fun canShowPhotoUploadFailureDetails(status: String, lastError: String?): Boolean =
     status in setOf("FAILED_RETRYABLE", "FAILED_PERMANENT") && !lastError.isNullOrBlank()
@@ -126,6 +562,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(),
@@ -139,6 +576,14 @@ fun localUploadPreviewPhoto(upload: PhotoUploadEntity): RoutePhotoDto? {
     )
 }
 
+fun routeScreenAfterServerRefresh(currentScreen: DriverScreen, route: DriverRouteDto): DriverScreen =
+    when {
+        currentScreen in setOf(DriverScreen.StartRoute, DriverScreen.LoadingWeight) &&
+            route.driverLifecycleStatus() in setOf("W TRAKCIE", "ZAKOŃCZONA") -> DriverScreen.Detail
+        currentScreen == DriverScreen.FinishRoute && route.driverLifecycleStatus() == "ZAKOŃCZONA" -> DriverScreen.Detail
+        else -> currentScreen
+    }
+
 fun canLaunchCameraWithLocationPolicy(requirePreciseLocation: Boolean, hasFineLocation: Boolean): Boolean =
     !requirePreciseLocation || hasFineLocation
 
@@ -161,6 +606,21 @@ fun offlineStaleBannerMessage(isOnline: Boolean, isStale: Boolean, syncLabel: St
         else -> "Dane mogą być nieaktualne. Ostatnia synchronizacja: $syncLabel."
     }
 
+fun connectionStatusBannerMessage(
+    isOnline: Boolean,
+    isStale: Boolean,
+    serverConnectionState: ServerConnectionState,
+    showRealtimeReconnecting: Boolean,
+    syncLabel: String,
+): String? = when {
+    !isOnline -> offlineStaleBannerMessage(false, isStale, syncLabel)
+    serverConnectionState == ServerConnectionState.Degraded ->
+        "Internet działa, ale serwer jest chwilowo niedostępny. Pokazujemy dane z $syncLabel."
+    showRealtimeReconnecting -> "Ponowne łączenie. Dane są uzgadniane z serwerem."
+    isStale -> offlineStaleBannerMessage(true, true, syncLabel)
+    else -> null
+}
+
 private fun parseIsoOffsetEpochMillis(value: String?): Long? =
     value?.takeIf { it.isNotBlank() }?.let {
         runCatching { OffsetDateTime.parse(it).toInstant().toEpochMilli() }.getOrNull()

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

@@ -2,12 +2,27 @@ package pl.firmatpp.kierowca.data
 
 import java.io.IOException
 import java.net.UnknownHostException
+import kotlin.coroutines.cancellation.CancellationException
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
+import org.junit.Assert.assertSame
 import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
 import org.junit.Test
 
 class ApiErrorMapperTest {
+    @Test
+    fun rethrowsWorkerCancellationInsteadOfMappingItAsApplicationFailure() {
+        val cancellation = CancellationException("Job was cancelled")
+
+        try {
+            cancellation.rethrowIfCancellation()
+            fail("CancellationException should be rethrown")
+        } catch (thrown: CancellationException) {
+            assertSame(cancellation, thrown)
+        }
+    }
+
     @Test
     fun mapsNetworkFailuresToRetryableOfflineMessage() {
         val error = ApiErrorMapper.map(IOException("timeout"))

app/src/test/java/pl/firmatpp/kierowca/data/sync/NetworkMonitorTest.kt

@@ -0,0 +1,17 @@
+package pl.firmatpp.kierowca.data.sync
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class NetworkMonitorTest {
+    @Test
+    fun captivePortalIsNotTreatedAsOnline() {
+        assertFalse(hasValidatedInternetCapabilities(hasInternet = true, hasValidated = false))
+    }
+
+    @Test
+    fun validatedInternetIsOnline() {
+        assertTrue(hasValidatedInternetCapabilities(hasInternet = true, hasValidated = true))
+    }
+}

app/src/test/java/pl/firmatpp/kierowca/data/sync/StartupOfflineFallbackLoaderTest.kt

@@ -0,0 +1,70 @@
+package pl.firmatpp.kierowca.data.sync
+
+import java.io.IOException
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class StartupOfflineFallbackLoaderTest {
+    @Test
+    fun returnsServerDataBeforeTimeout() = runTest {
+        val loader = StartupOfflineFallbackLoader(timeoutMillis = 1_000L)
+
+        val result = loader.load(
+            onlineLoad = { "server" },
+            offlineLoad = { "cache" },
+        )
+
+        assertEquals("server", result)
+    }
+
+    @Test
+    fun returnsCachedDataWhenServerExceedsTimeout() = runTest {
+        val loader = StartupOfflineFallbackLoader(timeoutMillis = 1_000L)
+
+        val result = loader.load(
+            onlineLoad = {
+                delay(2_000L)
+                "server"
+            },
+            offlineLoad = { "cache" },
+        )
+
+        assertEquals("cache", result)
+    }
+
+    @Test
+    fun reportsMissingOfflineDataAfterTimeout() = runTest {
+        val loader = StartupOfflineFallbackLoader(timeoutMillis = 1_000L)
+
+        val error = runCatching {
+            loader.load(
+                onlineLoad = {
+                    delay(2_000L)
+                    "server"
+                },
+                offlineLoad = { null },
+            )
+        }.exceptionOrNull()
+
+        assertTrue(error is IOException)
+    }
+
+    @Test
+    fun doesNotHideAuthenticationFailures() = runTest {
+        val loader = StartupOfflineFallbackLoader(timeoutMillis = 1_000L)
+        val authenticationFailure = IllegalStateException("401")
+
+        val error = runCatching {
+            loader.load(
+                onlineLoad = { throw authenticationFailure },
+                offlineLoad = { "cache" },
+            )
+        }.exceptionOrNull()
+
+        assertTrue(error is IllegalStateException)
+        assertEquals(authenticationFailure.message, error?.message)
+    }
+}

app/src/test/java/pl/firmatpp/kierowca/data/upload/OfflineOutboxManagerTest.kt

@@ -0,0 +1,43 @@
+package pl.firmatpp.kierowca.data.upload
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class OfflineOutboxManagerTest {
+    @Test
+    fun recognizesLegacyCancellationFailureDetails() {
+        assertTrue(isWorkerCancellationFailure("Typ: błąd aplikacji\nKomunikat: Job was cancelled"))
+        assertTrue(isWorkerCancellationFailure("kotlinx.coroutines.JobCancellationException"))
+        assertFalse(isWorkerCancellationFailure("HTTP 422: Niepoprawne zdjęcie"))
+        assertFalse(isWorkerCancellationFailure(null))
+    }
+
+    @Test
+    fun repairsInterruptedAndRetryablePhotoUploadsButNotRealPermanentFailures() {
+        assertTrue(shouldRepairPhotoUpload(PhotoUploadStatus.Pending.storageValue, null))
+        assertTrue(shouldRepairPhotoUpload(PhotoUploadStatus.Uploading.storageValue, null))
+        assertTrue(shouldRepairPhotoUpload(PhotoUploadStatus.Verifying.storageValue, null))
+        assertTrue(shouldRepairPhotoUpload(PhotoUploadStatus.FailedRetryable.storageValue, "timeout"))
+        assertTrue(shouldRepairPhotoUpload(PhotoUploadStatus.FailedPermanent.storageValue, "Job was cancelled"))
+        assertFalse(shouldRepairPhotoUpload(PhotoUploadStatus.FailedPermanent.storageValue, "HTTP 422"))
+        assertFalse(shouldRepairPhotoUpload(PhotoUploadStatus.Cancelled.storageValue, null))
+    }
+
+    @Test
+    fun repairsInterruptedRouteActionWithItsOriginalIdempotencyKey() {
+        assertTrue(shouldRepairRouteAction(RouteActionStatus.Pending, null))
+        assertTrue(shouldRepairRouteAction(RouteActionStatus.WaitingForPhotos, null))
+        assertTrue(shouldRepairRouteAction(RouteActionStatus.Syncing, null))
+        assertTrue(shouldRepairRouteAction(RouteActionStatus.FailedRetryable, "timeout"))
+        assertTrue(shouldRepairRouteAction(RouteActionStatus.FailedPermanent, "Job was cancelled"))
+        assertTrue(
+            shouldRepairRouteAction(
+                RouteActionStatus.FailedPermanent,
+                "Wymagane zdjęcie nie zostało wysłane. Popraw zdjęcie i ponów potwierdzenie etapu.",
+            ),
+        )
+        assertFalse(shouldRepairRouteAction(RouteActionStatus.FailedPermanent, "Brakuje zdjęcia"))
+        assertFalse(shouldRepairRouteAction(RouteActionStatus.FailedConflict, "Kurs już rozpoczęty"))
+    }
+}

app/src/test/java/pl/firmatpp/kierowca/data/upload/PhotoUploadReconciliationTest.kt

@@ -0,0 +1,62 @@
+package pl.firmatpp.kierowca.data.upload
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import pl.firmatpp.kierowca.data.model.RoutePhotoDto
+
+class PhotoUploadReconciliationTest {
+    @Test
+    fun serverReceiptIdentityClearsFalseLocalFailure() {
+        val upload = upload(
+            clientRequestId = "request-1",
+            contentSha256 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        )
+
+        assertTrue(serverPhotoConfirmsUpload(upload, serverPhoto("request-1", upload.contentSha256.uppercase())))
+        assertFalse(serverPhotoConfirmsUpload(upload, serverPhoto("request-2", upload.contentSha256)))
+        assertFalse(serverPhotoConfirmsUpload(upload, serverPhoto("request-1", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")))
+    }
+
+    @Test
+    fun legacyServerPhotoWithoutHashStillConfirmsMatchingRequestId() {
+        val upload = upload("request-1", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+
+        assertTrue(serverPhotoConfirmsUpload(upload, serverPhoto("request-1", null)))
+    }
+
+    private fun upload(clientRequestId: String, contentSha256: String): PhotoUploadEntity =
+        PhotoUploadEntity(
+            clientRequestId = clientRequestId,
+            routeId = "10",
+            localPath = "/tmp/$clientRequestId.jpg",
+            source = "camera",
+            takenAt = null,
+            latitude = null,
+            longitude = null,
+            locationAccuracyMeters = null,
+            mimeType = "image/jpeg",
+            size = 100,
+            contentSha256 = contentSha256,
+            status = PhotoUploadStatus.FailedPermanent.storageValue,
+            lastError = "Typ: błąd aplikacji\nKomunikat: Job was cancelled",
+        )
+
+    private fun serverPhoto(clientRequestId: String, contentSha256: String?): RoutePhotoDto =
+        RoutePhotoDto(
+            id = "42",
+            routeId = "10",
+            clientRequestId = clientRequestId,
+            contentSha256 = contentSha256,
+            source = "camera",
+            stage = "loading",
+            mimeType = "image/jpeg",
+            size = 100,
+            url = "https://example.test/photo/42",
+            takenAt = null,
+            latitude = null,
+            longitude = null,
+            locationAccuracyMeters = null,
+            createdAt = null,
+        )
+}

app/src/test/java/pl/firmatpp/kierowca/data/upload/RouteActionPhotoDependenciesTest.kt

@@ -0,0 +1,31 @@
+package pl.firmatpp.kierowca.data.upload
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class RouteActionPhotoDependenciesTest {
+    @Test
+    fun detectsRouteActionWaitingForConfirmedPhotoClientRequest() {
+        val action = action("""["photo-a","photo-b"]""")
+
+        assertTrue(routeActionReferencesPhotoClientRequest(action, "photo-b"))
+        assertFalse(routeActionReferencesPhotoClientRequest(action, "photo-c"))
+    }
+
+    @Test
+    fun malformedPhotoRequestJsonDoesNotMatch() {
+        assertFalse(routeActionReferencesPhotoClientRequest(action("not-json"), "photo-a"))
+    }
+
+    private fun action(photoClientRequestIdsJson: String): RouteActionEntity =
+        RouteActionEntity(
+            clientActionId = "action-1",
+            routeId = "route-1",
+            action = RouteActionType.Start,
+            weight = 12.5,
+            occurredAt = "2026-06-30T07:40:00Z",
+            photoClientRequestIdsJson = photoClientRequestIdsJson,
+            status = RouteActionStatus.WaitingForPhotos,
+        )
+}

app/src/test/java/pl/firmatpp/kierowca/data/upload/RoutePointWorkerRulesTest.kt

@@ -0,0 +1,18 @@
+package pl.firmatpp.kierowca.data.upload
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class RoutePointWorkerRulesTest {
+    @Test
+    fun inactiveRouteConflictDiscardsObsoleteGpsPoints() {
+        assertTrue(isInactiveRoutePointError("ROUTE_POINTS_INVALID_STATUS"))
+    }
+
+    @Test
+    fun temporaryServerFailureDoesNotDiscardGpsPoints() {
+        assertFalse(isInactiveRoutePointError("SERVER_UNAVAILABLE"))
+        assertFalse(isInactiveRoutePointError(null))
+    }
+}

app/src/test/java/pl/firmatpp/kierowca/diagnostics/DiagnosticSnapshotProviderTest.kt

@@ -0,0 +1,39 @@
+package pl.firmatpp.kierowca.diagnostics
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class DiagnosticSnapshotProviderTest {
+    @Test
+    fun secureIdentifierSummaryDoesNotExposeWholeToken() {
+        val token = "secret-session-token-123456"
+
+        val summary = secureIdentifierSummary(token)
+
+        assertFalse(summary.contains(token))
+        assertTrue(summary.contains("długość ${token.length}"))
+        assertTrue(summary.contains("końcówka …3456"))
+        assertTrue(summary.contains("SHA-256"))
+    }
+
+    @Test
+    fun copiedReportExplainsThatCredentialsAreRedacted() {
+        val snapshot = DiagnosticSnapshot(
+            generatedAtEpochMillis = 1_700_000_000_000,
+            sections = listOf(
+                DiagnosticSection(
+                    title = "Sesja",
+                    entries = listOf(DiagnosticEntry("Token", secureIdentifierSummary("top-secret"))),
+                ),
+            ),
+        )
+
+        val report = snapshot.asPlainText()
+
+        assertTrue(report.contains("[Sesja]"))
+        assertTrue(report.contains("Token: obecny"))
+        assertTrue(report.contains("nie zawiera danych pozwalających przejąć sesję"))
+        assertFalse(report.contains("top-secret"))
+    }
+}

app/src/test/java/pl/firmatpp/kierowca/domain/RouteDisplayMapperTest.kt

@@ -16,7 +16,9 @@ class RouteDisplayMapperTest {
             contractName = "Odpady przemyslowe",
             contractCode = "TPP-ODP-24",
             relationLabel = "TPP Baza Krakow -> Instalacja Odpadowa Slask",
-            status = "ZAPLANOWANA",
+            status = "ZAKOŃCZONA",
+            driverStatus = "ZAPLANOWANA",
+            operationalStatus = "ZAKOŃCZONA",
             distanceKm = 91.4,
             notes = null,
             truck = null,
@@ -29,6 +31,7 @@ class RouteDisplayMapperTest {
         assertEquals("Instalacja Odpadowa Slask", display.destination)
         assertEquals("TPP-ODP-24", display.contractLabel)
         assertEquals("09:15", display.time)
+        assertEquals("ZAPLANOWANA", display.status)
         assertEquals("91 km", display.distanceLabel)
     }
 }

app/src/test/java/pl/firmatpp/kierowca/domain/StartupSessionPolicyTest.kt

@@ -0,0 +1,32 @@
+package pl.firmatpp.kierowca.domain
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class StartupSessionPolicyTest {
+    @Test
+    fun rotatesStartupMessagesAsWaitingTimeIncreases() {
+        assertEquals("Sprawdzamy zapisaną sesję", StartupSessionPolicy.message(0).title)
+        assertEquals("Potwierdzamy logowanie", StartupSessionPolicy.message(3).title)
+        assertEquals("Pobieramy aktualne kursy", StartupSessionPolicy.message(6).title)
+        assertEquals("To trwa dłużej niż zwykle", StartupSessionPolicy.message(9).title)
+        assertEquals("Przygotowujemy tryb offline", StartupSessionPolicy.message(12).title)
+    }
+
+    @Test
+    fun countsDownToOfflineFallbackWithoutGoingBelowZero() {
+        assertEquals(15, StartupSessionPolicy.remainingSeconds(0))
+        assertEquals(7, StartupSessionPolicy.remainingSeconds(8))
+        assertEquals(0, StartupSessionPolicy.remainingSeconds(15))
+        assertEquals(0, StartupSessionPolicy.remainingSeconds(30))
+        assertEquals("Tryb offline najpóźniej za 5 s", StartupSessionPolicy.countdownLabel(10))
+        assertEquals("Otwieramy zapisane dane offline", StartupSessionPolicy.countdownLabel(15))
+    }
+
+    @Test
+    fun showsManualOfflineButtonAfterFourSecondsOnlyWhenCacheExists() {
+        assertEquals(false, StartupSessionPolicy.shouldShowOfflineButton(3, offlineDataAvailable = true))
+        assertEquals(true, StartupSessionPolicy.shouldShowOfflineButton(4, offlineDataAvailable = true))
+        assertEquals(false, StartupSessionPolicy.shouldShowOfflineButton(10, offlineDataAvailable = false))
+    }
+}

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

@@ -23,8 +23,26 @@ class DriverLiveSyncClientTest {
         reverbEnabled = true,
         reverbAppKey = "app-key",
         reverbWsBaseUrl = "wss://example.test/app",
+        reverbOrigin = "https://bootstrap-origin.test",
     )
 
+    @Test
+    fun derivesBrowserCompatibleOriginFromWebSocketUrl() {
+        assertEquals("https://api-intranet.firmatpp.pl", websocketOrigin("wss://api-intranet.firmatpp.pl/ws/app/app-key"))
+        assertEquals("https://example.test:8443", websocketOrigin("wss://example.test:8443/app/app-key"))
+        assertEquals("http://localhost:8080", websocketOrigin("ws://localhost:8080/app/app-key"))
+    }
+
+    @Test
+    fun passesBootstrapOriginToWebSocketFactory() = runTest {
+        val factory = FakeWebSocketFactory()
+        val client = liveClient(factory = factory, scope = backgroundScope)
+
+        client.start("driver-1", config)
+
+        assertEquals("https://bootstrap-origin.test", factory.origins.single())
+    }
+
     @Test
     fun reconnectsWithBackoffAfterSocketFailure() = runTest {
         val factory = FakeWebSocketFactory()
@@ -81,6 +99,23 @@ class DriverLiveSyncClientTest {
         assertEquals(2, factory.sockets.size)
     }
 
+    @Test
+    fun backgroundClosesSocketAndForegroundReconnects() = runTest {
+        val factory = FakeWebSocketFactory()
+        val client = liveClient(factory = factory, scope = backgroundScope)
+
+        client.start("driver-1", config)
+        client.setForeground(false)
+
+        assertTrue(factory.sockets.single().closed)
+        assertEquals(LiveSyncConnectionState.Stopped, client.connectionState.value)
+
+        client.setForeground(true)
+        advanceUntilIdle()
+
+        assertEquals(2, factory.sockets.size)
+    }
+
     @Test
     fun retriesWhenPrivateChannelSubscriptionAuthFails() = runTest {
         val gateway = FakeLiveSyncGateway(authFailure = RuntimeException("offline"))
@@ -107,6 +142,21 @@ class DriverLiveSyncClientTest {
         assertTrue(factory.sockets.single().sent.any { it.contains("pusher:pong") })
     }
 
+    @Test
+    fun subscribesToOwnUpdatesAndSharedLeaveCalendarUpdates() = runTest {
+        val factory = FakeWebSocketFactory()
+        val client = liveClient(factory = factory, scope = this)
+
+        client.start("driver-1", config)
+        factory.sockets.single().message(connectionEstablished("socket-1"))
+        runCurrent()
+
+        val sent = factory.sockets.single().sent
+        assertTrue(sent.any { it.contains("private-driver-mobile.driver-1") })
+        assertTrue(sent.any { it.contains("private-driver-mobile.0") })
+        client.stop()
+    }
+
     @Test
     fun closesAndReconnectsWhenConnectedSocketStopsReceivingMessages() = runTest {
         val factory = FakeWebSocketFactory()
@@ -172,10 +222,12 @@ class DriverLiveSyncClientTest {
 
     private class FakeWebSocketFactory : LiveWebSocketFactory {
         val sockets = mutableListOf<FakeWebSocket>()
+        val origins = mutableListOf<String?>()
 
-        override fun newWebSocket(url: String, listener: WebSocketListener): WebSocket {
+        override fun newWebSocket(url: String, origin: String?, listener: WebSocketListener): WebSocket {
             val socket = FakeWebSocket(listener)
             sockets += socket
+            origins += origin
             return socket
         }
     }

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

@@ -0,0 +1,24 @@
+package pl.firmatpp.kierowca.sync
+
+import org.junit.After
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class DriverRuntimeSyncStateTest {
+    @After
+    fun reset() {
+        DriverRuntimeSyncState.foreground = false
+        DriverRuntimeSyncState.realtimeConnected = false
+    }
+
+    @Test
+    fun websocketSuppressesDuplicateFcmSyncOnlyWhenForegroundAndConnected() {
+        DriverRuntimeSyncState.foreground = true
+        DriverRuntimeSyncState.realtimeConnected = true
+        assertTrue(DriverRuntimeSyncState.websocketOwnsForegroundHints())
+
+        DriverRuntimeSyncState.realtimeConnected = false
+        assertFalse(DriverRuntimeSyncState.websocketOwnsForegroundHints())
+    }
+}

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

@@ -5,6 +5,8 @@ import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Test
+import pl.firmatpp.kierowca.data.model.DriverLeaveCalendarDriverDto
+import pl.firmatpp.kierowca.data.model.DriverLeaveCalendarEntryDto
 
 class DriverLeaveRequestUiRulesTest {
     @Test
@@ -48,4 +50,59 @@ class DriverLeaveRequestUiRulesTest {
         assertFalse(DriverLeaveRequestUiRules.canCancel(status = "approved", dateFrom = yesterday))
         assertFalse(DriverLeaveRequestUiRules.canCancel(status = "rejected", dateFrom = tomorrow))
     }
+
+    @Test
+    fun findsCalendarEntriesThatOverlapSelectedDate() {
+        val entries = listOf(
+            calendarEntry(id = "week", dateFrom = "2026-08-03", dateTo = "2026-08-09"),
+            calendarEntry(id = "single-day", dateFrom = "2026-08-05", dateTo = "2026-08-05"),
+            calendarEntry(id = "outside", dateFrom = "2026-08-10", dateTo = "2026-08-12"),
+        )
+
+        val matching = DriverLeaveRequestUiRules.calendarEntriesForDate(entries, LocalDate.parse("2026-08-05"))
+
+        assertEquals(listOf("week", "single-day"), matching.map { it.id })
+    }
+
+    @Test
+    fun findsCalendarEntriesThatOverlapSelectedRange() {
+        val entries = listOf(
+            calendarEntry(id = "starts-before", dateFrom = "2026-08-01", dateTo = "2026-08-04"),
+            calendarEntry(id = "inside", dateFrom = "2026-08-06", dateTo = "2026-08-07"),
+            calendarEntry(id = "ends-after", dateFrom = "2026-08-09", dateTo = "2026-08-12"),
+            calendarEntry(id = "before", dateFrom = "2026-07-20", dateTo = "2026-07-22"),
+            calendarEntry(id = "after", dateFrom = "2026-08-13", dateTo = "2026-08-14"),
+        )
+
+        val matching = DriverLeaveRequestUiRules.calendarEntriesForRange(
+            entries = entries,
+            dateFrom = "2026-08-03",
+            dateTo = "2026-08-10",
+        )
+
+        assertEquals(listOf("starts-before", "inside", "ends-after"), matching.map { it.id })
+    }
+
+    @Test
+    fun normalizesPhoneNumberIntoDialerUri() {
+        assertEquals("tel:+48600700800", DriverLeaveRequestUiRules.phoneDialUri("+48 600 700 800"))
+        assertEquals("tel:+48600700800", DriverLeaveRequestUiRules.phoneDialUri("0048 600 700 800"))
+        assertEquals(null, DriverLeaveRequestUiRules.phoneDialUri(null))
+        assertEquals(null, DriverLeaveRequestUiRules.phoneDialUri(" "))
+    }
+
+    private fun calendarEntry(id: String, dateFrom: String, dateTo: String): DriverLeaveCalendarEntryDto =
+        DriverLeaveCalendarEntryDto(
+            id = id,
+            dateFrom = dateFrom,
+            dateTo = dateTo,
+            type = "URLOP",
+            typeLabel = "Urlop",
+            status = "approved",
+            driver = DriverLeaveCalendarDriverDto(
+                id = "driver-$id",
+                displayName = "Kierowca $id",
+                phoneNumber = "+48 600 700 800",
+            ),
+        )
 }

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

@@ -0,0 +1,194 @@
+package pl.firmatpp.kierowca.ui
+
+import com.google.gson.Gson
+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.model.RoutePhotoDto
+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 routeProjectionNormalizesNullPhotosFromCachedJsonBeforeCopy() {
+        val route = Gson().fromJson(
+            """
+            {
+              "id": "1",
+              "startsAt": "",
+              "originName": "Baza",
+              "destinationName": "Instalacja",
+              "contractorName": "TPP",
+              "contractName": "Kontrakt",
+              "contractCode": "TPP-1",
+              "relationLabel": "Baza -> Instalacja",
+              "status": "ZAPLANOWANA",
+              "distanceKm": 1.0,
+              "notes": null,
+              "truck": null,
+              "photos": null
+            }
+            """.trimIndent(),
+            DriverRouteDto::class.java,
+        )
+
+        val projection = projectDriverRoute(
+            route = route,
+            actions = listOf(action(RouteActionType.Start, RouteActionStatus.Confirmed, weight = 12.5)),
+        )
+
+        assertEquals("W TRAKCIE", projection.route.status)
+        assertEquals(emptyList<RoutePhotoDto>(), projection.route.photos)
+    }
+
+    @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[3].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[1].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",
+            routeDate = "2026-06-30",
+            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")
@@ -35,6 +39,32 @@ class DriverUiRulesTest {
         assertFalse(canCompleteRouteFromDriverApp(route(status = "ZAPLANOWANA"), "2026-06-29", today))
     }
 
+    @Test
+    fun multiDayRouteCanLoadTodayButCanUnloadOnlyOnItsUnloadingDate() {
+        val route = route(
+            status = "ZAPLANOWANA",
+            routeDate = "2026-06-29",
+            unloadingDate = "2026-06-30",
+        )
+
+        assertTrue(canStartRouteFromDriverApp(route, "2026-06-30", today))
+        assertEquals("Załaduj", routeLifecyclePrimaryAction(route, "2026-06-30", today)?.label)
+        assertEquals("Dziś: rozładunek. Załadunek możesz potwierdzić dzisiaj.", routeTodayInstruction(route, "2026-06-30", today))
+
+        val activeRoute = route.copy(status = "W TRAKCIE")
+        assertTrue(canFinishRouteFromDriverApp(activeRoute, "2026-06-30", today))
+        assertEquals("Rozładuj", routeLifecyclePrimaryAction(activeRoute, "2026-06-30", today)?.label)
+        assertFalse(canFinishRouteFromDriverApp(activeRoute, "2026-06-29", LocalDate.parse("2026-06-29")))
+    }
+
+    @Test
+    fun routeScheduleShowsBothDispatcherDates() {
+        val route = route(routeDate = "2026-06-30", unloadingDate = "2026-07-02")
+
+        assertEquals("Załadunek: 30.06 · Rozładunek: 02.07", routeScheduleSummary(route))
+        assertEquals("Załadunek: 30.06 · Rozładunek: ten sam dzień", routeScheduleSummary(route.copy(unloadingDate = null)))
+    }
+
     @Test
     fun showsLiveRouteDayUpdateOnlyForViewedDate() {
         assertTrue(shouldShowRouteDayLiveUpdate(viewedDate = "2026-03-12", hintDate = "2026-03-12"))
@@ -52,6 +82,39 @@ class DriverUiRulesTest {
         assertEquals("—", routeDateChipLabel("", today))
     }
 
+    @Test
+    fun buildsNavigationCandidatesFromGeofenceCoordinatesWithFallbacks() {
+        val candidates = navigationIntentCandidates(
+            latitude = 50.0619474,
+            longitude = 19.9368564,
+            label = "Brama główna",
+        )
+
+        assertEquals(3, candidates.size)
+        assertEquals("com.google.android.apps.maps", candidates[0].packageName)
+        assertEquals("google.navigation:q=50.0619474,19.9368564", candidates[0].uri)
+        assertEquals(null, candidates[1].packageName)
+        assertEquals(
+            "geo:0,0?q=50.0619474,19.9368564(Brama%20g%C5%82%C3%B3wna)",
+            candidates[1].uri,
+        )
+        assertEquals(
+            "https://www.google.com/maps/dir/?api=1&destination=50.0619474,19.9368564",
+            candidates[2].uri,
+        )
+    }
+
+    @Test
+    fun doesNotBuildNavigationCandidatesForMissingOrInvalidCoordinates() {
+        assertFalse(hasValidNavigationCoordinates(null, 19.9368564))
+        assertFalse(hasValidNavigationCoordinates(50.0619474, null))
+        assertFalse(hasValidNavigationCoordinates(Double.NaN, 19.9368564))
+        assertFalse(hasValidNavigationCoordinates(91.0, 19.9368564))
+        assertFalse(hasValidNavigationCoordinates(50.0619474, 181.0))
+        assertTrue(hasValidNavigationCoordinates(50.0619474, 19.9368564))
+        assertTrue(navigationIntentCandidates(null, null, "Cel").isEmpty())
+    }
+
     @Test
     fun calculatesPhotoGridRowsForTwoColumnInlineGallery() {
         assertEquals(0, inlinePhotoGridRows(0))
@@ -61,6 +124,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))
@@ -151,8 +238,9 @@ class DriverUiRulesTest {
     }
 
     @Test
-    fun allowsRetryActionOnlyForRetryableFailedUploads() {
+    fun allowsRetryForRetryableAndLegacyCancelledUploads() {
         assertTrue(canRetryPhotoUpload("FAILED_RETRYABLE"))
+        assertTrue(canRetryPhotoUpload("FAILED_PERMANENT", "Typ: błąd aplikacji\nKomunikat: Job was cancelled"))
         assertFalse(canRetryPhotoUpload("PENDING"))
         assertFalse(canRetryPhotoUpload("UPLOADING"))
         assertFalse(canRetryPhotoUpload("VERIFYING"))
@@ -161,6 +249,37 @@ class DriverUiRulesTest {
         assertFalse(canRetryPhotoUpload("CANCELLED"))
     }
 
+    @Test
+    fun permanentUploadDoesNotSatisfyRouteStageAndCanBeDiscarded() {
+        val failed = upload(status = "FAILED_PERMANENT")
+        val pending = upload(status = "PENDING").copy(clientRequestId = "pending-upload")
+
+        assertEquals(listOf("pending-upload"), routeStageUsableUploads(listOf(failed, pending)).map { it.clientRequestId })
+        assertFalse(photoUploadCanSatisfyStage("FAILED_PERMANENT"))
+        assertTrue(canDiscardLocalPhotoUpload("FAILED_PERMANENT", null))
+        assertFalse(canDiscardLocalPhotoUpload("CONFIRMED", "42"))
+    }
+
+    @Test
+    fun serverRefreshLeavesObsoleteRouteStageScreen() {
+        assertEquals(
+            DriverScreen.Detail,
+            routeScreenAfterServerRefresh(DriverScreen.StartRoute, route(status = "W TRAKCIE")),
+        )
+        assertEquals(
+            DriverScreen.Detail,
+            routeScreenAfterServerRefresh(DriverScreen.LoadingWeight, route(status = "ZAKOŃCZONA")),
+        )
+        assertEquals(
+            DriverScreen.Detail,
+            routeScreenAfterServerRefresh(DriverScreen.FinishRoute, route(status = "ZAKOŃCZONA")),
+        )
+        assertEquals(
+            DriverScreen.StartRoute,
+            routeScreenAfterServerRefresh(DriverScreen.StartRoute, route(status = "ZAPLANOWANA")),
+        )
+    }
+
     @Test
     fun showsFailureDetailsOnlyForFailedUploadsWithErrorMessage() {
         assertTrue(canShowPhotoUploadFailureDetails("FAILED_RETRYABLE", "Typ: błąd serwera"))
@@ -207,6 +326,32 @@ class DriverUiRulesTest {
         )
     }
 
+    @Test
+    fun healthyOnlineStateDoesNotShowOfflineBanner() {
+        assertEquals(
+            null,
+            connectionStatusBannerMessage(
+                isOnline = true,
+                isStale = false,
+                serverConnectionState = ServerConnectionState.Reachable,
+                showRealtimeReconnecting = false,
+                syncLabel = "12:30",
+            ),
+        )
+    }
+
+    @Test
+    fun serverFailureAndRealtimeReconnectAreNotCalledOffline() {
+        assertEquals(
+            "Internet działa, ale serwer jest chwilowo niedostępny. Pokazujemy dane z 12:30.",
+            connectionStatusBannerMessage(true, true, ServerConnectionState.Degraded, false, "12:30"),
+        )
+        assertEquals(
+            "Ponowne łączenie. Dane są uzgadniane z serwerem.",
+            connectionStatusBannerMessage(true, false, ServerConnectionState.Reachable, true, "12:30"),
+        )
+    }
+
     @Test
     fun explainsStaleCachedDataWhenOnline() {
         assertEquals(
@@ -222,9 +367,288 @@ 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))
+        assertTrue(canSubmitRouteStageForm(weightText = "23400", serverPhotoCount = 1, localUploadCount = 0))
+        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 parsesRouteWeightsEnteredInTonsOrKilograms() {
+        assertEquals(23.4, parseRouteWeightTons("23,4") ?: 0.0, 0.0)
+        assertEquals(23.4, parseRouteWeightTons("23400") ?: 0.0, 0.0)
+        assertEquals(23.401, parseRouteWeightTons("23400,5") ?: 0.0, 0.0)
+        assertEquals("Wpisano kilogramy — zapiszemy 23,400 t.", routeWeightInputHelpText("23400"))
+    }
+
+    @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("Zdjęcia załadunku", "Tonaż załadunku", "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(RouteFlowStepState.Todo, steps[3].state)
+        assertEquals("Załaduj", action?.label)
+        assertEquals(RouteLifecycleAction.Start, action?.action)
+    }
+
+    @Test
+    fun driverFlowIgnoresOperationalStatusFromGeofence() {
+        val route = route(
+            status = "ZAKOŃCZONA",
+            driverStatus = "ZAPLANOWANA",
+            operationalStatus = "ZAKOŃCZONA",
+        )
+
+        val steps = routeFlowSteps(route, emptyList())
+
+        assertTrue(canStartRouteFromDriverApp(route, "2026-06-30", today))
+        assertEquals(RouteFlowStepState.Todo, steps[0].state)
+        assertEquals(RouteFlowStepState.Todo, steps[1].state)
+        assertEquals(RouteFlowStepState.Todo, steps[2].state)
+        assertEquals(DriverScreen.StartRoute, routeScreenAfterServerRefresh(DriverScreen.StartRoute, route))
+    }
+
+    @Test
+    fun plannedRouteWithLoadingPhotoShowsOnlyPhotoStepComplete() {
+        val route = route(status = "ZAPLANOWANA", photos = listOf(photo("loading-1", stage = "loading")))
+
+        val steps = routeFlowSteps(route, emptyList())
+
+        assertEquals(RouteFlowStepState.ServerSaved, steps[0].state)
+        assertEquals("zapisane na serwerze", steps[0].stateLabel)
+        assertEquals(RouteFlowStepState.Todo, steps[1].state)
+        assertEquals(RouteFlowStepState.Todo, steps[2].state)
+        assertEquals(RouteFlowStepState.Todo, steps[3].state)
+    }
+
+    @Test
+    fun freshInstallLabelsBackendLoadingDocumentationAsServerData() {
+        val route = route(
+            status = "ZAPLANOWANA",
+            loadingWeight = 23.76,
+            photos = listOf(photo("loading-1", stage = "loading")),
+        )
+
+        val steps = routeFlowSteps(route, emptyList())
+
+        assertEquals(RouteFlowStepState.ServerSaved, steps[0].state)
+        assertEquals("zapisane na serwerze", steps[0].stateLabel)
+        assertEquals(RouteFlowStepState.ServerSaved, steps[1].state)
+        assertEquals("zapisane na serwerze", steps[1].stateLabel)
+        assertEquals(RouteFlowStepState.Todo, steps[2].state)
+        assertEquals(RouteFlowStepState.Todo, steps[3].state)
+    }
+
+    @Test
+    fun serverWeightDoesNotMarkMissingLoadingPhotoAsComplete() {
+        val steps = routeFlowSteps(route(status = "ZAPLANOWANA", loadingWeight = 23.76), emptyList())
+
+        assertEquals(RouteFlowStepState.Todo, steps[0].state)
+        assertEquals(RouteFlowStepState.ServerSaved, steps[1].state)
+    }
+
+    @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.Confirmed, steps[1].state)
+        assertEquals(RouteFlowStepState.InProgress, steps[2].state)
+        assertEquals("w trakcie", steps[2].stateLabel)
+        assertEquals(RouteFlowStepState.Todo, steps[3].state)
+        assertEquals("Rozładuj", 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(RouteFlowStepState.Confirmed, steps[3].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[1].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[3].state)
+        assertEquals("Kurs wymaga obsługi. Dane wpisane w telefonie zostały zachowane.", callout?.text)
+        assertTrue(callout?.isConflict ?: false)
+        assertFalse(callout?.canCorrect ?: true)
+    }
+
+    @Test
+    fun permanentlyRejectedRouteActionOffersDataCorrection() {
+        val callout = routeSyncCallout(
+            listOf(action(RouteActionType.Start, RouteActionStatus.FailedPermanent, "Brakuje wymaganych danych.")),
+        )
+
+        assertTrue(callout?.canCorrect ?: false)
+    }
+
+    @Test
+    fun routeStageSubmitBlockerExplainsMissingRequirements() {
+        assertEquals("Podaj tonaż.", routeStageSubmitBlocker("", serverPhotoCount = 1, localUploadCount = 0))
+        assertEquals("Tonaż musi być większy 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))
+    }
+
+    @Test
+    fun loadingPhotosStepRequiresAtLeastOneLoadingPhotoBeforeWeightStep() {
+        assertEquals(
+            "Dodaj co najmniej jedno zdjęcie załadunku.",
+            loadingPhotosSubmitBlocker(serverPhotoCount = 0, localUploadCount = 0),
+        )
+        assertEquals(null, loadingPhotosSubmitBlocker(serverPhotoCount = 1, localUploadCount = 0))
+        assertEquals(null, loadingPhotosSubmitBlocker(serverPhotoCount = 0, localUploadCount = 1))
+    }
+
+    @Test
+    fun loadingWeightStepRequiresPositiveWeightAndPreviousLoadingPhoto() {
+        assertEquals("Podaj tonaż.", loadingWeightSubmitBlocker("", serverPhotoCount = 1, localUploadCount = 0))
+        assertEquals("Podaj poprawny tonaż.", loadingWeightSubmitBlocker("abc", serverPhotoCount = 1, localUploadCount = 0))
+        assertEquals("Tonaż musi być większy od zera.", loadingWeightSubmitBlocker("0", serverPhotoCount = 1, localUploadCount = 0))
+        assertEquals(
+            "Dodaj co najmniej jedno zdjęcie załadunku.",
+            loadingWeightSubmitBlocker("12,5", serverPhotoCount = 0, localUploadCount = 0),
+        )
+        assertEquals(null, loadingWeightSubmitBlocker("12,5", serverPhotoCount = 0, localUploadCount = 1))
+    }
+
+    @Test
+    fun optionalStageInputsAreVisibleButDoNotBlockConfirmation() {
+        assertEquals(
+            null,
+            routeStageSubmitBlocker(
+                weightText = "",
+                serverPhotoCount = 0,
+                localUploadCount = 0,
+                weightRequirement = RouteStageRequirement.Optional,
+                photoRequirement = RouteStageRequirement.Optional,
+            ),
+        )
+        assertEquals(
+            "Podaj poprawny tonaż.",
+            routeStageSubmitBlocker(
+                weightText = "abc",
+                serverPhotoCount = 0,
+                localUploadCount = 0,
+                weightRequirement = RouteStageRequirement.Optional,
+                photoRequirement = RouteStageRequirement.Optional,
+            ),
+        )
+    }
+
+    @Test
+    fun disabledStageInputsAreHiddenAndDoNotBlockConfirmation() {
+        assertEquals(RouteStageRequirement.Required, normalizeRouteStageRequirement(null))
+        assertEquals(RouteStageRequirement.Required, normalizeRouteStageRequirement("unknown"))
+        assertFalse(routeStageRequirementIsVisible(RouteStageRequirement.Disabled))
+        assertTrue(routeStageRequirementIsVisible(RouteStageRequirement.Optional))
+        assertTrue(routeStageRequirementIsRequired(RouteStageRequirement.Required))
+        assertEquals(
+            null,
+            routeStageSubmitBlocker(
+                weightText = "invalid value is ignored",
+                serverPhotoCount = 0,
+                localUploadCount = 0,
+                weightRequirement = RouteStageRequirement.Disabled,
+                photoRequirement = RouteStageRequirement.Disabled,
+            ),
+        )
+    }
+
+    @Test
+    fun disabledLoadingStepsAreRemovedFromRouteFlow() {
+        val steps = routeFlowSteps(
+            route(status = "ZAPLANOWANA"),
+            emptyList(),
+            loadingPhotoRequirement = RouteStageRequirement.Disabled,
+            loadingWeightRequirement = RouteStageRequirement.Disabled,
+        )
+
+        assertEquals(listOf("W trasie", "Rozładunek"), steps.map { it.title })
+    }
+
+    private fun route(
+        status: String = "ZAPLANOWANA",
+        driverStatus: String? = null,
+        operationalStatus: String? = null,
+        loadingWeight: Double? = null,
+        unloadingWeight: Double? = null,
+        photos: List<RoutePhotoDto> = emptyList(),
+        routeDate: String? = "2026-06-30",
+        unloadingDate: String? = null,
+    ): DriverRouteDto =
         DriverRouteDto(
             id = "1",
+            routeDate = routeDate,
+            unloadingDate = unloadingDate,
             startsAt = "",
             originName = "Baza",
             destinationName = "Instalacja",
@@ -233,9 +657,26 @@ class DriverUiRulesTest {
             contractCode = "TPP-1",
             relationLabel = "Baza -> Instalacja",
             status = status,
+            driverStatus = driverStatus,
+            operationalStatus = operationalStatus,
+            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 =
@@ -255,6 +696,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

@@ -1,9 +1,15 @@
 package pl.firmatpp.kierowca.ui
 
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Test
+import java.io.IOException
 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 {
@@ -22,6 +28,21 @@ class DriverUiStateTest {
         assertEquals(AppThemeMode.Material3, state.themeMode)
     }
 
+    @Test
+    fun networkTimeoutDoesNotChangeValidatedNetworkState() {
+        val state = DriverUiState(
+            isOnline = true,
+            serverConnectionState = ServerConnectionState.Reachable,
+            lastServerSyncAtEpochMillis = 123L,
+        )
+
+        val failed = state.withApiError(IOException("timeout"))
+
+        assertTrue(failed.isOnline)
+        assertTrue(failed.isStale)
+        assertEquals(ServerConnectionState.Degraded, failed.serverConnectionState)
+    }
+
     @Test
     fun refreshingLeaveRequestsKeepsDetailScreenOpenAndUpdatesSelectedRequest() {
         val state = DriverUiState(
@@ -51,12 +72,145 @@ class DriverUiStateTest {
         assertEquals(1, refreshed.leaveRequests.size)
     }
 
-    private fun leaveRequest(id: String, status: String): DriverLeaveRequestDto =
+    @Test
+    fun staleLeaveRequestRefreshDoesNotOverwriteNewerMutationResult() {
+        val state = DriverUiState(
+            screen = DriverScreen.LeaveRequestDetail,
+            leaveRequests = listOf(leaveRequest(id = "leave-1", status = "cancel_requested", version = 3)),
+            selectedLeaveRequest = leaveRequest(id = "leave-1", status = "cancel_requested", version = 3),
+        )
+
+        val refreshed = state.withLoadedLeaveRequests(
+            requests = listOf(leaveRequest(id = "leave-1", status = "approved", version = 2)),
+            navigateToList = false,
+        )
+
+        assertEquals("cancel_requested", refreshed.leaveRequests.single().status)
+        assertEquals(3L, refreshed.selectedLeaveRequest?.version)
+    }
+
+    @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)
+    }
+
+    @Test
+    fun displayRoutesMovesCompletedRoutesBelowActiveDispatcherOrder() {
+        val state = DriverUiState(
+            routes = listOf(
+                route(id = "completed", status = "ZAKOŃCZONA"),
+                route(id = "planned", status = "ZAPLANOWANA"),
+                route(id = "active", status = "W TRAKCIE"),
+            ),
+        )
+
+        assertEquals(listOf("planned", "active", "completed"), state.displayRoutes.map { it.id })
+    }
+
+    @Test
+    fun displayRoutesUsesTheSelectedDayOrderingForMultiDayRoutes() {
+        val state = DriverUiState(
+            selectedDate = "2026-07-02",
+            routes = listOf(
+                route(id = "span", status = "ZAPLANOWANA", ordering = 0, dayOrderings = mapOf("2026-07-02" to 2)),
+                route(id = "above-first", status = "ZAPLANOWANA", ordering = 0, dayOrderings = mapOf("2026-07-02" to 0)),
+                route(id = "above-second", status = "ZAPLANOWANA", ordering = 1, dayOrderings = mapOf("2026-07-02" to 1)),
+            ),
+        )
+
+        assertEquals(listOf("above-first", "above-second", "span"), state.displayRoutes.map { it.id })
+    }
+
+    @Test
+    fun freshGpsPointsDoNotShowSynchronizationBannerWhenOnlineIsHealthy() {
+        val state = DriverUiState(
+            isOnline = true,
+            serverConnectionState = ServerConnectionState.Reachable,
+            pendingGpsPoints = 48,
+            oldestPendingGpsAtEpochMillis = System.currentTimeMillis() - 30_000L,
+        )
+
+        assertEquals(0, state.pendingOperationalItems)
+        assertFalse(state.operationalQueueNeedsAttention)
+    }
+
+    @Test
+    fun staleGpsBacklogRequiresAttentionWhenOnline() {
+        val state = DriverUiState(
+            isOnline = true,
+            serverConnectionState = ServerConnectionState.Reachable,
+            pendingGpsPoints = 48,
+            oldestPendingGpsAtEpochMillis = System.currentTimeMillis() - 3 * 60_000L,
+        )
+
+        assertEquals(48, state.pendingOperationalItems)
+        assertTrue(state.operationalQueueNeedsAttention)
+    }
+
+    @Test
+    fun offlineGpsPointsAreShownAsSavedLocallyNotAsFailure() {
+        val state = DriverUiState(
+            isOnline = false,
+            pendingGpsPoints = 48,
+            oldestPendingGpsAtEpochMillis = System.currentTimeMillis() - 3 * 60_000L,
+        )
+
+        assertEquals(48, state.pendingOperationalItems)
+        assertFalse(state.operationalQueueNeedsAttention)
+    }
+
+    private fun leaveRequest(id: String, status: String, version: Long = 1): DriverLeaveRequestDto =
         DriverLeaveRequestDto(
             id = id,
             dateFrom = "2026-07-10",
             dateTo = "2026-07-12",
             type = "URLOP",
             status = status,
+            version = version,
+        )
+
+    private fun route(
+        id: String = "1",
+        status: String,
+        ordering: Int? = null,
+        dayOrderings: Map<String, Int> = emptyMap(),
+    ): DriverRouteDto =
+        DriverRouteDto(
+            id = id,
+            routeDate = "2026-06-30",
+            ordering = ordering,
+            dayOrderings = dayOrderings,
+            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,
         )
 }

scripts/release-android.sh

@@ -0,0 +1,363 @@
+#!/usr/bin/env bash
+
+set -Eeuo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+VERSION_FILE="$ROOT_DIR/app/build.gradle.kts"
+REMOTE_NAME="${GIT_REMOTE:-origin}"
+NOTES_FILE=""
+SKIP_TESTS=0
+REUSE_CURRENT=0
+VERSION_FILE_CHANGED=0
+VERSION_COMMITTED=0
+VERSION_BACKUP=""
+RELEASE_SUCCEEDED=0
+
+usage() {
+    cat <<'EOF'
+Użycie: scripts/release-android.sh [opcje]
+
+Buduje i publikuje kolejną wersję aplikacji kierowcy:
+  - automatycznie zwiększa versionCode o 1 i patch versionName o 1,
+  - uruchamia testy jednostkowe,
+  - buduje podpisany APK dla Gitea Release,
+  - buduje podpisany AAB dla Google Play Console,
+  - zapisuje zmianę wersji w commicie, tworzy tag i wykonuje push,
+  - tworzy lub aktualizuje Gitea Release i wysyła APK oraz SHA256SUMS.
+
+Opcje:
+  --notes-file PLIK   Treść release notes z podanego pliku.
+  --skip-tests        Pomiń testDebugUnitTest.
+  --reuse-current     Nie zwiększaj wersji. Wznów publikację wersji zapisanej
+                      obecnie w app/build.gradle.kts.
+  -h, --help          Pokaż pomoc.
+
+Zmienne środowiskowe:
+  GITEA_TOKEN         Token API Gitea. Jeśli go brak, używany jest git credential helper.
+  GITEA_BASE_URL      Nadpisuje adres Gitea, np. https://gitea.example.com.
+  GITEA_REPOSITORY    Nadpisuje owner/repository.
+  GIT_REMOTE          Remote Git, domyślnie origin.
+
+Wersja początkowa jest zawsze odczytywana z app/build.gradle.kts.
+Google Play Console otrzymuje plik AAB, ponieważ jest to właściwy format publikacyjny.
+EOF
+}
+
+while (($# > 0)); do
+    case "$1" in
+        --notes-file)
+            NOTES_FILE="${2:-}"
+            [[ -n "$NOTES_FILE" ]] || { echo "Brak wartości dla --notes-file." >&2; exit 2; }
+            shift 2
+            ;;
+        --skip-tests)
+            SKIP_TESTS=1
+            shift
+            ;;
+        --reuse-current)
+            REUSE_CURRENT=1
+            shift
+            ;;
+        -h|--help)
+            usage
+            exit 0
+            ;;
+        *)
+            echo "Nieznana opcja: $1" >&2
+            usage >&2
+            exit 2
+            ;;
+    esac
+done
+
+cd "$ROOT_DIR"
+
+for command in git curl jq perl sha256sum jarsigner; do
+    command -v "$command" >/dev/null 2>&1 || {
+        echo "Brak wymaganego polecenia: $command" >&2
+        exit 1
+    }
+done
+
+[[ -x ./gradlew ]] || { echo "Brak wykonywalnego ./gradlew." >&2; exit 1; }
+[[ -f keystore.properties ]] || { echo "Brak keystore.properties wymaganego do podpisania release." >&2; exit 1; }
+[[ -f "$VERSION_FILE" ]] || { echo "Brak $VERSION_FILE." >&2; exit 1; }
+
+branch="$(git branch --show-current)"
+[[ -n "$branch" ]] || { echo "Release nie może być wykonany z detached HEAD." >&2; exit 1; }
+
+if ! git diff --quiet || ! git diff --cached --quiet; then
+    echo "Repozytorium ma niezapisane zmiany śledzonych plików. Najpierw wykonaj commit." >&2
+    exit 1
+fi
+
+relevant_untracked="$(git status --porcelain --untracked-files=all -- app gradle scripts build.gradle.kts settings.gradle.kts gradle.properties | awk '$1 == "??" { print }')"
+if [[ -n "$relevant_untracked" ]]; then
+    echo "Repozytorium ma nieśledzone pliki źródłowe. Najpierw zdecyduj, czy mają wejść do release:" >&2
+    printf '%s\n' "$relevant_untracked" >&2
+    exit 1
+fi
+
+git fetch --tags "$REMOTE_NAME"
+
+remote_url="$(git remote get-url "$REMOTE_NAME")"
+sanitized_remote="$(printf '%s' "$remote_url" | sed -E 's#^(https?://)[^/@]+@#\1#')"
+if [[ "$sanitized_remote" =~ ^(https?)://([^/]+)/(.+)$ ]]; then
+    detected_protocol="${BASH_REMATCH[1]}"
+    detected_host="${BASH_REMATCH[2]}"
+    detected_repository="${BASH_REMATCH[3]%.git}"
+else
+    detected_protocol="https"
+    detected_host=""
+    detected_repository=""
+fi
+
+gitea_base_url="${GITEA_BASE_URL:-${detected_protocol}://${detected_host}}"
+gitea_repository="${GITEA_REPOSITORY:-$detected_repository}"
+gitea_base_url="${gitea_base_url%/}"
+[[ "$gitea_base_url" =~ ^https?://[^/]+$ ]] || { echo "Ustaw poprawne GITEA_BASE_URL." >&2; exit 1; }
+[[ "$gitea_repository" =~ ^[^/]+/[^/]+$ ]] || { echo "Ustaw poprawne GITEA_REPOSITORY=owner/repository." >&2; exit 1; }
+
+auth_args=()
+if [[ -n "${GITEA_TOKEN:-}" ]]; then
+    auth_args=(-H "Authorization: token $GITEA_TOKEN")
+else
+    credential="$(printf 'protocol=%s\nhost=%s\n\n' "$detected_protocol" "$detected_host" | git credential fill)"
+    gitea_username="$(printf '%s\n' "$credential" | sed -n 's/^username=//p')"
+    gitea_password="$(printf '%s\n' "$credential" | sed -n 's/^password=//p')"
+    [[ -n "$gitea_username" && -n "$gitea_password" ]] || {
+        echo "Brak danych Gitea. Ustaw GITEA_TOKEN albo skonfiguruj git credential helper." >&2
+        exit 1
+    }
+    auth_args=(-u "$gitea_username:$gitea_password")
+fi
+
+api_base="$gitea_base_url/api/v1/repos/$gitea_repository"
+preflight_status="$(curl -sS "${auth_args[@]}" -o /dev/null -w '%{http_code}' "$api_base")"
+[[ "$preflight_status" == "200" ]] || {
+    echo "Brak dostępu do repozytorium Gitea $gitea_repository (HTTP $preflight_status)." >&2
+    exit 1
+}
+
+read_version() {
+    local code name
+    code="$(sed -nE 's/^[[:space:]]*versionCode = ([0-9]+).*$/\1/p' "$VERSION_FILE" | sed -n '1p')"
+    name="$(sed -nE 's/^[[:space:]]*versionName = "([^"]+)".*$/\1/p' "$VERSION_FILE" | sed -n '1p')"
+    [[ "$code" =~ ^[0-9]+$ ]] || { echo "Nie można odczytać versionCode." >&2; return 1; }
+    [[ "$name" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]] || { echo "versionName musi mieć format major.minor.patch." >&2; return 1; }
+    printf '%s %s\n' "$code" "$name"
+}
+
+read -r current_code current_name < <(read_version)
+if ((REUSE_CURRENT == 1)); then
+    next_code="$current_code"
+    next_name="$current_name"
+else
+    IFS=. read -r version_major version_minor version_patch <<<"$current_name"
+    next_code=$((current_code + 1))
+    next_name="${version_major}.${version_minor}.$((version_patch + 1))"
+fi
+
+tag_name="v${next_name}-${next_code}"
+artifact_dir="$ROOT_DIR/release-artifacts/$tag_name"
+gitea_apk_name="TPP-Kierowca-${next_name}-${next_code}.apk"
+play_aab_name="TPP-Kierowca-${next_name}-${next_code}.aab"
+
+cleanup_on_exit() {
+    local exit_code=$?
+    if ((RELEASE_SUCCEEDED == 0 && VERSION_FILE_CHANGED == 1 && VERSION_COMMITTED == 0)) && [[ -n "$VERSION_BACKUP" && -f "$VERSION_BACKUP" ]]; then
+        cp "$VERSION_BACKUP" "$VERSION_FILE"
+        echo "Przywrócono poprzednią wersję w app/build.gradle.kts." >&2
+    fi
+    [[ -n "$VERSION_BACKUP" && -f "$VERSION_BACKUP" ]] && rm -f "$VERSION_BACKUP"
+    if ((RELEASE_SUCCEEDED == 0)); then
+        echo "Release nie został ukończony. Po usunięciu przyczyny użyj --reuse-current, jeśli commit wersji już powstał." >&2
+    fi
+    trap - EXIT INT TERM
+    exit "$exit_code"
+}
+trap cleanup_on_exit EXIT
+trap 'exit 130' INT
+trap 'exit 143' TERM
+
+if ((REUSE_CURRENT == 0)); then
+    if git show-ref --verify --quiet "refs/tags/$tag_name" || git ls-remote --exit-code --tags "$REMOTE_NAME" "refs/tags/$tag_name" >/dev/null 2>&1; then
+        echo "Tag $tag_name już istnieje. Użyj --reuse-current albo zwiększ wersję ręcznie." >&2
+        exit 1
+    fi
+
+    VERSION_BACKUP="$(mktemp)"
+    cp "$VERSION_FILE" "$VERSION_BACKUP"
+    perl -0pi -e "s/versionCode = \\d+/versionCode = $next_code/" "$VERSION_FILE"
+    perl -0pi -e "s/versionName = \"[^\"]+\"/versionName = \"$next_name\"/" "$VERSION_FILE"
+    VERSION_FILE_CHANGED=1
+
+    read -r written_code written_name < <(read_version)
+    [[ "$written_code" == "$next_code" && "$written_name" == "$next_name" ]] || {
+        echo "Nie udało się jednoznacznie zapisać nowej wersji." >&2
+        exit 1
+    }
+fi
+
+echo "Buduję TPP Kierowca $next_name ($next_code)..."
+gradle_tasks=(assembleRelease bundleRelease)
+if ((SKIP_TESTS == 0)); then
+    gradle_tasks=(testDebugUnitTest "${gradle_tasks[@]}")
+fi
+./gradlew "${gradle_tasks[@]}"
+
+apk_source="$(find app/build/outputs/apk/release -maxdepth 1 -type f -name '*.apk' -print -quit)"
+aab_source="$(find app/build/outputs/bundle/release -maxdepth 1 -type f -name '*.aab' -print -quit)"
+[[ -n "$apk_source" && -f "$apk_source" ]] || { echo "Nie znaleziono release APK." >&2; exit 1; }
+[[ -n "$aab_source" && -f "$aab_source" ]] || { echo "Nie znaleziono release AAB." >&2; exit 1; }
+
+sdk_dir="${ANDROID_HOME:-${ANDROID_SDK_ROOT:-}}"
+if [[ -z "$sdk_dir" && -f local.properties ]]; then
+    sdk_dir="$(sed -n 's/^sdk.dir=//p' local.properties | sed -n '1p')"
+fi
+apksigner="$(find "$sdk_dir/build-tools" -type f -name apksigner 2>/dev/null | sort -V | tail -n 1)"
+aapt="$(find "$sdk_dir/build-tools" -type f -name aapt 2>/dev/null | sort -V | tail -n 1)"
+[[ -x "$apksigner" && -x "$aapt" ]] || { echo "Nie znaleziono apksigner/aapt w Android SDK." >&2; exit 1; }
+"$apksigner" verify --verbose "$apk_source"
+apk_badging="$("$aapt" dump badging "$apk_source" | sed -n '1p')"
+[[ "$apk_badging" == *"versionCode='$next_code'"* && "$apk_badging" == *"versionName='$next_name'"* ]] || {
+    echo "APK ma inny numer wersji niż oczekiwany $next_name ($next_code)." >&2
+    exit 1
+}
+jarsigner -verify "$aab_source" >/dev/null
+
+rm -rf "$artifact_dir"
+mkdir -p "$artifact_dir/gitea" "$artifact_dir/google-play"
+cp "$apk_source" "$artifact_dir/gitea/$gitea_apk_name"
+cp "$aab_source" "$artifact_dir/google-play/$play_aab_name"
+(
+    cd "$artifact_dir"
+    sha256sum "gitea/$gitea_apk_name" "google-play/$play_aab_name" > SHA256SUMS.txt
+)
+
+if ((REUSE_CURRENT == 0)); then
+    git add "$VERSION_FILE"
+    git diff --cached --check
+    git commit -m "chore: release android driver $next_name ($next_code)"
+    VERSION_COMMITTED=1
+fi
+
+git push "$REMOTE_NAME" "$branch"
+if ! git show-ref --verify --quiet "refs/tags/$tag_name"; then
+    git tag -a "$tag_name" -m "TPP Kierowca $next_name ($next_code)"
+fi
+tag_commit="$(git rev-list -n 1 "$tag_name")"
+head_commit="$(git rev-parse HEAD)"
+[[ "$tag_commit" == "$head_commit" ]] || {
+    echo "Tag $tag_name nie wskazuje aktualnego commita ($head_commit)." >&2
+    exit 1
+}
+git push "$REMOTE_NAME" "$tag_name"
+
+if [[ -n "$NOTES_FILE" ]]; then
+    [[ -f "$NOTES_FILE" ]] || { echo "Nie istnieje plik release notes: $NOTES_FILE" >&2; exit 1; }
+    release_notes="$(<"$NOTES_FILE")"
+else
+    previous_tag="$(git tag --sort=-version:refname | grep -Fxv "$tag_name" | sed -n '1p' || true)"
+    if [[ -n "$previous_tag" ]]; then
+        changes="$(git log --format='- %s (%h)' "$previous_tag..HEAD")"
+    else
+        changes="$(git log -20 --format='- %s (%h)')"
+    fi
+    release_notes="TPP Kierowca $next_name ($next_code)
+
+Zmiany:
+${changes:-'- Wydanie techniczne.'}
+
+Artefakt Google Play Console (AAB) znajduje się lokalnie w:
+release-artifacts/$tag_name/google-play/$play_aab_name"
+fi
+
+release_response="$(mktemp)"
+release_status="$(curl -sS "${auth_args[@]}" -o "$release_response" -w '%{http_code}' "$api_base/releases/tags/$tag_name")"
+if [[ "$release_status" == "200" ]]; then
+    release_id="$(jq -r '.id' "$release_response")"
+elif [[ "$release_status" == "404" ]]; then
+    release_payload="$(jq -n \
+        --arg tag "$tag_name" \
+        --arg target "$branch" \
+        --arg name "TPP Kierowca $next_name ($next_code)" \
+        --arg body "$release_notes" \
+        '{tag_name:$tag,target_commitish:$target,name:$name,body:$body,draft:false,prerelease:false}')"
+    release_status="$(curl -sS "${auth_args[@]}" \
+        -H 'Content-Type: application/json' \
+        -o "$release_response" \
+        -w '%{http_code}' \
+        -X POST \
+        -d "$release_payload" \
+        "$api_base/releases")"
+    [[ "$release_status" == "201" ]] || {
+        echo "Nie udało się utworzyć Gitea Release (HTTP $release_status)." >&2
+        jq '{message,errors}' "$release_response" >&2 || true
+        exit 1
+    }
+    release_id="$(jq -r '.id' "$release_response")"
+else
+    echo "Nie udało się sprawdzić Gitea Release (HTTP $release_status)." >&2
+    exit 1
+fi
+
+upload_asset() {
+    local file_path="$1"
+    local asset_name="$2"
+    local mime_type="$3"
+    local assets_response existing_asset_id upload_response upload_status
+    assets_response="$(mktemp)"
+    curl -fsS "${auth_args[@]}" -o "$assets_response" "$api_base/releases/$release_id/assets"
+    existing_asset_id="$(jq -r --arg name "$asset_name" '.[] | select(.name == $name) | .id' "$assets_response" | sed -n '1p')"
+    if [[ -n "$existing_asset_id" ]]; then
+        curl -fsS "${auth_args[@]}" -X DELETE "$api_base/releases/$release_id/assets/$existing_asset_id" >/dev/null
+    fi
+    upload_response="$(mktemp)"
+    upload_status="$(curl -sS "${auth_args[@]}" \
+        -o "$upload_response" \
+        -w '%{http_code}' \
+        -X POST \
+        -F "attachment=@$file_path;type=$mime_type" \
+        "$api_base/releases/$release_id/assets?name=$asset_name")"
+    [[ "$upload_status" == "201" ]] || {
+        echo "Nie udało się wysłać $asset_name (HTTP $upload_status)." >&2
+        jq '{message,errors}' "$upload_response" >&2 || true
+        return 1
+    }
+}
+
+upload_asset "$artifact_dir/gitea/$gitea_apk_name" "$gitea_apk_name" "application/vnd.android.package-archive"
+upload_asset "$artifact_dir/SHA256SUMS.txt" "SHA256SUMS.txt" "text/plain"
+
+assets_response="$(mktemp)"
+curl -fsS "${auth_args[@]}" -o "$assets_response" "$api_base/releases/$release_id/assets"
+published_apk_url="$(jq -r --arg name "$gitea_apk_name" '.[] | select(.name == $name) | .browser_download_url' "$assets_response" | sed -n '1p')"
+[[ -n "$published_apk_url" && "$published_apk_url" != "null" ]] || {
+    echo "Nie znaleziono opublikowanego APK w Gitea Release." >&2
+    exit 1
+}
+downloaded_apk="$(mktemp)"
+curl -fsSL "${auth_args[@]}" -o "$downloaded_apk" "$published_apk_url"
+local_apk_hash="$(sha256sum "$artifact_dir/gitea/$gitea_apk_name" | awk '{print $1}')"
+published_apk_hash="$(sha256sum "$downloaded_apk" | awk '{print $1}')"
+[[ "$local_apk_hash" == "$published_apk_hash" ]] || {
+    echo "Checksum opublikowanego APK nie zgadza się z lokalnym plikiem." >&2
+    exit 1
+}
+
+release_url="$gitea_base_url/$gitea_repository/releases/tag/$tag_name"
+RELEASE_SUCCEEDED=1
+trap - EXIT INT TERM
+[[ -n "$VERSION_BACKUP" ]] && rm -f "$VERSION_BACKUP"
+
+cat <<EOF
+
+Release zakończony:
+  Wersja:       $next_name ($next_code)
+  Tag:          $tag_name
+  Gitea:        $release_url
+  APK:          $artifact_dir/gitea/$gitea_apk_name
+  Google Play:  $artifact_dir/google-play/$play_aab_name
+  Checksumy:    $artifact_dir/SHA256SUMS.txt
+EOF