Fix leave request detail refresh navigation

.gitignore

@@ -1,5 +1,9 @@
 .gradle/
 build/
 local.properties
+app/google-services.json
+app/google-services.json:Zone.Identifier
 */build/
 *.iml
+keystore.properties
+*.jks

app/build.gradle.kts

@@ -1,22 +1,65 @@
+import java.io.File
+import java.util.Properties
+
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.android)
     alias(libs.plugins.kotlin.compose)
+    alias(libs.plugins.ksp)
+}
+
+if (file("google-services.json").exists()) {
+    apply(plugin = "com.google.gms.google-services")
+    apply(plugin = "com.google.firebase.crashlytics")
+}
+
+val keystorePropertiesFile = rootProject.file("keystore.properties")
+val keystoreProperties = Properties().apply {
+    if (keystorePropertiesFile.exists()) {
+        keystorePropertiesFile.inputStream().use(::load)
+    }
 }
 
 android {
     namespace = "pl.firmatpp.kierowca"
     compileSdk = 35
 
+    fun configValue(name: String, default: String): String =
+        providers.gradleProperty(name)
+            .orElse(providers.environmentVariable(name))
+            .orElse(default)
+            .get()
+
     defaultConfig {
         applicationId = "pl.firmatpp.kierowca"
         minSdk = 26
         targetSdk = 35
-        versionCode = 8
+        versionCode = 44
-        versionName = "1.0.7"
+        versionName = "1.0.42"
+        setProperty("archivesBaseName", "pl.firmatpp.kierowca")
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
 
         buildConfigField("String", "API_BASE_URL", "\"https://api-intranet.firmatpp.pl/api/\"")
+        buildConfigField("String", "REVERB_APP_KEY", "\"${configValue("REVERB_APP_KEY", "")}\"")
+        buildConfigField("String", "REVERB_WS_BASE_URL", "\"${configValue("REVERB_WS_BASE_URL", "wss://api-intranet.firmatpp.pl/app/")}\"")
+    }
+
+    signingConfigs {
+        create("release") {
+            fun requiredSigningProperty(name: String): String =
+                keystoreProperties.getProperty(name)
+                    ?: throw GradleException("Missing '$name' in keystore.properties")
+
+            val configuredStoreFile = requiredSigningProperty("storeFile")
+            storeFile = if (File(configuredStoreFile).isAbsolute) {
+                file(configuredStoreFile)
+            } else {
+                rootProject.file(configuredStoreFile)
+            }
+            storePassword = requiredSigningProperty("storePassword")
+            keyAlias = requiredSigningProperty("keyAlias")
+            keyPassword = requiredSigningProperty("keyPassword")
+        }
     }
 
     buildTypes {
@@ -24,7 +67,11 @@ android {
             isMinifyEnabled = false
         }
         release {
+            signingConfig = signingConfigs.getByName("release")
             isMinifyEnabled = false
+            ndk {
+                debugSymbolLevel = "SYMBOL_TABLE"
+            }
             proguardFiles(
                 getDefaultProguardFile("proguard-android-optimize.txt"),
                 "proguard-rules.pro"
@@ -45,6 +92,10 @@ android {
         compose = true
         buildConfig = true
     }
+
+    lint {
+        disable += "NullSafeMutableLiveData"
+    }
 }
 
 dependencies {
@@ -57,6 +108,8 @@ dependencies {
     implementation(libs.androidx.lifecycle.runtime.compose)
     implementation(libs.androidx.lifecycle.viewmodel.compose)
     implementation(libs.androidx.navigation.compose)
+    implementation(libs.androidx.room.ktx)
+    implementation(libs.androidx.room.runtime)
     implementation(libs.androidx.work.runtime.ktx)
     implementation(libs.camera.camera2)
     implementation(libs.camera.core)
@@ -70,6 +123,9 @@ dependencies {
     implementation(libs.compose.ui.graphics)
     implementation(libs.compose.ui.tooling.preview)
     implementation(libs.coroutines.android)
+    implementation(platform(libs.firebase.bom))
+    implementation(libs.firebase.crashlytics)
+    implementation(libs.firebase.messaging)
     implementation(libs.okhttp)
     implementation(libs.okhttp.logging)
     implementation(libs.play.services.auth)
@@ -81,4 +137,6 @@ dependencies {
 
     testImplementation(libs.junit)
     testImplementation(libs.coroutines.test)
+
+    ksp(libs.androidx.room.compiler)
 }

app/src/main/AndroidManifest.xml

@@ -2,10 +2,16 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.CAMERA" />
+    <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" />
 
     <application
         android:allowBackup="false"
+        android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
+        android:name=".DriverApplication"
+        android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.TppKierowca">
         <activity
@@ -26,5 +32,13 @@
                 android:name="android.support.FILE_PROVIDER_PATHS"
                 android:resource="@xml/file_paths" />
         </provider>
+
+        <service
+            android:name=".sync.DriverFirebaseMessagingService"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="com.google.firebase.MESSAGING_EVENT" />
+            </intent-filter>
+        </service>
     </application>
 </manifest>

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

@@ -0,0 +1,12 @@
+package pl.firmatpp.kierowca
+
+import android.app.Application
+import pl.firmatpp.kierowca.diagnostics.AppDiagnostics
+
+class DriverApplication : Application() {
+    override fun onCreate() {
+        super.onCreate()
+        AppDiagnostics.installFirebaseCrashlytics()
+        AppDiagnostics.log("app_started")
+    }
+}

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

@@ -3,19 +3,46 @@ package pl.firmatpp.kierowca
 import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
 import pl.firmatpp.kierowca.ui.DriverApp
 import pl.firmatpp.kierowca.ui.DriverViewModel
 import pl.firmatpp.kierowca.ui.theme.TppKierowcaTheme
 
 class MainActivity : ComponentActivity() {
+    private var notificationRouteId 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)
+        notificationLeaveRequestId = intent.getStringExtra(EXTRA_LEAVE_REQUEST_ID)
         setContent {
-            TppKierowcaTheme {
+            val viewModel: DriverViewModel = viewModel()
-                val viewModel: DriverViewModel = viewModel()
+            val state by viewModel.state.collectAsStateWithLifecycle()
-                DriverApp(viewModel = viewModel)
+
+            TppKierowcaTheme(themeMode = state.themeMode) {
+                DriverApp(
+                    viewModel = viewModel,
+                    initialRouteId = notificationRouteId,
+                    initialLeaveRequestId = notificationLeaveRequestId,
+                )
             }
         }
     }
+
+    override fun onNewIntent(intent: android.content.Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+        notificationRouteId = intent.getStringExtra(EXTRA_ROUTE_ID)
+        notificationLeaveRequestId = intent.getStringExtra(EXTRA_LEAVE_REQUEST_ID)
+    }
+
+    companion object {
+        const val EXTRA_ROUTE_ID = "pl.firmatpp.kierowca.EXTRA_ROUTE_ID"
+        const val EXTRA_LEAVE_REQUEST_ID = "pl.firmatpp.kierowca.EXTRA_LEAVE_REQUEST_ID"
+    }
 }

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

@@ -0,0 +1,108 @@
+package pl.firmatpp.kierowca.data
+
+import java.io.IOException
+import java.net.UnknownHostException
+import retrofit2.HttpException
+
+enum class ApiErrorKind {
+    Network,
+    Auth,
+    Forbidden,
+    Validation,
+    Conflict,
+    RateLimited,
+    Server,
+    Unknown,
+}
+
+data class ApiError(
+    val kind: ApiErrorKind,
+    val message: String,
+    val retryable: Boolean,
+    val code: String? = null,
+    val statusCode: Int? = null,
+    val responseBody: String? = null,
+)
+
+object ApiErrorMapper {
+    fun map(throwable: Throwable): ApiError =
+        when (throwable) {
+            is UnknownHostException -> ApiError(
+                kind = ApiErrorKind.Network,
+                message = "Brak internetu lub połączenia z serwerem. Sprawdź zasięg i spróbuj ponownie.",
+                retryable = true,
+            )
+            is IOException -> ApiError(
+                kind = ApiErrorKind.Network,
+                message = "Nie udało się połączyć z serwerem. Operacja nie została potwierdzona.",
+                retryable = true,
+            )
+            is HttpException -> mapHttpException(throwable)
+            else -> ApiError(
+                kind = ApiErrorKind.Unknown,
+                message = throwable.message ?: "Wystąpił błąd. Operacja nie została potwierdzona.",
+                retryable = false,
+            )
+        }
+
+    fun shouldReportNonFatal(throwable: Throwable): Boolean =
+        map(throwable).kind != ApiErrorKind.Network
+
+    fun mapHttpStatus(statusCode: Int, body: String?): ApiError {
+        val code = body?.let { """"code"\s*:\s*"([^"]+)"""".toRegex().find(it)?.groupValues?.getOrNull(1) }
+        val message = body?.let { """"message"\s*:\s*"([^"]+)"""".toRegex().find(it)?.groupValues?.getOrNull(1) }
+        val retryable = body?.let { """"retryable"\s*:\s*(true|false)""".toRegex().find(it)?.groupValues?.getOrNull(1)?.toBooleanStrictOrNull() }
+
+        return mapProblem(
+            statusCode = statusCode,
+            code = code,
+            message = message,
+            retryable = retryable,
+            responseBody = body,
+        )
+    }
+
+    fun mapProblem(
+        statusCode: Int,
+        code: String?,
+        message: String?,
+        retryable: Boolean?,
+        responseBody: String? = null,
+    ): ApiError {
+        val kind = when (statusCode) {
+            401 -> ApiErrorKind.Auth
+            403 -> ApiErrorKind.Forbidden
+            400, 422 -> ApiErrorKind.Validation
+            409 -> ApiErrorKind.Conflict
+            429 -> ApiErrorKind.RateLimited
+            in 500..599 -> ApiErrorKind.Server
+            else -> ApiErrorKind.Unknown
+        }
+        val defaultRetryable = statusCode == 429 || statusCode in 500..599
+        val resolvedRetryable = retryable ?: defaultRetryable
+        val resolvedMessage = message?.takeIf { it.isNotBlank() } ?: when (kind) {
+            ApiErrorKind.Auth -> "Sesja wygasła. Zaloguj się ponownie."
+            ApiErrorKind.Forbidden -> "Brak uprawnień do tej operacji."
+            ApiErrorKind.Validation -> "Serwer odrzucił operację. Nie została zapisana."
+            ApiErrorKind.Conflict -> "Operacja jest w konflikcie z aktualnym stanem danych."
+            ApiErrorKind.RateLimited -> "Za dużo prób. Aplikacja spróbuje ponownie później."
+            ApiErrorKind.Server -> "Serwer nie potwierdził operacji. Aplikacja spróbuje ponownie."
+            ApiErrorKind.Network -> "Nie udało się połączyć z serwerem. Operacja nie została potwierdzona."
+            ApiErrorKind.Unknown -> "Wystąpił błąd. Operacja nie została potwierdzona."
+        }
+
+        return ApiError(
+            kind = kind,
+            message = resolvedMessage,
+            retryable = resolvedRetryable,
+            code = code,
+            statusCode = statusCode,
+            responseBody = responseBody,
+        )
+    }
+
+    private fun mapHttpException(exception: HttpException): ApiError {
+        val body = runCatching { exception.response()?.errorBody()?.string() }.getOrNull()
+        return mapHttpStatus(exception.code(), body)
+    }
+}

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

@@ -0,0 +1,30 @@
+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.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.datastore.preferences.preferencesDataStore
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import pl.firmatpp.kierowca.ui.theme.AppThemeMode
+
+private val Context.driverAppPreferencesDataStore by preferencesDataStore(name = "driver_app_preferences")
+
+class AppPreferencesStore(
+    private val dataStore: DataStore<Preferences>,
+) {
+    constructor(context: Context) : this(context.driverAppPreferencesDataStore)
+
+    private val themeModeKey = stringPreferencesKey("theme_mode")
+
+    val themeMode: Flow<AppThemeMode> = dataStore.data
+        .map { preferences -> AppThemeMode.fromStoredValue(preferences[themeModeKey]) }
+
+    suspend fun setThemeMode(themeMode: AppThemeMode) {
+        dataStore.edit { preferences ->
+            preferences[themeModeKey] = themeMode.storedValue
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+package pl.firmatpp.kierowca.data
+
+import android.content.Context
+import android.os.Build
+import android.provider.Settings
+import pl.firmatpp.kierowca.BuildConfig
+import pl.firmatpp.kierowca.data.model.DriverDeviceInfo
+
+class DeviceInfoProvider(
+    private val context: Context,
+    private val tokenStore: TokenStore,
+) {
+    suspend fun currentDeviceInfo(): DriverDeviceInfo =
+        DriverDeviceInfo(
+            deviceId = tokenStore.deviceId(),
+            androidId = Settings.Secure.getString(context.contentResolver, Settings.Secure.ANDROID_ID),
+            brand = Build.BRAND,
+            manufacturer = Build.MANUFACTURER,
+            model = Build.MODEL,
+            device = Build.DEVICE,
+            product = Build.PRODUCT,
+            androidVersion = Build.VERSION.RELEASE,
+            sdkInt = Build.VERSION.SDK_INT,
+            appVersion = BuildConfig.VERSION_NAME,
+            serialNumber = readSerialNumber(),
+        )
+
+    private fun readSerialNumber(): String? =
+        runCatching {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                Build.getSerial()
+            } else {
+                @Suppress("DEPRECATION")
+                Build.SERIAL
+            }
+        }.getOrNull()
+            ?.takeUnless { it.isBlank() || it.equals(Build.UNKNOWN, ignoreCase = true) }
+}

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

@@ -2,29 +2,47 @@ package pl.firmatpp.kierowca.data
 
 import android.content.Context
 import android.net.Uri
+import java.io.File
+import java.security.MessageDigest
+import java.util.UUID
 import okhttp3.MediaType.Companion.toMediaTypeOrNull
 import okhttp3.MultipartBody
+import okhttp3.RequestBody
 import okhttp3.RequestBody.Companion.toRequestBody
 import pl.firmatpp.kierowca.data.api.ApiFactory
 import pl.firmatpp.kierowca.data.api.MobileDriverApi
 import pl.firmatpp.kierowca.data.model.BootstrapResponse
+import pl.firmatpp.kierowca.data.model.BroadcastAuthBody
+import pl.firmatpp.kierowca.data.model.BroadcastAuthResponse
+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.DriverLeaveRequestDto
+import pl.firmatpp.kierowca.data.model.NotificationPreferencesBody
+import pl.firmatpp.kierowca.data.model.NotificationPreferencesDto
 import pl.firmatpp.kierowca.data.model.OtpResponse
 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.RouteResponse
+import pl.firmatpp.kierowca.data.model.SyncStateResponse
 import pl.firmatpp.kierowca.data.model.VerifyOtpBody
+import pl.firmatpp.kierowca.data.upload.DispatchSheetUploadEntity
+import pl.firmatpp.kierowca.data.upload.PhotoUploadEntity
 
 class DriverRepository(
     private val context: Context,
     private val api: MobileDriverApi = ApiFactory.mobileDriverApi(),
     private val tokenStore: TokenStore = TokenStore(context),
+    private val deviceInfoProvider: DeviceInfoProvider = DeviceInfoProvider(context, tokenStore),
 ) {
     suspend fun requestOtp(phoneNumber: String): OtpResponse =
         api.requestOtp(RequestOtpBody(phoneNumber))
 
     suspend fun verifyOtp(phoneNumber: String, code: String, deviceName: String): DriverDto {
-        val response = api.verifyOtp(VerifyOtpBody(phoneNumber, code, deviceName))
+        val response = api.verifyOtp(VerifyOtpBody(phoneNumber, code, deviceName, deviceInfoProvider.currentDeviceInfo()))
         val token = response.accessToken ?: error("Brak tokenu sesji.")
         tokenStore.save(token)
         return response.driver ?: error("Brak danych kierowcy.")
@@ -36,20 +54,134 @@ class DriverRepository(
     suspend fun route(routeId: String): RouteResponse =
         api.route(authHeader(requireToken()), routeId)
 
-    suspend fun uploadPhoto(routeId: String, uri: Uri, source: String): PhotoUploadResponse {
+    suspend fun leaveRequests(): List<DriverLeaveRequestDto> =
+        api.leaveRequests(authHeader(requireToken())).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 completeRoute(routeId: String) =
+        api.completeRoute(authHeader(requireToken()), routeId)
+
+    suspend fun updateNotificationPreferences(notifyNewRoutes: Boolean): NotificationPreferencesDto =
+        api.updateNotificationPreferences(authHeader(requireToken()), NotificationPreferencesBody(notifyNewRoutes))
+
+    suspend fun syncState(date: String?, routeId: String? = null): SyncStateResponse =
+        api.syncState(authHeader(requireToken()), date, routeId)
+
+    suspend fun broadcastAuth(socketId: String, channelName: String): BroadcastAuthResponse =
+        api.broadcastAuth(authHeader(requireToken()), BroadcastAuthBody(socketId, channelName))
+
+    suspend fun storePushToken(token: String) {
+        api.storePushToken(authHeader(requireToken()), PushTokenBody(token))
+    }
+
+    suspend fun storeRealtimeStatus(status: String, socketId: String? = null, error: String? = null) {
+        api.storeRealtimeStatus(authHeader(requireToken()), RealtimeStatusBody(status, socketId, error))
+    }
+
+    suspend fun deletePushToken() {
+        val token = tokenStore.read() ?: return
+        runCatching { api.deletePushToken(authHeader(token)) }
+    }
+
+    suspend fun uploadPhoto(
+        routeId: String,
+        uri: Uri,
+        source: String,
+        metadata: PhotoUploadMetadata = PhotoUploadMetadata(),
+    ): PhotoUploadResponse {
         val resolver = context.contentResolver
         val mimeType = resolver.getType(uri) ?: "image/jpeg"
         val bytes = resolver.openInputStream(uri)?.use { it.readBytes() } ?: error("Nie mozna odczytac zdjecia.")
+        val clientRequestId = UUID.randomUUID().toString()
+        val contentSha256 = sha256(bytes)
         val body = bytes.toRequestBody(mimeType.toMediaTypeOrNull())
         val photo = MultipartBody.Part.createFormData("photo", "ladunek.jpg", body)
         val sourceBody = source.toRequestBody("text/plain".toMediaTypeOrNull())
+        val metadataParts = metadata.toMultipartTextParts()
 
-        return api.uploadPhoto(authHeader(requireToken()), routeId, photo, sourceBody)
+        return api.uploadPhoto(
+            authHeader(requireToken()),
+            clientRequestId,
+            routeId,
+            photo,
+            clientRequestId.toPlainTextBody(),
+            contentSha256.toPlainTextBody(),
+            sourceBody,
+            metadataParts["takenAt"],
+            metadataParts["latitude"],
+            metadataParts["longitude"],
+            metadataParts["locationAccuracyMeters"],
+        )
+    }
+
+    suspend fun uploadQueuedPhoto(upload: PhotoUploadEntity): PhotoUploadResponse {
+        val file = File(upload.localPath)
+        val body = file.readBytes().toRequestBody(upload.mimeType.toMediaTypeOrNull())
+        val photo = MultipartBody.Part.createFormData("photo", file.name, body)
+        val metadataParts = PhotoUploadMetadata(
+            takenAt = upload.takenAt,
+            latitude = upload.latitude,
+            longitude = upload.longitude,
+            locationAccuracyMeters = upload.locationAccuracyMeters,
+        ).toMultipartTextParts()
+
+        return api.uploadPhoto(
+            authHeader(requireToken()),
+            upload.clientRequestId,
+            upload.routeId,
+            photo,
+            upload.clientRequestId.toPlainTextBody(),
+            upload.contentSha256.toPlainTextBody(),
+            upload.source.toPlainTextBody(),
+            metadataParts["takenAt"],
+            metadataParts["latitude"],
+            metadataParts["longitude"],
+            metadataParts["locationAccuracyMeters"],
+        )
+    }
+
+    suspend fun uploadQueuedDispatchSheetPhoto(upload: DispatchSheetUploadEntity): DispatchSheetUploadResponse {
+        val file = File(upload.localPath)
+        val body = file.readBytes().toRequestBody(upload.mimeType.toMediaTypeOrNull())
+        val photo = MultipartBody.Part.createFormData("photo", file.name, body)
+        val metadataParts = PhotoUploadMetadata(
+            takenAt = upload.takenAt,
+            latitude = upload.latitude,
+            longitude = upload.longitude,
+            locationAccuracyMeters = upload.locationAccuracyMeters,
+        ).toMultipartTextParts()
+
+        return api.uploadDispatchSheetPhoto(
+            authHeader(requireToken()),
+            upload.clientRequestId,
+            photo,
+            upload.clientRequestId.toPlainTextBody(),
+            upload.contentSha256.toPlainTextBody(),
+            upload.source.toPlainTextBody(),
+            metadataParts["takenAt"],
+            metadataParts["latitude"],
+            metadataParts["longitude"],
+            metadataParts["locationAccuracyMeters"],
+            upload.replacePhotoId?.toPlainTextBody(),
+        )
+    }
+
+    suspend fun deletePhoto(photoId: String) {
+        api.deletePhoto(authHeader(requireToken()), photoId)
     }
 
     suspend fun logout() {
         val token = tokenStore.read()
         if (token != null) {
+            runCatching { api.deletePushToken(authHeader(token)) }
             runCatching { api.logout(authHeader(token)) }
         }
         tokenStore.clear()
@@ -62,4 +194,11 @@ class DriverRepository(
     private suspend fun requireToken(): String = tokenStore.read() ?: error("Brak aktywnej sesji.")
 
     private fun authHeader(token: String): String = "Bearer $token"
+
+    private fun String.toPlainTextBody(): RequestBody = toRequestBody("text/plain".toMediaTypeOrNull())
+
+    private fun sha256(bytes: ByteArray): String =
+        MessageDigest.getInstance("SHA-256")
+            .digest(bytes)
+            .joinToString("") { "%02x".format(it) }
 }

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

@@ -0,0 +1,21 @@
+package pl.firmatpp.kierowca.data
+
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.RequestBody
+import okhttp3.RequestBody.Companion.toRequestBody
+
+data class PhotoUploadMetadata(
+    val takenAt: String? = null,
+    val latitude: Double? = null,
+    val longitude: Double? = null,
+    val locationAccuracyMeters: Double? = null,
+)
+
+fun PhotoUploadMetadata.toMultipartTextParts(): Map<String, RequestBody> = buildMap {
+    takenAt?.let { put("takenAt", it.toPlainTextBody()) }
+    latitude?.let { put("latitude", it.toString().toPlainTextBody()) }
+    longitude?.let { put("longitude", it.toString().toPlainTextBody()) }
+    locationAccuracyMeters?.let { put("locationAccuracyMeters", it.toString().toPlainTextBody()) }
+}
+
+private fun String.toPlainTextBody(): RequestBody = toRequestBody("text/plain".toMediaTypeOrNull())

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

@@ -6,11 +6,13 @@ import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
+import java.util.UUID
 
 private val Context.driverDataStore by preferencesDataStore(name = "driver_session")
 
 class TokenStore(private val context: Context) {
     private val tokenKey = stringPreferencesKey("access_token")
+    private val deviceIdKey = stringPreferencesKey("device_id")
 
     suspend fun save(token: String) {
         context.driverDataStore.edit { preferences ->
@@ -22,6 +24,21 @@ class TokenStore(private val context: Context) {
         .map { it[tokenKey] }
         .first()
 
+    suspend fun deviceId(): String {
+        val existing = context.driverDataStore.data
+            .map { it[deviceIdKey] }
+            .first()
+
+        if (!existing.isNullOrBlank()) return existing
+
+        val generated = UUID.randomUUID().toString()
+        context.driverDataStore.edit { preferences ->
+            preferences[deviceIdKey] = generated
+        }
+
+        return generated
+    }
+
     suspend fun clear() {
         context.driverDataStore.edit { it.remove(tokenKey) }
     }

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

@@ -3,17 +3,33 @@ package pl.firmatpp.kierowca.data.api
 import okhttp3.MultipartBody
 import okhttp3.RequestBody
 import pl.firmatpp.kierowca.data.model.BootstrapResponse
+import pl.firmatpp.kierowca.data.model.BroadcastAuthBody
+import pl.firmatpp.kierowca.data.model.BroadcastAuthResponse
+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.LeaveRequestListResponse
+import pl.firmatpp.kierowca.data.model.LeaveRequestResponse
+import pl.firmatpp.kierowca.data.model.LeaveRequestTypesResponse
 import pl.firmatpp.kierowca.data.model.OtpResponse
+import pl.firmatpp.kierowca.data.model.NotificationPreferencesBody
+import pl.firmatpp.kierowca.data.model.NotificationPreferencesDto
 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.RouteResponse
+import pl.firmatpp.kierowca.data.model.SyncStateResponse
 import pl.firmatpp.kierowca.data.model.VerifyOtpBody
 import pl.firmatpp.kierowca.data.model.VerifyOtpResponse
 import retrofit2.http.Body
+import retrofit2.http.DELETE
 import retrofit2.http.GET
 import retrofit2.http.Header
 import retrofit2.http.Multipart
 import retrofit2.http.POST
+import retrofit2.http.PUT
 import retrofit2.http.Part
 import retrofit2.http.Path
 import retrofit2.http.Query
@@ -28,24 +44,129 @@ interface MobileDriverApi {
     @POST("mobile/driver/auth/logout")
     suspend fun logout(@Header("Authorization") authorization: String): Map<String, Boolean>
 
+    @GET("mobile/driver/notification-preferences")
+    suspend fun notificationPreferences(
+        @Header("Authorization") authorization: String,
+    ): NotificationPreferencesDto
+
+    @PUT("mobile/driver/notification-preferences")
+    suspend fun updateNotificationPreferences(
+        @Header("Authorization") authorization: String,
+        @Body body: NotificationPreferencesBody,
+    ): NotificationPreferencesDto
+
     @GET("mobile/driver/bootstrap")
     suspend fun bootstrap(
         @Header("Authorization") authorization: String,
         @Query("date") date: String?,
     ): BootstrapResponse
 
+    @GET("mobile/driver/leave-request-types")
+    suspend fun leaveRequestTypes(
+        @Header("Authorization") authorization: String,
+    ): LeaveRequestTypesResponse
+
+    @GET("mobile/driver/leave-requests")
+    suspend fun leaveRequests(
+        @Header("Authorization") authorization: String,
+    ): LeaveRequestListResponse
+
+    @POST("mobile/driver/leave-requests")
+    suspend fun createLeaveRequest(
+        @Header("Authorization") authorization: String,
+        @Body body: CreateLeaveRequestBody,
+    ): LeaveRequestResponse
+
+    @GET("mobile/driver/leave-requests/{id}")
+    suspend fun leaveRequest(
+        @Header("Authorization") authorization: String,
+        @Path("id") id: String,
+    ): LeaveRequestResponse
+
+    @POST("mobile/driver/leave-requests/{id}/cancel")
+    suspend fun cancelLeaveRequest(
+        @Header("Authorization") authorization: String,
+        @Path("id") id: String,
+        @Body body: CancelLeaveRequestBody,
+    ): LeaveRequestResponse
+
     @GET("mobile/driver/routes/{routeId}")
     suspend fun route(
         @Header("Authorization") authorization: String,
         @Path("routeId") routeId: String,
     ): RouteResponse
 
+    @POST("mobile/driver/routes/{routeId}/complete")
+    suspend fun completeRoute(
+        @Header("Authorization") authorization: String,
+        @Path("routeId") routeId: String,
+    ): CompleteRouteResponse
+
+    @GET("mobile/driver/sync-state")
+    suspend fun syncState(
+        @Header("Authorization") authorization: String,
+        @Query("date") date: String?,
+        @Query("routeId") routeId: String?,
+    ): SyncStateResponse
+
+    @POST("mobile/driver/broadcasting/auth")
+    suspend fun broadcastAuth(
+        @Header("Authorization") authorization: String,
+        @Body body: BroadcastAuthBody,
+    ): BroadcastAuthResponse
+
+    @PUT("mobile/driver/push-token")
+    suspend fun storePushToken(
+        @Header("Authorization") authorization: String,
+        @Body body: PushTokenBody,
+    ): Map<String, Boolean>
+
+    @PUT("mobile/driver/realtime-status")
+    suspend fun storeRealtimeStatus(
+        @Header("Authorization") authorization: String,
+        @Body body: RealtimeStatusBody,
+    ): Map<String, Boolean>
+
+    @DELETE("mobile/driver/push-token")
+    suspend fun deletePushToken(
+        @Header("Authorization") authorization: String,
+    ): Map<String, Boolean>
+
     @Multipart
     @POST("mobile/driver/routes/{routeId}/photos")
     suspend fun uploadPhoto(
         @Header("Authorization") authorization: String,
+        @Header("Idempotency-Key") idempotencyKey: String,
         @Path("routeId") routeId: String,
         @Part photo: MultipartBody.Part,
+        @Part("clientRequestId") clientRequestId: RequestBody,
+        @Part("contentSha256") contentSha256: RequestBody,
         @Part("source") source: RequestBody,
+        @Part("takenAt") takenAt: RequestBody?,
+        @Part("latitude") latitude: RequestBody?,
+        @Part("longitude") longitude: RequestBody?,
+        @Part("locationAccuracyMeters") locationAccuracyMeters: RequestBody?,
     ): PhotoUploadResponse
+
+    @Multipart
+    @POST("mobile/driver/dispatch-sheet-photos")
+    suspend fun uploadDispatchSheetPhoto(
+        @Header("Authorization") authorization: String,
+        @Header("Idempotency-Key") idempotencyKey: String,
+        @Part photo: MultipartBody.Part,
+        @Part("clientRequestId") clientRequestId: RequestBody,
+        @Part("contentSha256") contentSha256: RequestBody,
+        @Part("source") source: RequestBody,
+        @Part("takenAt") takenAt: RequestBody?,
+        @Part("latitude") latitude: RequestBody?,
+        @Part("longitude") longitude: RequestBody?,
+        @Part("locationAccuracyMeters") locationAccuracyMeters: RequestBody?,
+        @Part("replacePhotoId") replacePhotoId: RequestBody?,
+    ): DispatchSheetUploadResponse
+
+    @DELETE("mobile/driver/photos/{photoId}")
+    suspend fun deletePhoto(
+        @Header("Authorization") authorization: String,
+        @Path("photoId") photoId: String,
+    ): Map<String, Boolean>
 }

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

@@ -6,6 +6,21 @@ data class VerifyOtpBody(
     val phoneNumber: String,
     val code: String,
     val deviceName: String,
+    val device: DriverDeviceInfo,
+)
+
+data class DriverDeviceInfo(
+    val deviceId: String,
+    val androidId: String?,
+    val brand: String?,
+    val manufacturer: String?,
+    val model: String?,
+    val device: String?,
+    val product: String?,
+    val androidVersion: String?,
+    val sdkInt: Int,
+    val appVersion: String?,
+    val serialNumber: String?,
 )
 
 data class OtpResponse(
@@ -31,6 +46,10 @@ data class BootstrapResponse(
     val session: DriverSessionDto,
     val routes: RoutesBucketDto,
     val driverAppSettings: DriverAppSettingsDto?,
+    val dispatchSheetReminder: DispatchSheetReminderDto? = null,
+    val notificationPreferences: NotificationPreferencesDto? = null,
+    val realtime: RealtimeConfigDto? = null,
+    val syncState: SyncStateResponse? = null,
 )
 
 data class DriverAppSettingsDto(
@@ -41,6 +60,44 @@ data class DriverAppSettingsDto(
     val maxPastDays: Int,
     val autoRefreshSeconds: Int,
     val allowGalleryUploads: Boolean?,
+    val allowRouteCompletion: Boolean?,
+    val requirePreciseLocationForPhotos: Boolean?,
+    val dispatchSheetRemindersEnabled: Boolean? = null,
+    val dispatchSheetOnFridays: Boolean? = null,
+    val dispatchSheetOnLastWorkingDay: Boolean? = null,
+    val leaveRequests: LeaveRequestsConfigDto? = null,
+)
+
+data class LeaveRequestsConfigDto(
+    val enabled: Boolean = false,
+    val types: List<String> = listOf("URLOP"),
+)
+
+data class DispatchSheetReminderDto(
+    val enabled: Boolean = false,
+    val dueToday: Boolean = false,
+    val workDate: String? = null,
+    val reason: String? = null,
+    val availableUntil: String? = null,
+    val status: String = "not_required",
+    val photo: DispatchSheetPhotoDto? = null,
+    val canUpload: Boolean = false,
+)
+
+data class DispatchSheetPhotoDto(
+    val id: String,
+    val driverId: String,
+    val workDate: String?,
+    val clientRequestId: String? = null,
+    val contentSha256: String? = null,
+    val source: String,
+    val mimeType: String?,
+    val size: Long,
+    val takenAt: String?,
+    val latitude: Double?,
+    val longitude: Double?,
+    val locationAccuracyMeters: Double?,
+    val createdAt: String?,
 )
 
 data class DriverSessionDto(
@@ -48,16 +105,125 @@ data class DriverSessionDto(
     val lastSyncAt: String,
 )
 
+data class NotificationPreferencesDto(
+    val notifyNewRoutes: Boolean = false,
+)
+
+data class RealtimeConfigDto(
+    val reverbEnabled: Boolean = false,
+    val reverbAppKey: String? = null,
+    val reverbWsBaseUrl: String? = null,
+)
+
 data class RoutesBucketDto(
     val today: List<DriverRouteDto> = emptyList(),
 )
 
 data class RouteResponse(
     val route: DriverRouteDto,
+    val syncState: SyncStateResponse? = null,
+)
+
+data class CompleteRouteResponse(
+    val ok: Boolean,
+    val alreadyCompleted: Boolean,
+    val message: String?,
+    val completedAt: String?,
+    val route: DriverRouteDto,
+)
+
+data class SyncStateResponse(
+    val scopes: List<SyncScopeDto> = emptyList(),
+)
+
+data class SyncScopeDto(
+    val scope: String,
+    val date: String? = null,
+    val routeId: String? = null,
+    val version: Long,
+    val checksum: String,
+    val computedAt: String,
+)
+
+data class BroadcastAuthBody(
+    val socket_id: String,
+    val channel_name: String,
+)
+
+data class BroadcastAuthResponse(
+    val auth: String,
+)
+
+data class PushTokenBody(
+    val token: String,
+    val platform: String = "android",
+)
+
+data class NotificationPreferencesBody(
+    val notifyNewRoutes: Boolean,
+)
+
+data class LeaveRequestListResponse(
+    val data: List<DriverLeaveRequestDto> = emptyList(),
+)
+
+data class LeaveRequestResponse(
+    val data: DriverLeaveRequestDto,
+)
+
+data class LeaveRequestTypesResponse(
+    val data: List<LeaveRequestTypeDto> = emptyList(),
+)
+
+data class LeaveRequestTypeDto(
+    val value: String,
+    val label: String,
+)
+
+data class CreateLeaveRequestBody(
+    val dateFrom: String,
+    val dateTo: String,
+    val type: String,
+    val note: String?,
+)
+
+data class CancelLeaveRequestBody(
+    val comment: String? = null,
+)
+
+data class DriverLeaveRequestDto(
+    val id: String,
+    val driver: DriverDto? = null,
+    val dateFrom: String?,
+    val dateTo: String?,
+    val type: String,
+    val typeLabel: String? = null,
+    val note: String? = null,
+    val status: String,
+    val submittedAt: String? = null,
+    val decidedAt: String? = null,
+    val decisionComment: String? = null,
+    val events: List<DriverLeaveRequestEventDto> = emptyList(),
+)
+
+data class DriverLeaveRequestEventDto(
+    val id: String,
+    val action: String,
+    val fromStatus: String? = null,
+    val toStatus: String? = null,
+    val comment: String? = null,
+    val createdAt: String? = null,
+)
+
+data class RealtimeStatusBody(
+    val reverbStatus: String,
+    val socketId: String? = null,
+    val error: String? = null,
 )
 
 data class DriverRouteDto(
     val id: String,
+    val routeDate: String? = null,
     val startsAt: String,
     val originName: String,
     val destinationName: String,
@@ -69,25 +235,66 @@ data class DriverRouteDto(
     val distanceKm: Double?,
     val notes: String?,
     val truck: TruckDto?,
+    val completedAt: String? = null,
+    val completedByDriver: DriverDto? = null,
+    val originNavigation: NavigationPointDto? = null,
+    val destinationNavigation: NavigationPointDto? = null,
     val photos: List<RoutePhotoDto> = emptyList(),
 )
 
 data class TruckDto(
     val id: String,
     val registration: String?,
+    val trailerRegistration: String? = null,
     val name: String?,
 )
 
+data class NavigationPointDto(
+    val id: String,
+    val label: String?,
+    val latitude: Double?,
+    val longitude: Double?,
+)
+
 data class RoutePhotoDto(
     val id: String,
     val routeId: String,
+    val clientRequestId: String? = null,
+    val contentSha256: String? = null,
     val source: String,
     val mimeType: String?,
     val size: Long,
     val url: String,
+    val takenAt: String?,
+    val latitude: Double?,
+    val longitude: Double?,
+    val locationAccuracyMeters: Double?,
     val createdAt: String?,
+    val canDelete: Boolean = false,
+    val deleteUntil: String? = null,
 )
 
 data class PhotoUploadResponse(
     val photo: RoutePhotoDto,
+    val receipt: PhotoUploadReceiptDto,
+)
+
+data class PhotoUploadReceiptDto(
+    val clientRequestId: String,
+    val serverPhotoId: String,
+    val contentSha256: String,
+    val storedAt: String?,
+)
+
+data class DispatchSheetUploadResponse(
+    val photo: DispatchSheetPhotoDto,
+    val reminder: DispatchSheetReminderDto,
+    val receipt: DispatchSheetUploadReceiptDto,
+)
+
+data class DispatchSheetUploadReceiptDto(
+    val clientRequestId: String,
+    val serverPhotoId: String,
+    val contentSha256: String,
+    val storedAt: String?,
 )

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

@@ -0,0 +1,36 @@
+package pl.firmatpp.kierowca.data.sync
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+
+@Dao
+interface DriverCacheDao {
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun upsertBootstrap(cache: DriverBootstrapCacheEntity)
+
+    @Query("SELECT * FROM driver_bootstrap_cache WHERE date = :date LIMIT 1")
+    suspend fun bootstrap(date: String): 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?
+
+    @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("DELETE FROM driver_bootstrap_cache")
+    suspend fun clearBootstrap()
+
+    @Query("DELETE FROM driver_route_cache")
+    suspend fun clearRoutes()
+
+    @Query("DELETE FROM driver_sync_states")
+    suspend fun clearSyncStates()
+}

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

@@ -0,0 +1,49 @@
+package pl.firmatpp.kierowca.data.sync
+
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+
+@Entity(tableName = "driver_bootstrap_cache")
+data class DriverBootstrapCacheEntity(
+    @PrimaryKey val date: String,
+    val payloadJson: String,
+    val checksum: String?,
+    val version: Long?,
+    val syncedAtEpochMillis: Long,
+)
+
+@Entity(tableName = "driver_route_cache")
+data class DriverRouteCacheEntity(
+    @PrimaryKey val routeId: String,
+    val payloadJson: String,
+    val checksum: String?,
+    val version: Long?,
+    val syncedAtEpochMillis: Long,
+)
+
+@Entity(
+    tableName = "driver_sync_states",
+    indices = [
+        Index(value = ["scope", "date", "routeId"], unique = true),
+    ],
+)
+data class DriverSyncStateEntity(
+    @PrimaryKey val key: String,
+    val scope: String,
+    val date: String?,
+    val routeId: String?,
+    val checksum: String,
+    val version: Long,
+    val computedAt: String,
+    val syncedAtEpochMillis: Long,
+)
+
+data class CachedValue<T>(
+    val value: T,
+    val stale: Boolean,
+    val syncedAtEpochMillis: Long?,
+)
+
+fun syncStateKey(scope: String, date: String?, routeId: String?): String =
+    listOf(scope, date ?: "-", routeId ?: "-").joinToString(":")

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

@@ -0,0 +1,156 @@
+package pl.firmatpp.kierowca.data.sync
+
+import android.content.Context
+import com.google.gson.Gson
+import java.io.IOException
+import pl.firmatpp.kierowca.data.DriverRepository
+import pl.firmatpp.kierowca.data.model.BootstrapResponse
+import pl.firmatpp.kierowca.data.model.DriverRouteDto
+import pl.firmatpp.kierowca.data.model.RouteResponse
+import pl.firmatpp.kierowca.data.model.SyncScopeDto
+import pl.firmatpp.kierowca.data.model.SyncStateResponse
+import pl.firmatpp.kierowca.data.upload.DriverDatabase
+import retrofit2.HttpException
+
+class DriverSyncRepository(
+    context: Context,
+    private val repository: DriverRepository = DriverRepository(context),
+    private val dao: DriverCacheDao = DriverDatabase.get(context).driverCacheDao(),
+    private val gson: Gson = Gson(),
+) {
+    suspend fun bootstrap(date: String?): CachedValue<BootstrapResponse> {
+        val requestedDate = date ?: currentDateFallback()
+
+        return runCatching {
+            val response = repository.bootstrap(date)
+            val selectedDate = response.driverAppSettings?.selectedDate ?: requestedDate
+            val routeState = response.syncState?.scopes?.firstOrNull { it.scope == SCOPE_ROUTES }
+            dao.upsertBootstrap(
+                DriverBootstrapCacheEntity(
+                    date = selectedDate,
+                    payloadJson = gson.toJson(response),
+                    checksum = routeState?.checksum,
+                    version = routeState?.version,
+                    syncedAtEpochMillis = System.currentTimeMillis(),
+                ),
+            )
+            saveSyncStates(response.syncState)
+            CachedValue(response, stale = false, syncedAtEpochMillis = System.currentTimeMillis())
+        }.getOrElse { throwable ->
+            cachedBootstrap(requestedDate, throwable)
+        }
+    }
+
+    suspend fun route(routeId: String): CachedValue<RouteResponse> =
+        runCatching {
+            val response = repository.route(routeId)
+            val routeState = response.syncState?.scopes?.firstOrNull { it.scope == SCOPE_ROUTE_DETAIL }
+            dao.upsertRoute(
+                DriverRouteCacheEntity(
+                    routeId = routeId,
+                    payloadJson = gson.toJson(response),
+                    checksum = routeState?.checksum,
+                    version = routeState?.version,
+                    syncedAtEpochMillis = System.currentTimeMillis(),
+                ),
+            )
+            saveSyncStates(response.syncState)
+            CachedValue(response, stale = false, syncedAtEpochMillis = System.currentTimeMillis())
+        }.getOrElse { throwable ->
+            cachedRoute(routeId, throwable)
+        }
+
+    suspend fun cacheConfirmedRoute(route: DriverRouteDto, date: String?) {
+        val syncedAt = System.currentTimeMillis()
+        dao.upsertRoute(
+            DriverRouteCacheEntity(
+                routeId = route.id,
+                payloadJson = gson.toJson(RouteResponse(route = route)),
+                checksum = null,
+                version = null,
+                syncedAtEpochMillis = syncedAt,
+            ),
+        )
+
+        val selectedDate = date ?: return
+        val cachedBootstrap = dao.bootstrap(selectedDate) ?: return
+        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(
+            cachedBootstrap.copy(
+                payloadJson = gson.toJson(response.copy(routes = response.routes.copy(today = updatedRoutes))),
+                checksum = null,
+                version = null,
+                syncedAtEpochMillis = syncedAt,
+            ),
+        )
+    }
+
+    suspend fun fetchSyncState(date: String?, routeId: String?): SyncStateResponse =
+        repository.syncState(date, routeId)
+
+    suspend fun shouldRefresh(scope: SyncScopeDto): Boolean {
+        val local = dao.syncState(scope.scope, scope.date, scope.routeId)
+        return local == null || local.checksum != scope.checksum || local.version < scope.version
+    }
+
+    suspend fun saveSyncStates(response: SyncStateResponse?) {
+        response?.scopes.orEmpty().forEach { scope ->
+            dao.upsertSyncState(
+                DriverSyncStateEntity(
+                    key = syncStateKey(scope.scope, scope.date, scope.routeId),
+                    scope = scope.scope,
+                    date = scope.date,
+                    routeId = scope.routeId,
+                    checksum = scope.checksum,
+                    version = scope.version,
+                    computedAt = scope.computedAt,
+                    syncedAtEpochMillis = System.currentTimeMillis(),
+                ),
+            )
+        }
+    }
+
+    suspend fun clearCache() {
+        dao.clearBootstrap()
+        dao.clearRoutes()
+        dao.clearSyncStates()
+    }
+
+    private suspend fun cachedBootstrap(date: String, throwable: Throwable): CachedValue<BootstrapResponse> {
+        val cached = dao.bootstrap(date)
+        if (cached != null && throwable.isReadFallbackAllowed()) {
+            return CachedValue(
+                gson.fromJson(cached.payloadJson, BootstrapResponse::class.java),
+                stale = true,
+                syncedAtEpochMillis = cached.syncedAtEpochMillis,
+            )
+        }
+        throw throwable
+    }
+
+    private suspend fun cachedRoute(routeId: String, throwable: Throwable): CachedValue<RouteResponse> {
+        val cached = dao.route(routeId)
+        if (cached != null && throwable.isReadFallbackAllowed()) {
+            return CachedValue(
+                gson.fromJson(cached.payloadJson, RouteResponse::class.java),
+                stale = true,
+                syncedAtEpochMillis = cached.syncedAtEpochMillis,
+            )
+        }
+        throw throwable
+    }
+
+    private fun Throwable.isReadFallbackAllowed(): Boolean =
+        this is IOException || (this is HttpException && code() != 401 && code() != 403)
+
+    private fun currentDateFallback(): String = java.time.LocalDate.now().toString()
+
+    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"
+    }
+}

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

@@ -0,0 +1,38 @@
+package pl.firmatpp.kierowca.data.sync
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
+
+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
+
+        val callback = object : ConnectivityManager.NetworkCallback() {
+            override fun onAvailable(network: Network) {
+                trySend(current())
+            }
+
+            override fun onLost(network: Network) {
+                trySend(current())
+            }
+
+            override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
+                trySend(current())
+            }
+        }
+
+        trySend(current())
+        connectivityManager.registerDefaultNetworkCallback(callback)
+        awaitClose { connectivityManager.unregisterNetworkCallback(callback) }
+    }.distinctUntilChanged()
+}

app/src/main/java/pl/firmatpp/kierowca/data/upload/DispatchSheetUploadDao.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 DispatchSheetUploadDao {
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun upsert(upload: DispatchSheetUploadEntity)
+
+    @Query("SELECT * FROM dispatch_sheet_uploads WHERE clientRequestId = :clientRequestId LIMIT 1")
+    suspend fun find(clientRequestId: String): DispatchSheetUploadEntity?
+
+    @Query(
+        """
+        SELECT * FROM dispatch_sheet_uploads
+        WHERE workDate = :workDate
+        AND status != 'CANCELLED'
+        ORDER BY createdAtEpochMillis ASC
+        """,
+    )
+    fun observeVisibleForWorkDate(workDate: String): Flow<List<DispatchSheetUploadEntity>>
+
+    @Query(
+        """
+        UPDATE dispatch_sheet_uploads
+        SET status = :status,
+            progress = :progress,
+            lastError = :lastError,
+            attemptCount = attemptCount + :attemptIncrement,
+            updatedAtEpochMillis = :updatedAt
+        WHERE clientRequestId = :clientRequestId
+        """,
+    )
+    suspend fun updateStatus(
+        clientRequestId: String,
+        status: String,
+        progress: Int,
+        lastError: String?,
+        attemptIncrement: Int,
+        updatedAt: Long = System.currentTimeMillis(),
+    )
+
+    @Query(
+        """
+        UPDATE dispatch_sheet_uploads
+        SET status = 'CONFIRMED',
+            progress = 100,
+            lastError = NULL,
+            serverPhotoId = :serverPhotoId,
+            updatedAtEpochMillis = :updatedAt
+        WHERE clientRequestId = :clientRequestId
+        """,
+    )
+    suspend fun markConfirmed(
+        clientRequestId: String,
+        serverPhotoId: String,
+        updatedAt: Long = System.currentTimeMillis(),
+    )
+
+    @Query("DELETE FROM dispatch_sheet_uploads WHERE clientRequestId = :clientRequestId")
+    suspend fun delete(clientRequestId: String)
+}

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

@@ -0,0 +1,37 @@
+package pl.firmatpp.kierowca.data.upload
+
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+
+@Entity(
+    tableName = "dispatch_sheet_uploads",
+    indices = [
+        Index(value = ["workDate"]),
+        Index(value = ["status"]),
+    ],
+)
+data class DispatchSheetUploadEntity(
+    @PrimaryKey val clientRequestId: String,
+    val workDate: String,
+    val replacePhotoId: String?,
+    val localPath: String,
+    val source: String,
+    val takenAt: String?,
+    val latitude: Double?,
+    val longitude: Double?,
+    val locationAccuracyMeters: Double?,
+    val mimeType: String,
+    val size: Long,
+    val contentSha256: String,
+    val status: String = PhotoUploadStatus.Pending.storageValue,
+    val progress: Int = 0,
+    val attemptCount: Int = 0,
+    val lastError: String? = null,
+    val serverPhotoId: String? = null,
+    val createdAtEpochMillis: Long = System.currentTimeMillis(),
+    val updatedAtEpochMillis: Long = System.currentTimeMillis(),
+) {
+    val statusType: PhotoUploadStatus
+        get() = PhotoUploadStatus.fromStorage(status)
+}

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

@@ -0,0 +1,102 @@
+package pl.firmatpp.kierowca.data.upload
+
+import android.content.Context
+import android.net.Uri
+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.io.File
+import java.security.MessageDigest
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+import kotlinx.coroutines.flow.Flow
+import pl.firmatpp.kierowca.data.PhotoUploadMetadata
+
+class DispatchSheetUploadOutbox(
+    private val context: Context,
+    private val dao: DispatchSheetUploadDao = DriverDatabase.get(context).dispatchSheetUploadDao(),
+    private val workManager: WorkManager = WorkManager.getInstance(context),
+) {
+    fun observeVisibleForWorkDate(workDate: String): Flow<List<DispatchSheetUploadEntity>> =
+        dao.observeVisibleForWorkDate(workDate)
+
+    suspend fun enqueue(
+        workDate: String,
+        replacePhotoId: String?,
+        uri: Uri,
+        source: String,
+        metadata: PhotoUploadMetadata,
+    ): DispatchSheetUploadEntity {
+        val clientRequestId = UUID.randomUUID().toString()
+        val mimeType = context.contentResolver.getType(uri) ?: "image/jpeg"
+        val extension = when (mimeType) {
+            "image/png" -> "png"
+            "image/webp" -> "webp"
+            else -> "jpg"
+        }
+        val uploadDir = File(context.filesDir, "dispatch-sheet-upload-outbox").apply { mkdirs() }
+        val localFile = File(uploadDir, "$clientRequestId.$extension")
+        val sha256 = copyAndHash(uri, localFile)
+        val upload = DispatchSheetUploadEntity(
+            clientRequestId = clientRequestId,
+            workDate = workDate,
+            replacePhotoId = replacePhotoId,
+            localPath = localFile.absolutePath,
+            source = source,
+            takenAt = metadata.takenAt,
+            latitude = metadata.latitude,
+            longitude = metadata.longitude,
+            locationAccuracyMeters = metadata.locationAccuracyMeters,
+            mimeType = mimeType,
+            size = localFile.length(),
+            contentSha256 = sha256,
+        )
+
+        dao.upsert(upload)
+        enqueueWorker(clientRequestId)
+
+        return upload
+    }
+
+    suspend fun discard(clientRequestId: String) {
+        dao.find(clientRequestId)?.let { upload ->
+            File(upload.localPath).delete()
+            dao.delete(upload.clientRequestId)
+        }
+    }
+
+    private fun enqueueWorker(clientRequestId: String) {
+        val request = OneTimeWorkRequestBuilder<DispatchSheetUploadWorker>()
+            .setInputData(workDataOf(DispatchSheetUploadWorker.KEY_CLIENT_REQUEST_ID to clientRequestId))
+            .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build())
+            .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
+            .build()
+
+        workManager.enqueueUniqueWork(
+            DispatchSheetUploadWorker.uniqueWorkName(clientRequestId),
+            ExistingWorkPolicy.REPLACE,
+            request,
+        )
+    }
+
+    private fun copyAndHash(uri: Uri, target: File): String {
+        val digest = MessageDigest.getInstance("SHA-256")
+        context.contentResolver.openInputStream(uri).use { input ->
+            requireNotNull(input) { "Nie można odczytać zdjęcia karty spedycyjnej." }
+            target.outputStream().use { output ->
+                val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+                while (true) {
+                    val read = input.read(buffer)
+                    if (read == -1) break
+                    digest.update(buffer, 0, read)
+                    output.write(buffer, 0, read)
+                }
+            }
+        }
+        return digest.digest().joinToString("") { "%02x".format(it) }
+    }
+}

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

@@ -0,0 +1,10 @@
+package pl.firmatpp.kierowca.data.upload
+
+import pl.firmatpp.kierowca.data.model.DispatchSheetUploadReceiptDto
+
+object DispatchSheetUploadReceiptVerifier {
+    fun matches(upload: DispatchSheetUploadEntity, receipt: DispatchSheetUploadReceiptDto): Boolean =
+        upload.clientRequestId == receipt.clientRequestId &&
+            upload.contentSha256.equals(receipt.contentSha256, ignoreCase = true) &&
+            receipt.serverPhotoId.isNotBlank()
+}

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

@@ -0,0 +1,98 @@
+package pl.firmatpp.kierowca.data.upload
+
+import android.content.Context
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import androidx.work.workDataOf
+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.diagnostics.AppDiagnostics
+
+class DispatchSheetUploadWorker(
+    appContext: Context,
+    params: WorkerParameters,
+) : CoroutineWorker(appContext, params) {
+    private val dao = DriverDatabase.get(appContext).dispatchSheetUploadDao()
+    private val repository = DriverRepository(appContext)
+
+    override suspend fun doWork(): Result {
+        val clientRequestId = inputData.getString(KEY_CLIENT_REQUEST_ID) ?: return Result.failure()
+        val upload = dao.find(clientRequestId) ?: return Result.failure()
+        val file = File(upload.localPath)
+
+        if (!file.exists()) {
+            val message = "Lokalny plik zdjęcia karty spedycyjnej nie istnieje. Zdjęcie nie zostało zapisane."
+            dao.updateStatus(
+                clientRequestId = clientRequestId,
+                status = PhotoUploadStatus.FailedPermanent.storageValue,
+                progress = 0,
+                lastError = PhotoUploadFailureDetails.local(message),
+                attemptIncrement = 0,
+            )
+            return Result.failure()
+        }
+
+        dao.updateStatus(
+            clientRequestId = clientRequestId,
+            status = PhotoUploadStatus.Uploading.storageValue,
+            progress = 10,
+            lastError = null,
+            attemptIncrement = 1,
+        )
+        setProgress(workDataOf(KEY_PROGRESS to 10))
+
+        return runCatching {
+            setProgress(workDataOf(KEY_PROGRESS to 70))
+            val response = repository.uploadQueuedDispatchSheetPhoto(upload)
+
+            dao.updateStatus(
+                clientRequestId = clientRequestId,
+                status = PhotoUploadStatus.Verifying.storageValue,
+                progress = 90,
+                lastError = null,
+                attemptIncrement = 0,
+            )
+            setProgress(workDataOf(KEY_PROGRESS to 90))
+
+            val receipt = response.receipt
+            if (!DispatchSheetUploadReceiptVerifier.matches(upload, receipt)) {
+                error("Serwer nie potwierdził zgodności zdjęcia karty spedycyjnej. Zdjęcie nie zostało zapisane.")
+            }
+
+            dao.markConfirmed(clientRequestId, receipt.serverPhotoId)
+            Result.success()
+        }.getOrElse { throwable ->
+            val error = ApiErrorMapper.map(throwable)
+            AppDiagnostics.reportNonFatal(
+                throwable = throwable,
+                operation = "dispatch_sheet_upload_worker",
+                keys = mapOf(
+                    "client_request_id" to clientRequestId,
+                    "api_error_kind" to error.kind.name,
+                    "api_error_code" to error.code,
+                    "api_status_code" to error.statusCode,
+                    "retryable" to error.retryable,
+                ),
+            )
+            val status = if (error.retryable) PhotoUploadStatus.FailedRetryable else PhotoUploadStatus.FailedPermanent
+            dao.updateStatus(
+                clientRequestId = clientRequestId,
+                status = status.storageValue,
+                progress = 0,
+                lastError = PhotoUploadFailureDetails.fromApiError(error),
+                attemptIncrement = 0,
+            )
+
+            if (error.retryable && error.kind != ApiErrorKind.Auth) Result.retry() else Result.failure()
+        }
+    }
+
+    companion object {
+        const val KEY_CLIENT_REQUEST_ID = "clientRequestId"
+        const val KEY_PROGRESS = "progress"
+
+        fun uniqueWorkName(clientRequestId: String): String = "dispatch-sheet-upload-$clientRequestId"
+    }
+}

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

@@ -0,0 +1,117 @@
+package pl.firmatpp.kierowca.data.upload
+
+import android.content.Context
+import androidx.room.migration.Migration
+import androidx.room.Database
+import androidx.room.Room
+import androidx.room.RoomDatabase
+import androidx.sqlite.db.SupportSQLiteDatabase
+import pl.firmatpp.kierowca.data.sync.DriverBootstrapCacheEntity
+import pl.firmatpp.kierowca.data.sync.DriverCacheDao
+import pl.firmatpp.kierowca.data.sync.DriverRouteCacheEntity
+import pl.firmatpp.kierowca.data.sync.DriverSyncStateEntity
+
+@Database(
+    entities = [
+        PhotoUploadEntity::class,
+        DispatchSheetUploadEntity::class,
+        DriverBootstrapCacheEntity::class,
+        DriverRouteCacheEntity::class,
+        DriverSyncStateEntity::class,
+    ],
+    version = 3,
+    exportSchema = false,
+)
+abstract class DriverDatabase : RoomDatabase() {
+    abstract fun photoUploadDao(): PhotoUploadDao
+    abstract fun dispatchSheetUploadDao(): DispatchSheetUploadDao
+    abstract fun driverCacheDao(): DriverCacheDao
+
+    companion object {
+        @Volatile
+        private var instance: DriverDatabase? = null
+
+        private val migration1To2 = object : Migration(1, 2) {
+            override fun migrate(db: SupportSQLiteDatabase) {
+                db.execSQL(
+                    """
+                    CREATE TABLE IF NOT EXISTS driver_bootstrap_cache (
+                        date TEXT NOT NULL PRIMARY KEY,
+                        payloadJson TEXT NOT NULL,
+                        checksum TEXT,
+                        version INTEGER,
+                        syncedAtEpochMillis INTEGER NOT NULL
+                    )
+                    """.trimIndent(),
+                )
+                db.execSQL(
+                    """
+                    CREATE TABLE IF NOT EXISTS driver_route_cache (
+                        routeId TEXT NOT NULL PRIMARY KEY,
+                        payloadJson TEXT NOT NULL,
+                        checksum TEXT,
+                        version INTEGER,
+                        syncedAtEpochMillis INTEGER NOT NULL
+                    )
+                    """.trimIndent(),
+                )
+                db.execSQL(
+                    """
+                    CREATE TABLE IF NOT EXISTS driver_sync_states (
+                        key TEXT NOT NULL PRIMARY KEY,
+                        scope TEXT NOT NULL,
+                        date TEXT,
+                        routeId TEXT,
+                        checksum TEXT NOT NULL,
+                        version INTEGER NOT NULL,
+                        computedAt TEXT NOT NULL,
+                        syncedAtEpochMillis INTEGER NOT NULL
+                    )
+                    """.trimIndent(),
+                )
+                db.execSQL("CREATE UNIQUE INDEX IF NOT EXISTS index_driver_sync_states_scope_date_routeId ON driver_sync_states(scope, date, routeId)")
+            }
+        }
+
+        private val migration2To3 = object : Migration(2, 3) {
+            override fun migrate(db: SupportSQLiteDatabase) {
+                db.execSQL(
+                    """
+                    CREATE TABLE IF NOT EXISTS dispatch_sheet_uploads (
+                        clientRequestId TEXT NOT NULL PRIMARY KEY,
+                        workDate TEXT NOT NULL,
+                        replacePhotoId TEXT,
+                        localPath TEXT NOT NULL,
+                        source TEXT NOT NULL,
+                        takenAt TEXT,
+                        latitude REAL,
+                        longitude REAL,
+                        locationAccuracyMeters REAL,
+                        mimeType TEXT NOT NULL,
+                        size INTEGER NOT NULL,
+                        contentSha256 TEXT NOT NULL,
+                        status TEXT NOT NULL,
+                        progress INTEGER NOT NULL,
+                        attemptCount INTEGER NOT NULL,
+                        lastError TEXT,
+                        serverPhotoId TEXT,
+                        createdAtEpochMillis INTEGER NOT NULL,
+                        updatedAtEpochMillis INTEGER NOT NULL
+                    )
+                    """.trimIndent(),
+                )
+                db.execSQL("CREATE INDEX IF NOT EXISTS index_dispatch_sheet_uploads_workDate ON dispatch_sheet_uploads(workDate)")
+                db.execSQL("CREATE INDEX IF NOT EXISTS index_dispatch_sheet_uploads_status ON dispatch_sheet_uploads(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 }
+            }
+    }
+}

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

@@ -0,0 +1,85 @@
+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 PhotoUploadDao {
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun upsert(upload: PhotoUploadEntity)
+
+    @Query("SELECT * FROM photo_uploads WHERE clientRequestId = :clientRequestId LIMIT 1")
+    suspend fun find(clientRequestId: String): PhotoUploadEntity?
+
+    @Query(
+        """
+        SELECT * FROM photo_uploads
+        WHERE routeId = :routeId
+        AND status != 'CANCELLED'
+        ORDER BY createdAtEpochMillis ASC
+        """,
+    )
+    fun observeVisibleForRoute(routeId: String): Flow<List<PhotoUploadEntity>>
+
+    @Query(
+        """
+        SELECT * FROM photo_uploads
+        WHERE status != 'CONFIRMED'
+        AND status != 'CANCELLED'
+        ORDER BY createdAtEpochMillis ASC
+        """,
+    )
+    fun observeQueuedUploads(): Flow<List<PhotoUploadEntity>>
+
+    @Query(
+        """
+        SELECT * FROM photo_uploads
+        WHERE routeId = :routeId
+        AND status = 'CONFIRMED'
+        """,
+    )
+    suspend fun confirmedForRoute(routeId: String): List<PhotoUploadEntity>
+
+    @Query(
+        """
+        UPDATE photo_uploads
+        SET status = :status,
+            progress = :progress,
+            lastError = :lastError,
+            attemptCount = attemptCount + :attemptIncrement,
+            updatedAtEpochMillis = :updatedAt
+        WHERE clientRequestId = :clientRequestId
+        """,
+    )
+    suspend fun updateStatus(
+        clientRequestId: String,
+        status: String,
+        progress: Int,
+        lastError: String?,
+        attemptIncrement: Int,
+        updatedAt: Long = System.currentTimeMillis(),
+    )
+
+    @Query(
+        """
+        UPDATE photo_uploads
+        SET status = 'CONFIRMED',
+            progress = 100,
+            lastError = NULL,
+            serverPhotoId = :serverPhotoId,
+            updatedAtEpochMillis = :updatedAt
+        WHERE clientRequestId = :clientRequestId
+        """,
+    )
+    suspend fun markConfirmed(
+        clientRequestId: String,
+        serverPhotoId: String,
+        updatedAt: Long = System.currentTimeMillis(),
+    )
+
+    @Query("DELETE FROM photo_uploads WHERE clientRequestId = :clientRequestId")
+    suspend fun delete(clientRequestId: String)
+}

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

@@ -0,0 +1,36 @@
+package pl.firmatpp.kierowca.data.upload
+
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+
+@Entity(
+    tableName = "photo_uploads",
+    indices = [
+        Index(value = ["routeId"]),
+        Index(value = ["status"]),
+    ],
+)
+data class PhotoUploadEntity(
+    @PrimaryKey val clientRequestId: String,
+    val routeId: String,
+    val localPath: String,
+    val source: String,
+    val takenAt: String?,
+    val latitude: Double?,
+    val longitude: Double?,
+    val locationAccuracyMeters: Double?,
+    val mimeType: String,
+    val size: Long,
+    val contentSha256: String,
+    val status: String = PhotoUploadStatus.Pending.storageValue,
+    val progress: Int = 0,
+    val attemptCount: Int = 0,
+    val lastError: String? = null,
+    val serverPhotoId: String? = null,
+    val createdAtEpochMillis: Long = System.currentTimeMillis(),
+    val updatedAtEpochMillis: Long = System.currentTimeMillis(),
+) {
+    val statusType: PhotoUploadStatus
+        get() = PhotoUploadStatus.fromStorage(status)
+}

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

@@ -0,0 +1,39 @@
+package pl.firmatpp.kierowca.data.upload
+
+import pl.firmatpp.kierowca.data.ApiError
+import pl.firmatpp.kierowca.data.ApiErrorKind
+
+object PhotoUploadFailureDetails {
+    fun fromApiError(error: ApiError): String {
+        val type = when (error.kind) {
+            ApiErrorKind.Network -> "błąd komunikacji"
+            ApiErrorKind.Server,
+            ApiErrorKind.RateLimited,
+            ApiErrorKind.Validation,
+            ApiErrorKind.Forbidden,
+            ApiErrorKind.Auth,
+            ApiErrorKind.Conflict,
+            -> "błąd serwera"
+            ApiErrorKind.Unknown -> "błąd aplikacji"
+        }
+
+        return buildString {
+            appendLine("Typ: $type")
+            appendLine("Komunikat: ${error.message}")
+            error.statusCode?.let { appendLine("HTTP: $it") }
+            error.code?.takeIf { it.isNotBlank() }?.let { appendLine("Kod: $it") }
+            error.responseBody
+                ?.takeIf { it.isNotBlank() }
+                ?.let {
+                    appendLine("Odpowiedź serwera:")
+                    append(it.take(MAX_RESPONSE_CHARS))
+                    if (it.length > MAX_RESPONSE_CHARS) append("...")
+                }
+        }.trim()
+    }
+
+    fun local(message: String): String =
+        "Typ: błąd aplikacji\nKomunikat: $message"
+
+    private const val MAX_RESPONSE_CHARS = 1200
+}

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

@@ -0,0 +1,119 @@
+package pl.firmatpp.kierowca.data.upload
+
+import android.content.Context
+import android.net.Uri
+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.io.File
+import java.security.MessageDigest
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+import kotlinx.coroutines.flow.Flow
+import pl.firmatpp.kierowca.data.PhotoUploadMetadata
+import pl.firmatpp.kierowca.data.model.DriverRouteDto
+
+class PhotoUploadOutbox(
+    private val context: Context,
+    private val dao: PhotoUploadDao = DriverDatabase.get(context).photoUploadDao(),
+    private val workManager: WorkManager = WorkManager.getInstance(context),
+) {
+    fun observeVisibleForRoute(routeId: String): Flow<List<PhotoUploadEntity>> =
+        dao.observeVisibleForRoute(routeId)
+
+    fun observeQueuedUploads(): Flow<List<PhotoUploadEntity>> =
+        dao.observeQueuedUploads()
+
+    suspend fun enqueue(routeId: String, uri: Uri, source: String, metadata: PhotoUploadMetadata): PhotoUploadEntity {
+        val clientRequestId = UUID.randomUUID().toString()
+        val mimeType = context.contentResolver.getType(uri) ?: "image/jpeg"
+        val extension = when (mimeType) {
+            "image/png" -> "png"
+            "image/webp" -> "webp"
+            else -> "jpg"
+        }
+        val uploadDir = File(context.filesDir, "photo-upload-outbox").apply { mkdirs() }
+        val localFile = File(uploadDir, "$clientRequestId.$extension")
+        val sha256 = copyAndHash(uri, localFile)
+        val upload = PhotoUploadEntity(
+            clientRequestId = clientRequestId,
+            routeId = routeId,
+            localPath = localFile.absolutePath,
+            source = source,
+            takenAt = metadata.takenAt,
+            latitude = metadata.latitude,
+            longitude = metadata.longitude,
+            locationAccuracyMeters = metadata.locationAccuracyMeters,
+            mimeType = mimeType,
+            size = localFile.length(),
+            contentSha256 = sha256,
+        )
+
+        dao.upsert(upload)
+        enqueueWorker(clientRequestId)
+
+        return upload
+    }
+
+    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)
+    }
+
+    suspend fun discard(clientRequestId: String) {
+        dao.find(clientRequestId)?.let { upload ->
+            File(upload.localPath).delete()
+            dao.delete(upload.clientRequestId)
+        }
+    }
+
+    suspend fun discardConfirmedServerPhotos(route: DriverRouteDto) {
+        dao.confirmedForRoute(route.id).forEach { upload ->
+            File(upload.localPath).delete()
+            dao.delete(upload.clientRequestId)
+        }
+    }
+
+    private fun enqueueWorker(clientRequestId: String) {
+        val request = OneTimeWorkRequestBuilder<PhotoUploadWorker>()
+            .setInputData(workDataOf(PhotoUploadWorker.KEY_CLIENT_REQUEST_ID to clientRequestId))
+            .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build())
+            .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
+            .build()
+
+        workManager.enqueueUniqueWork(
+            PhotoUploadWorker.uniqueWorkName(clientRequestId),
+            ExistingWorkPolicy.REPLACE,
+            request,
+        )
+    }
+
+    private fun copyAndHash(uri: Uri, target: File): String {
+        val digest = MessageDigest.getInstance("SHA-256")
+        context.contentResolver.openInputStream(uri).use { input ->
+            requireNotNull(input) { "Nie można odczytać zdjęcia." }
+            target.outputStream().use { output ->
+                val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+                while (true) {
+                    val read = input.read(buffer)
+                    if (read == -1) break
+                    digest.update(buffer, 0, read)
+                    output.write(buffer, 0, read)
+                }
+            }
+        }
+        return digest.digest().joinToString("") { "%02x".format(it) }
+    }
+}

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

@@ -0,0 +1,9 @@
+package pl.firmatpp.kierowca.data.upload
+
+import pl.firmatpp.kierowca.data.model.PhotoUploadReceiptDto
+
+object PhotoUploadReceiptVerifier {
+    fun matches(upload: PhotoUploadEntity, receipt: PhotoUploadReceiptDto): Boolean =
+        receipt.clientRequestId == upload.clientRequestId &&
+            receipt.contentSha256.lowercase() == upload.contentSha256.lowercase()
+}

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

@@ -0,0 +1,20 @@
+package pl.firmatpp.kierowca.data.upload
+
+enum class PhotoUploadStatus(
+    val storageValue: String,
+    val label: String,
+    val isStoredOnServer: Boolean,
+) {
+    Pending("PENDING", "Czeka na wysłanie", false),
+    Uploading("UPLOADING", "Wysyłam zdjęcie", false),
+    Verifying("VERIFYING", "Sprawdzam zapis", false),
+    Confirmed("CONFIRMED", "Zapisane", true),
+    FailedRetryable("FAILED_RETRYABLE", "Nie wysłano, ponów", false),
+    FailedPermanent("FAILED_PERMANENT", "Zdjęcie nie zostało zapisane", false),
+    Cancelled("CANCELLED", "Anulowano", false);
+
+    companion object {
+        fun fromStorage(value: String): PhotoUploadStatus =
+            entries.firstOrNull { it.storageValue == value } ?: Pending
+    }
+}

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

@@ -0,0 +1,99 @@
+package pl.firmatpp.kierowca.data.upload
+
+import android.content.Context
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import androidx.work.workDataOf
+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.diagnostics.AppDiagnostics
+
+class PhotoUploadWorker(
+    appContext: Context,
+    params: WorkerParameters,
+) : CoroutineWorker(appContext, params) {
+    private val dao = DriverDatabase.get(appContext).photoUploadDao()
+    private val repository = DriverRepository(appContext)
+
+    override suspend fun doWork(): Result {
+        val clientRequestId = inputData.getString(KEY_CLIENT_REQUEST_ID) ?: return Result.failure()
+        val upload = dao.find(clientRequestId) ?: return Result.failure()
+        val file = File(upload.localPath)
+
+        if (!file.exists()) {
+            val message = "Lokalny plik zdjęcia nie istnieje. Zdjęcie nie zostało zapisane."
+            dao.updateStatus(
+                clientRequestId = clientRequestId,
+                status = PhotoUploadStatus.FailedPermanent.storageValue,
+                progress = 0,
+                lastError = PhotoUploadFailureDetails.local(message),
+                attemptIncrement = 0,
+            )
+            return Result.failure()
+        }
+
+        dao.updateStatus(
+            clientRequestId = clientRequestId,
+            status = PhotoUploadStatus.Uploading.storageValue,
+            progress = 10,
+            lastError = null,
+            attemptIncrement = 1,
+        )
+        setProgress(workDataOf(KEY_PROGRESS to 10))
+
+        return runCatching {
+            setProgress(workDataOf(KEY_PROGRESS to 70))
+            val response = repository.uploadQueuedPhoto(upload)
+
+            dao.updateStatus(
+                clientRequestId = clientRequestId,
+                status = PhotoUploadStatus.Verifying.storageValue,
+                progress = 90,
+                lastError = null,
+                attemptIncrement = 0,
+            )
+            setProgress(workDataOf(KEY_PROGRESS to 90))
+
+            val receipt = response.receipt
+            if (!PhotoUploadReceiptVerifier.matches(upload, receipt)) {
+                error("Serwer nie potwierdził zgodności zdjęcia. Zdjęcie nie zostało zapisane.")
+            }
+
+            dao.markConfirmed(clientRequestId, receipt.serverPhotoId)
+            Result.success()
+        }.getOrElse { throwable ->
+            val error = ApiErrorMapper.map(throwable)
+            AppDiagnostics.reportNonFatal(
+                throwable = throwable,
+                operation = "photo_upload_worker",
+                keys = mapOf(
+                    "client_request_id" to clientRequestId,
+                    "route_id" to upload.routeId,
+                    "api_error_kind" to error.kind.name,
+                    "api_error_code" to error.code,
+                    "api_status_code" to error.statusCode,
+                    "retryable" to error.retryable,
+                ),
+            )
+            val status = if (error.retryable) PhotoUploadStatus.FailedRetryable else PhotoUploadStatus.FailedPermanent
+            dao.updateStatus(
+                clientRequestId = clientRequestId,
+                status = status.storageValue,
+                progress = 0,
+                lastError = PhotoUploadFailureDetails.fromApiError(error),
+                attemptIncrement = 0,
+            )
+
+            if (error.retryable && error.kind != ApiErrorKind.Auth) Result.retry() else Result.failure()
+        }
+    }
+
+    companion object {
+        const val KEY_CLIENT_REQUEST_ID = "clientRequestId"
+        const val KEY_PROGRESS = "progress"
+
+        fun uniqueWorkName(clientRequestId: String): String = "photo-upload-$clientRequestId"
+    }
+}

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

@@ -0,0 +1,75 @@
+package pl.firmatpp.kierowca.diagnostics
+
+import com.google.firebase.crashlytics.FirebaseCrashlytics
+
+interface DiagnosticsSink {
+    fun log(message: String)
+    fun setUserId(userId: String)
+    fun setCustomKey(key: String, value: String)
+    fun recordException(throwable: Throwable)
+}
+
+object NoOpDiagnosticsSink : DiagnosticsSink {
+    override fun log(message: String) = Unit
+    override fun setUserId(userId: String) = Unit
+    override fun setCustomKey(key: String, value: String) = Unit
+    override fun recordException(throwable: Throwable) = Unit
+}
+
+class FirebaseCrashlyticsDiagnosticsSink(
+    private val crashlytics: FirebaseCrashlytics = FirebaseCrashlytics.getInstance(),
+) : DiagnosticsSink {
+    override fun log(message: String) {
+        crashlytics.log(message)
+    }
+
+    override fun setUserId(userId: String) {
+        crashlytics.setUserId(userId)
+    }
+
+    override fun setCustomKey(key: String, value: String) {
+        crashlytics.setCustomKey(key, value)
+    }
+
+    override fun recordException(throwable: Throwable) {
+        crashlytics.recordException(throwable)
+    }
+}
+
+object AppDiagnostics {
+    @Volatile
+    private var sink: DiagnosticsSink = NoOpDiagnosticsSink
+
+    fun installFirebaseCrashlytics() {
+        installSink(FirebaseCrashlyticsDiagnosticsSink())
+    }
+
+    fun installSink(nextSink: DiagnosticsSink) {
+        sink = nextSink
+    }
+
+    fun setDriverId(driverId: String) {
+        sink.setUserId(driverId)
+    }
+
+    fun clearDriverId() {
+        sink.setUserId("")
+    }
+
+    fun log(message: String) {
+        sink.log(message)
+    }
+
+    fun reportNonFatal(
+        throwable: Throwable,
+        operation: String,
+        keys: Map<String, Any?> = emptyMap(),
+    ) {
+        sink.setCustomKey("operation", operation)
+        keys.forEach { (key, value) ->
+            sink.setCustomKey(key, value?.toString().orEmpty())
+        }
+        sink.log("non_fatal: $operation: ${throwable.message ?: throwable::class.java.simpleName}")
+        sink.recordException(throwable)
+    }
+}

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

@@ -0,0 +1,57 @@
+package pl.firmatpp.kierowca.sync
+
+import com.google.firebase.messaging.FirebaseMessagingService
+import com.google.firebase.messaging.RemoteMessage
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import pl.firmatpp.kierowca.data.DriverRepository
+
+class DriverFirebaseMessagingService : FirebaseMessagingService() {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
+    override fun onNewToken(token: String) {
+        scope.launch {
+            val repository = DriverRepository(applicationContext)
+            if (repository.hasToken()) {
+                runCatching { repository.storePushToken(token) }
+            }
+        }
+    }
+
+    override fun onMessageReceived(message: RemoteMessage) {
+        val data = message.data
+        if (data["type"] == "driver_new_route_notification") {
+            NewRouteNotificationWorker.enqueue(
+                context = applicationContext,
+                routeId = data["routeId"],
+                date = data["date"],
+            )
+            return
+        }
+
+        if (data["type"] == "driver_leave_request_decision") {
+            LeaveRequestDecisionNotificationWorker.enqueue(
+                context = applicationContext,
+                leaveRequestId = data["leaveRequestId"],
+                title = data["title"],
+                body = data["body"],
+            )
+            DriverSyncWorker.enqueue(
+                context = applicationContext,
+                date = data["date"],
+                routeId = data["routeId"],
+            )
+            return
+        }
+
+        if (data["type"] != "driver_sync_hint") return
+
+        DriverSyncWorker.enqueue(
+            context = applicationContext,
+            date = data["date"],
+            routeId = data["routeId"],
+        )
+    }
+}

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

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

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

@@ -0,0 +1,21 @@
+package pl.firmatpp.kierowca.sync
+
+import pl.firmatpp.kierowca.data.model.SyncScopeDto
+
+data class DriverSyncHint(
+    val scope: String,
+    val date: String?,
+    val routeId: String?,
+    val version: Long,
+    val checksum: String,
+) {
+    fun asScope(): SyncScopeDto =
+        SyncScopeDto(
+            scope = scope,
+            date = date,
+            routeId = routeId,
+            version = version,
+            checksum = checksum,
+            computedAt = "",
+        )
+}

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

@@ -0,0 +1,99 @@
+package pl.firmatpp.kierowca.sync
+
+import android.content.Context
+import androidx.work.BackoffPolicy
+import androidx.work.Constraints
+import androidx.work.CoroutineWorker
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.WorkerParameters
+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.sync.DriverSyncRepository
+import pl.firmatpp.kierowca.diagnostics.AppDiagnostics
+
+class DriverSyncWorker(
+    appContext: Context,
+    params: WorkerParameters,
+) : CoroutineWorker(appContext, params) {
+    private val syncRepository = DriverSyncRepository(appContext)
+
+    override suspend fun doWork(): Result =
+        runCatching {
+            val date = inputData.getString(KEY_DATE)
+            val routeId = inputData.getString(KEY_ROUTE_ID)
+            val response = syncRepository.fetchSyncState(date, routeId)
+            var refreshed = false
+
+            response.scopes.forEach { scope ->
+                if (syncRepository.shouldRefresh(scope)) {
+                    when (scope.scope) {
+                        DriverSyncRepository.SCOPE_ROUTES -> {
+                            syncRepository.bootstrap(scope.date ?: date)
+                            refreshed = true
+                        }
+                        DriverSyncRepository.SCOPE_ROUTE_DETAIL -> {
+                            val id = scope.routeId ?: routeId
+                            if (!id.isNullOrBlank()) {
+                                syncRepository.route(id)
+                                refreshed = true
+                            }
+                        }
+                        DriverSyncRepository.SCOPE_SETTINGS,
+                        DriverSyncRepository.SCOPE_DISPATCH_SHEET -> {
+                            syncRepository.bootstrap(scope.date ?: date)
+                            refreshed = true
+                        }
+                        DriverSyncRepository.SCOPE_LEAVE_REQUESTS -> {
+                            syncRepository.saveSyncStates(response)
+                            refreshed = true
+                        }
+                    }
+                }
+            }
+
+            if (!refreshed) {
+                syncRepository.saveSyncStates(response)
+            }
+
+            Result.success()
+        }.getOrElse { throwable ->
+            val error = ApiErrorMapper.map(throwable)
+            AppDiagnostics.reportNonFatal(
+                throwable = throwable,
+                operation = "driver_sync_worker",
+                keys = mapOf(
+                    "date" to inputData.getString(KEY_DATE),
+                    "route_id" to inputData.getString(KEY_ROUTE_ID),
+                    "api_error_kind" to error.kind.name,
+                    "api_error_code" to error.code,
+                    "api_status_code" to error.statusCode,
+                    "retryable" to error.retryable,
+                ),
+            )
+            if (error.retryable && error.kind != ApiErrorKind.Auth) Result.retry() else Result.failure()
+        }
+
+    companion object {
+        private const val KEY_DATE = "date"
+        private const val KEY_ROUTE_ID = "routeId"
+
+        fun enqueue(context: Context, date: String?, routeId: String?) {
+            val request = OneTimeWorkRequestBuilder<DriverSyncWorker>()
+                .setInputData(workDataOf(KEY_DATE to date, KEY_ROUTE_ID to routeId))
+                .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,
+                request,
+            )
+        }
+    }
+}

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

@@ -0,0 +1,110 @@
+package pl.firmatpp.kierowca.sync
+
+import android.Manifest
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.ContextCompat
+import androidx.work.CoroutineWorker
+import androidx.work.ExistingWorkPolicy
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.WorkerParameters
+import androidx.work.workDataOf
+import pl.firmatpp.kierowca.MainActivity
+import pl.firmatpp.kierowca.R
+
+class LeaveRequestDecisionNotificationWorker(
+    appContext: Context,
+    params: WorkerParameters,
+) : CoroutineWorker(appContext, params) {
+    override suspend fun doWork(): Result {
+        val leaveRequestId = inputData.getString(KEY_LEAVE_REQUEST_ID)?.takeIf(String::isNotBlank)
+            ?: return Result.success()
+
+        if (!canShowNotifications(applicationContext)) {
+            return Result.success()
+        }
+
+        createChannel(applicationContext)
+        val title = inputData.getString(KEY_TITLE)?.takeIf(String::isNotBlank) ?: "Decyzja w sprawie urlopu"
+        val body = inputData.getString(KEY_BODY)?.takeIf(String::isNotBlank) ?: "Status wniosku urlopowego został zmieniony."
+        val intent = Intent(applicationContext, MainActivity::class.java).apply {
+            flags = Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP
+            putExtra(MainActivity.EXTRA_LEAVE_REQUEST_ID, leaveRequestId)
+        }
+        val pendingIntent = PendingIntent.getActivity(
+            applicationContext,
+            leaveRequestId.hashCode(),
+            intent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+        )
+
+        val notification = NotificationCompat.Builder(applicationContext, CHANNEL_ID)
+            .setSmallIcon(R.mipmap.ic_launcher)
+            .setContentTitle(title)
+            .setContentText(body)
+            .setStyle(NotificationCompat.BigTextStyle().bigText(body))
+            .setContentIntent(pendingIntent)
+            .setAutoCancel(true)
+            .setCategory(NotificationCompat.CATEGORY_STATUS)
+            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+            .build()
+
+        NotificationManagerCompat.from(applicationContext).notify(leaveRequestId.hashCode(), notification)
+        return Result.success()
+    }
+
+    private fun createChannel(context: Context) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+
+        val channel = NotificationChannel(
+            CHANNEL_ID,
+            "Wnioski urlopowe",
+            NotificationManager.IMPORTANCE_DEFAULT,
+        ).apply {
+            description = "Powiadomienia o decyzjach w sprawie wniosków urlopowych."
+        }
+        context.getSystemService(NotificationManager::class.java)?.createNotificationChannel(channel)
+    }
+
+    private fun canShowNotifications(context: Context): Boolean {
+        val hasRuntimePermission = Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU ||
+            ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED
+
+        return hasRuntimePermission && NotificationManagerCompat.from(context).areNotificationsEnabled()
+    }
+
+    companion object {
+        private const val CHANNEL_ID = "leave_request_decisions"
+        private const val KEY_LEAVE_REQUEST_ID = "leaveRequestId"
+        private const val KEY_TITLE = "title"
+        private const val KEY_BODY = "body"
+
+        fun enqueue(context: Context, leaveRequestId: String?, title: String?, body: String?) {
+            if (leaveRequestId.isNullOrBlank()) return
+
+            val request = OneTimeWorkRequestBuilder<LeaveRequestDecisionNotificationWorker>()
+                .setInputData(
+                    workDataOf(
+                        KEY_LEAVE_REQUEST_ID to leaveRequestId,
+                        KEY_TITLE to title,
+                        KEY_BODY to body,
+                    ),
+                )
+                .build()
+
+            WorkManager.getInstance(context).enqueueUniqueWork(
+                "driver-leave-request-decision-$leaveRequestId",
+                ExistingWorkPolicy.REPLACE,
+                request,
+            )
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+package pl.firmatpp.kierowca.sync
+
+import java.time.LocalDate
+import java.util.Locale
+import java.time.DayOfWeek
+import java.time.format.DateTimeFormatter
+import pl.firmatpp.kierowca.data.model.DriverRouteDto
+
+object NewRouteNotificationFormatter {
+    private val polishLocale = Locale("pl", "PL")
+    private val monthFormatter = DateTimeFormatter.ofPattern("d MMMM", polishLocale)
+
+    fun title(routeDate: String?, today: LocalDate = LocalDate.now()): String {
+        val label = humanDate(routeDate, today) ?: return "Nowy kurs"
+
+        return "Nowy kurs: $label"
+    }
+
+    fun collapsedText(route: DriverRouteDto): String =
+        listOf(route.originName, route.destinationName)
+            .filter(String::isNotBlank)
+            .joinToString(" → ")
+            .ifBlank { route.relationLabel }
+            .let { relation ->
+                val contract = route.contractName?.takeIf(String::isNotBlank) ?: route.contractCode
+                if (contract.isNullOrBlank()) relation else "$relation · $contract"
+            }
+
+    fun expandedText(route: DriverRouteDto): String {
+        val contract = route.contractName?.takeIf(String::isNotBlank) ?: route.contractCode ?: "Brak nazwy kontraktu"
+
+        return listOf(
+            "Skąd: ${route.originName.ifBlank { "Nie podano" }}",
+            "Dokąd: ${route.destinationName.ifBlank { "Nie podano" }}",
+            "Kontrakt: $contract",
+        ).joinToString("\n")
+    }
+
+    private fun humanDate(routeDate: String?, today: LocalDate): String? {
+        val date = runCatching { routeDate?.let(LocalDate::parse) }.getOrNull() ?: return null
+
+        return when {
+            date == today -> "dzisiaj"
+            date == today.plusDays(1) -> "jutro"
+            date.isAfter(today.plusDays(1)) && !date.isAfter(today.plusDays(7)) ->
+                "w ${weekdayAccusative(date.dayOfWeek)}"
+            else -> date.format(monthFormatter).lowercase(polishLocale)
+        }
+    }
+
+    private fun weekdayAccusative(dayOfWeek: DayOfWeek): String =
+        when (dayOfWeek) {
+            DayOfWeek.MONDAY -> "poniedziałek"
+            DayOfWeek.TUESDAY -> "wtorek"
+            DayOfWeek.WEDNESDAY -> "środę"
+            DayOfWeek.THURSDAY -> "czwartek"
+            DayOfWeek.FRIDAY -> "piątek"
+            DayOfWeek.SATURDAY -> "sobotę"
+            DayOfWeek.SUNDAY -> "niedzielę"
+        }
+}

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

@@ -0,0 +1,137 @@
+package pl.firmatpp.kierowca.sync
+
+import android.Manifest
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.ContextCompat
+import androidx.work.BackoffPolicy
+import androidx.work.Constraints
+import androidx.work.CoroutineWorker
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.WorkerParameters
+import androidx.work.workDataOf
+import java.util.concurrent.TimeUnit
+import pl.firmatpp.kierowca.MainActivity
+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.diagnostics.AppDiagnostics
+import retrofit2.HttpException
+
+class NewRouteNotificationWorker(
+    appContext: Context,
+    params: WorkerParameters,
+) : CoroutineWorker(appContext, params) {
+    private val repository = DriverRepository(appContext)
+
+    override suspend fun doWork(): Result {
+        val routeId = inputData.getString(KEY_ROUTE_ID)?.takeIf(String::isNotBlank) ?: return Result.success()
+
+        return runCatching {
+            val route = repository.route(routeId).route
+            if (!canShowNotifications(applicationContext)) {
+                return@runCatching Result.success()
+            }
+
+            createChannel(applicationContext)
+            val contentTitle = NewRouteNotificationFormatter.title(route.routeDate ?: inputData.getString(KEY_DATE))
+            val contentText = NewRouteNotificationFormatter.collapsedText(route)
+            val expandedText = NewRouteNotificationFormatter.expandedText(route)
+            val intent = Intent(applicationContext, MainActivity::class.java).apply {
+                flags = Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP
+                putExtra(MainActivity.EXTRA_ROUTE_ID, route.id)
+            }
+            val pendingIntent = PendingIntent.getActivity(
+                applicationContext,
+                route.id.hashCode(),
+                intent,
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+            )
+
+            val notification = NotificationCompat.Builder(applicationContext, CHANNEL_ID)
+                .setSmallIcon(R.mipmap.ic_launcher)
+                .setContentTitle(contentTitle)
+                .setContentText(contentText)
+                .setStyle(NotificationCompat.BigTextStyle().bigText(expandedText))
+                .setContentIntent(pendingIntent)
+                .setAutoCancel(true)
+                .setCategory(NotificationCompat.CATEGORY_REMINDER)
+                .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+                .build()
+
+            NotificationManagerCompat.from(applicationContext).notify(route.id.hashCode(), notification)
+            Result.success()
+        }.getOrElse { throwable ->
+            if (throwable is HttpException && throwable.code() == 404) {
+                Result.success()
+            } else {
+                val error = ApiErrorMapper.map(throwable)
+                AppDiagnostics.reportNonFatal(
+                    throwable = throwable,
+                    operation = "new_route_notification_worker",
+                    keys = mapOf(
+                        "route_id" to routeId,
+                        "api_error_kind" to error.kind.name,
+                        "api_error_code" to error.code,
+                        "api_status_code" to error.statusCode,
+                        "retryable" to error.retryable,
+                    ),
+                )
+                if (error.retryable && error.kind != ApiErrorKind.Auth) Result.retry() else Result.success()
+            }
+        }
+    }
+
+    private fun createChannel(context: Context) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+
+        val channel = NotificationChannel(
+            CHANNEL_ID,
+            "Nowe kursy",
+            NotificationManager.IMPORTANCE_DEFAULT,
+        ).apply {
+            description = "Powiadomienia o nowych kursach dodanych przez spedytora."
+        }
+        context.getSystemService(NotificationManager::class.java)?.createNotificationChannel(channel)
+    }
+
+    private fun canShowNotifications(context: Context): Boolean {
+        val hasRuntimePermission = Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU ||
+            ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED
+
+        return hasRuntimePermission && NotificationManagerCompat.from(context).areNotificationsEnabled()
+    }
+
+    companion object {
+        private const val CHANNEL_ID = "new_routes"
+        private const val KEY_ROUTE_ID = "routeId"
+        private const val KEY_DATE = "date"
+
+        fun enqueue(context: Context, routeId: String?, date: String?) {
+            if (routeId.isNullOrBlank()) return
+
+            val request = OneTimeWorkRequestBuilder<NewRouteNotificationWorker>()
+                .setInputData(workDataOf(KEY_ROUTE_ID to routeId, KEY_DATE to date))
+                .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build())
+                .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
+                .build()
+
+            WorkManager.getInstance(context).enqueueUniqueWork(
+                "driver-new-route-notification-$routeId",
+                ExistingWorkPolicy.REPLACE,
+                request,
+            )
+        }
+    }
+}

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

@@ -0,0 +1,55 @@
+package pl.firmatpp.kierowca.ui
+
+import java.time.LocalDate
+
+data class LeaveRequestsConfig(
+    val enabled: Boolean = false,
+    val types: List<String> = listOf("URLOP"),
+)
+
+object DriverLeaveRequestUiRules {
+    fun isFeatureVisible(config: LeaveRequestsConfig?): Boolean =
+        config?.enabled == true && config.types.isNotEmpty()
+
+    fun statusLabel(status: String): String =
+        when (status) {
+            "pending" -> "Oczekuje"
+            "approved" -> "Zatwierdzony"
+            "rejected" -> "Odrzucony"
+            "cancel_requested" -> "Anulowanie do decyzji"
+            "cancelled" -> "Anulowany"
+            "revoked" -> "Cofnięto decyzję"
+            else -> "Nieznany status"
+        }
+
+    fun eventActionLabel(action: String): String =
+        when (action) {
+            "submitted" -> "Wniosek złożony"
+            "approved" -> "Wniosek zatwierdzony"
+            "rejected" -> "Wniosek odrzucony"
+            "revoked" -> "Decyzja cofnięta"
+            "cancelled_by_driver" -> "Wniosek anulowany przez kierowcę"
+            "cancellation_requested" -> "Kierowca poprosił o anulowanie"
+            "cancellation_approved" -> "Anulowanie zatwierdzone"
+            "cancellation_rejected" -> "Anulowanie odrzucone"
+            else -> "Aktualizacja wniosku"
+        }
+
+    fun typeLabel(type: String): String =
+        when (type) {
+            "URLOP" -> "Urlop"
+            "CHOROBOWE" -> "Chorobowe"
+            "SZKOLENIE" -> "Szkolenie"
+            "WOLNE" -> "Dzień wolny"
+            "INNE" -> "Inne"
+            else -> type
+        }
+
+    fun canCancel(status: String, dateFrom: String, today: LocalDate = LocalDate.now()): Boolean {
+        if (status == "pending") return true
+        if (status != "approved") return false
+
+        val start = runCatching { LocalDate.parse(dateFrom) }.getOrNull() ?: return false
+        return start.isAfter(today)
+    }
+}

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

@@ -0,0 +1,167 @@
+package pl.firmatpp.kierowca.ui
+
+import java.io.File
+import java.time.DayOfWeek
+import java.time.LocalDate
+import java.time.OffsetDateTime
+import java.time.format.DateTimeFormatter
+import java.time.temporal.ChronoUnit
+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
+
+private val shortDateFormatter: DateTimeFormatter = DateTimeFormatter.ofPattern("dd.MM")
+
+fun canManageRoutePhotos(selectedDate: String, today: LocalDate = LocalDate.now()): Boolean =
+    runCatching { LocalDate.parse(selectedDate).isEqual(today) }.getOrDefault(false)
+
+fun canCompleteRouteFromDriverApp(
+    route: DriverRouteDto,
+    selectedDate: String,
+    today: LocalDate = LocalDate.now(),
+): Boolean =
+    canManageRoutePhotos(selectedDate, today)
+        && route.status in setOf("ZAPLANOWANA", "W TRAKCIE")
+
+fun shouldShowRouteDayLiveUpdate(viewedDate: String, hintDate: String?): Boolean =
+    viewedDate.isNotBlank() && (hintDate == null || hintDate == viewedDate)
+
+fun routeDateChipLabel(routeDate: String?, today: LocalDate = LocalDate.now()): String {
+    val date = routeDate
+        ?.takeIf { it.isNotBlank() }
+        ?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
+        ?: return "—"
+
+    val fallback = date.format(shortDateFormatter)
+    val days = ChronoUnit.DAYS.between(today, date)
+    val human = when {
+        days == 0L -> "dzisiaj"
+        days == 1L -> "jutro"
+        days in 2L..7L -> polishWeekdayPhrase(date.dayOfWeek)
+        else -> null
+    }
+
+    return human?.let { "$it · $fallback" } ?: fallback
+}
+
+private fun polishWeekdayPhrase(day: DayOfWeek): String =
+    when (day) {
+        DayOfWeek.MONDAY -> "w poniedziałek"
+        DayOfWeek.TUESDAY -> "we wtorek"
+        DayOfWeek.WEDNESDAY -> "w środę"
+        DayOfWeek.THURSDAY -> "w czwartek"
+        DayOfWeek.FRIDAY -> "w piątek"
+        DayOfWeek.SATURDAY -> "w sobotę"
+        DayOfWeek.SUNDAY -> "w niedzielę"
+    }
+
+fun inlinePhotoGridRows(photoCount: Int): Int =
+    if (photoCount <= 0) 0 else (photoCount + 1) / 2
+
+fun authBrandBannerHeightDp(screenHeightDp: Int): Int =
+    when {
+        screenHeightDp < 640 -> 118
+        screenHeightDp < 740 -> 150
+        else -> 190
+    }
+
+fun appBrandHeaderHeightDp(screenHeightDp: Int): Int =
+    when {
+        screenHeightDp < 640 -> 92
+        screenHeightDp < 740 -> 108
+        else -> 124
+    }
+
+fun bottomNavigationHeightDp(screenHeightDp: Int): Int =
+    when {
+        screenHeightDp < 640 -> 72
+        screenHeightDp < 740 -> 78
+        else -> 82
+    }
+
+fun screenHorizontalPaddingDp(screenWidthDp: Int): Int =
+    when {
+        screenWidthDp < 360 -> 14
+        screenWidthDp < 420 -> 16
+        else -> 20
+    }
+
+fun phonePrefixWidthDp(screenWidthDp: Int): Int =
+    when {
+        screenWidthDp < 360 -> 70
+        screenWidthDp < 420 -> 82
+        else -> 94
+    }
+
+fun routeFactColumns(screenWidthDp: Int): Int =
+    if (screenWidthDp < 360) 1 else 2
+
+fun visiblePhotoAttachmentCount(serverPhotoCount: Int, localUploadCount: Int): Int =
+    serverPhotoCount.coerceAtLeast(0) + localUploadCount.coerceAtLeast(0)
+
+fun queuedPhotoUploadCount(statuses: List<String>): Int =
+    statuses.count { status -> status != "CONFIRMED" && status != "CANCELLED" }
+
+fun routePhotoSortEpochMillis(createdAt: String?, takenAt: String?, fallback: Long): Long =
+    parseIsoOffsetEpochMillis(createdAt)
+        ?: parseIsoOffsetEpochMillis(takenAt)
+        ?: fallback
+
+fun confirmedUploadServerPhotoId(status: String, serverPhotoId: String?): String? =
+    serverPhotoId?.takeIf { status == "CONFIRMED" && it.isNotBlank() }
+
+fun canRetryPhotoUpload(status: String): Boolean =
+    status == "FAILED_RETRYABLE"
+
+fun canShowPhotoUploadFailureDetails(status: String, lastError: String?): Boolean =
+    status in setOf("FAILED_RETRYABLE", "FAILED_PERMANENT") && !lastError.isNullOrBlank()
+
+fun localUploadPreviewPhoto(upload: PhotoUploadEntity): RoutePhotoDto? {
+    if (upload.localPath.isBlank()) return null
+
+    return RoutePhotoDto(
+        id = upload.clientRequestId,
+        routeId = upload.routeId,
+        clientRequestId = upload.clientRequestId,
+        contentSha256 = upload.contentSha256,
+        source = upload.source,
+        mimeType = upload.mimeType,
+        size = upload.size,
+        url = File(upload.localPath).toURI().toString(),
+        takenAt = upload.takenAt,
+        latitude = upload.latitude,
+        longitude = upload.longitude,
+        locationAccuracyMeters = upload.locationAccuracyMeters,
+        createdAt = null,
+        canDelete = confirmedUploadServerPhotoId(upload.status, upload.serverPhotoId) != null,
+        deleteUntil = null,
+    )
+}
+
+fun canLaunchCameraWithLocationPolicy(requirePreciseLocation: Boolean, hasFineLocation: Boolean): Boolean =
+    !requirePreciseLocation || hasFineLocation
+
+fun shouldShowDispatchSheetReminderCard(reminder: DispatchSheetReminderDto?): Boolean =
+    reminder?.dueToday == true && reminder.status in setOf("missing", "uploaded")
+
+fun dispatchSheetPrimaryActionLabel(reminder: DispatchSheetReminderDto?, hasQueuedUpload: Boolean): String =
+    when {
+        hasQueuedUpload -> "Wysyłam zdjęcie..."
+        reminder?.status == "uploaded" -> "Popraw"
+        else -> "Zrób zdjęcie"
+    }
+
+fun offlineStaleBannerMessage(isOnline: Boolean, isStale: Boolean, syncLabel: String): String? =
+    when {
+        isOnline && !isStale -> null
+        !isOnline && syncLabel == "brak zapisanej synchronizacji" ->
+            "Brak połączenia z serwerem. Sprawdź internet i spróbuj ponownie."
+        !isOnline -> "Brak połączenia z serwerem. Dane z $syncLabel mogą być nieaktualne."
+        else -> "Dane mogą być nieaktualne. Ostatnia synchronizacja: $syncLabel."
+    }
+
+private fun parseIsoOffsetEpochMillis(value: String?): Long? =
+    value?.takeIf { it.isNotBlank() }?.let {
+        runCatching { OffsetDateTime.parse(it).toInstant().toEpochMilli() }.getOrNull()
+    }

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

@@ -4,21 +4,40 @@ import android.app.Application
 import android.net.Uri
 import androidx.lifecycle.AndroidViewModel
 import androidx.lifecycle.viewModelScope
+import com.google.firebase.messaging.FirebaseMessaging
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import java.time.LocalDate
+import pl.firmatpp.kierowca.data.AppPreferencesStore
+import pl.firmatpp.kierowca.data.ApiErrorMapper
+import pl.firmatpp.kierowca.data.ApiErrorKind
 import pl.firmatpp.kierowca.data.DriverRepository
+import pl.firmatpp.kierowca.data.PhotoUploadMetadata
+import pl.firmatpp.kierowca.data.sync.DriverSyncRepository
+import pl.firmatpp.kierowca.data.sync.NetworkMonitor
+import pl.firmatpp.kierowca.data.model.DispatchSheetReminderDto
 import pl.firmatpp.kierowca.data.model.DriverDto
+import pl.firmatpp.kierowca.data.model.DriverLeaveRequestDto
 import pl.firmatpp.kierowca.data.model.DriverRouteDto
 import pl.firmatpp.kierowca.data.model.RoutePhotoDto
+import pl.firmatpp.kierowca.data.upload.DispatchSheetUploadEntity
+import pl.firmatpp.kierowca.data.upload.DispatchSheetUploadOutbox
+import pl.firmatpp.kierowca.data.upload.PhotoUploadEntity
+import pl.firmatpp.kierowca.data.upload.PhotoUploadOutbox
+import pl.firmatpp.kierowca.diagnostics.AppDiagnostics
+import pl.firmatpp.kierowca.sync.DriverLiveSyncClient
+import pl.firmatpp.kierowca.sync.DriverSyncHint
+import pl.firmatpp.kierowca.sync.DriverSyncWorker
+import pl.firmatpp.kierowca.ui.theme.AppThemeMode
 
-enum class DriverScreen { Phone, Otp, Routes, Profile, Detail, Photo }
+enum class DriverScreen { Initializing, Phone, Otp, Routes, Profile, Detail, Photo, PhotoQueue, LeaveRequests, LeaveRequestDetail, AddLeaveRequest }
 
 data class DriverUiState(
-    val screen: DriverScreen = DriverScreen.Phone,
+    val screen: DriverScreen = DriverScreen.Initializing,
-    val loading: Boolean = false,
+    val loading: Boolean = true,
     val refreshing: Boolean = false,
     val phone: String = "",
     val otpCode: String = "",
@@ -30,25 +49,116 @@ data class DriverUiState(
     val maxRouteDate: String = LocalDate.now().plusDays(1).toString(),
     val autoRefreshSeconds: Int = 60,
     val allowGalleryUploads: Boolean = true,
+    val allowRouteCompletion: Boolean = false,
+    val requirePreciseLocationForPhotos: Boolean = false,
+    val notifyNewRoutes: Boolean = false,
+    val notificationPermissionDenied: Boolean = false,
     val selectedRoute: DriverRouteDto? = null,
     val selectedPhoto: RoutePhotoDto? = null,
+    val photoUploads: List<PhotoUploadEntity> = emptyList(),
+    val queuedPhotoUploads: List<PhotoUploadEntity> = emptyList(),
+    val dispatchSheetReminder: DispatchSheetReminderDto? = null,
+    val dispatchSheetUploads: List<DispatchSheetUploadEntity> = emptyList(),
+    val leaveRequestsConfig: LeaveRequestsConfig? = null,
+    val leaveRequests: List<DriverLeaveRequestDto> = emptyList(),
+    val selectedLeaveRequest: DriverLeaveRequestDto? = null,
+    val leaveRequestDateFrom: String = LocalDate.now().toString(),
+    val leaveRequestDateTo: String = LocalDate.now().toString(),
+    val leaveRequestType: String = "URLOP",
+    val leaveRequestNote: String = "",
+    val deletingPhotoIds: Set<String> = emptySet(),
+    val completingRoute: Boolean = false,
     val imageAuthHeader: String? = null,
+    val isOnline: Boolean = true,
+    val isStale: Boolean = false,
+    val lastSuccessfulSyncAtEpochMillis: Long? = null,
+    val routeDayLiveUpdateMessage: String? = null,
+    val themeMode: AppThemeMode = AppThemeMode.Default,
+    val feedback: String? = null,
     val error: String? = null,
 )
 
+private fun DriverUiState.withApiError(throwable: Throwable): DriverUiState {
+    val apiError = ApiErrorMapper.map(throwable)
+    return copy(
+        isOnline = if (apiError.kind == ApiErrorKind.Network) false else isOnline,
+        isStale = if (apiError.kind == ApiErrorKind.Network && lastSuccessfulSyncAtEpochMillis != null) true else isStale,
+        error = apiError.message,
+    )
+}
+
+internal fun DriverUiState.withLoadedLeaveRequests(
+    requests: List<DriverLeaveRequestDto>,
+    navigateToList: Boolean,
+): DriverUiState {
+    val refreshedSelectedRequest = selectedLeaveRequest?.let { selected ->
+        requests.firstOrNull { request -> request.id == selected.id } ?: selected
+    }
+    return copy(
+        screen = if (navigateToList) DriverScreen.LeaveRequests else screen,
+        leaveRequests = requests,
+        selectedLeaveRequest = refreshedSelectedRequest,
+        error = null,
+    )
+}
+
 class DriverViewModel(application: Application) : AndroidViewModel(application) {
+    private val appPreferencesStore = AppPreferencesStore(application)
     private val repository = DriverRepository(application)
+    private val syncRepository = DriverSyncRepository(application, repository)
+    private val networkMonitor = NetworkMonitor(application)
+    private val photoUploadOutbox = PhotoUploadOutbox(application)
+    private val dispatchSheetUploadOutbox = DispatchSheetUploadOutbox(application)
     private val _state = MutableStateFlow(DriverUiState(loading = true))
+    private val otpAutoSubmitPolicy = OtpAutoSubmitPolicy()
+    private val liveSyncClient = DriverLiveSyncClient(
+        repository = repository,
+        onConnected = { viewModelScope.launch { checkRemoteSyncState() } },
+        onHint = { hint -> viewModelScope.launch { handleSyncHint(hint) } },
+    )
+    private var photoUploadsJob: Job? = null
+    private var dispatchSheetUploadsJob: Job? = null
+    private var pushTokenRegisteredForDriverId: String? = null
     val state: StateFlow<DriverUiState> = _state
 
     init {
         viewModelScope.launch {
-            if (repository.hasToken()) refreshRoutes() else _state.update { it.copy(loading = false) }
+            appPreferencesStore.themeMode.collect { themeMode ->
+                _state.update { it.copy(themeMode = themeMode) }
+            }
+        }
+        viewModelScope.launch {
+            photoUploadOutbox.observeQueuedUploads().collect { uploads ->
+                _state.update { it.copy(queuedPhotoUploads = uploads) }
+            }
+        }
+        viewModelScope.launch {
+            networkMonitor.isOnline.collect { online ->
+                liveSyncClient.onNetworkAvailable(online)
+                _state.update {
+                    it.copy(
+                        isOnline = online,
+                        isStale = if (!online && it.lastSuccessfulSyncAtEpochMillis != null) true else it.isStale,
+                    )
+                }
+                if (online && repository.hasToken()) {
+                    liveSyncClient.ensureConnected()
+                    refreshCurrentScopeFromSyncState()
+                }
+            }
+        }
+        viewModelScope.launch {
+            if (repository.hasToken()) {
+                refreshRoutes()
+            } else {
+                _state.update { it.copy(screen = DriverScreen.Phone, loading = false) }
+            }
         }
     }
 
-    fun requestOtp(phone: String) = runLoading {
+    fun requestOtp(phone: String) = runLoading("request_otp") {
         val response = repository.requestOtp(phone)
+        otpAutoSubmitPolicy.reset()
         _state.update {
             it.copy(
                 screen = DriverScreen.Otp,
@@ -60,45 +170,96 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         }
     }
 
-    fun verifyOtp(code: String) = runLoading {
+    fun verifyOtp(code: String) = runLoading("verify_otp") {
         val driver = repository.verifyOtp(_state.value.phone, code, android.os.Build.MODEL ?: "Android")
+        AppDiagnostics.setDriverId(driver.id)
         _state.update { it.copy(driver = driver, imageAuthHeader = repository.imageAuthHeader()) }
         refreshRoutes()
     }
 
     fun updateOtpCode(code: String) {
-        _state.update { it.copy(otpCode = code.filter(Char::isDigit).take(10)) }
+        val sanitized = code.filter(Char::isDigit).take(6)
+        _state.update { it.copy(otpCode = sanitized) }
+
+        if (otpAutoSubmitPolicy.shouldSubmit(sanitized, _state.value.loading)) {
+            verifyOtp(sanitized)
+        }
     }
 
     fun refreshRoutes() = loadRoutes(date = _state.value.selectedDate, showLoading = true, navigateToRoutes = true)
 
     fun refreshRoutesSilently() = loadRoutes(date = _state.value.selectedDate, showLoading = false, navigateToRoutes = false)
 
-    fun selectRouteDate(date: String) = loadRoutes(date = date, showLoading = true, navigateToRoutes = true)
+    fun onAppForegrounded() {
+        liveSyncClient.ensureConnected()
+        viewModelScope.launch { checkRemoteSyncState() }
+        if (_state.value.screen == DriverScreen.Routes) {
+            refreshRoutesSilently()
+        }
+    }
+
+    fun selectRouteDate(date: String) {
+        _state.update { it.copy(routeDayLiveUpdateMessage = null) }
+        loadRoutes(date = date, showLoading = true, navigateToRoutes = true)
+    }
+
+    fun dismissRouteDayLiveUpdate() {
+        _state.update { it.copy(routeDayLiveUpdateMessage = null) }
+    }
 
     private fun loadRoutes(date: String?, showLoading: Boolean, navigateToRoutes: Boolean) {
         viewModelScope.launch {
-            _state.update { it.copy(loading = showLoading, refreshing = !showLoading, error = null) }
+            _state.update { it.copy(loading = showLoading, refreshing = !showLoading, feedback = null, error = null) }
 
             runCatching {
-                val response = repository.bootstrap(date)
+                val cached = syncRepository.bootstrap(date)
+                val response = cached.value
                 val settings = response.driverAppSettings
+                AppDiagnostics.setDriverId(response.session.driver.id)
                 _state.update {
                     it.copy(
-                        screen = if (navigateToRoutes) DriverScreen.Routes else it.screen,
                         driver = response.session.driver,
                         routes = response.routes.today,
+                        dispatchSheetReminder = response.dispatchSheetReminder,
                         selectedDate = settings?.selectedDate ?: date ?: it.selectedDate,
                         minRouteDate = settings?.minDate ?: it.minRouteDate,
                         maxRouteDate = settings?.maxDate ?: it.maxRouteDate,
                         autoRefreshSeconds = settings?.autoRefreshSeconds ?: it.autoRefreshSeconds,
                         allowGalleryUploads = settings?.allowGalleryUploads ?: it.allowGalleryUploads,
+                        allowRouteCompletion = settings?.allowRouteCompletion ?: it.allowRouteCompletion,
+                        requirePreciseLocationForPhotos = settings?.requirePreciseLocationForPhotos
+                            ?: it.requirePreciseLocationForPhotos,
+                        leaveRequestsConfig = settings?.leaveRequests?.let { config ->
+                            LeaveRequestsConfig(enabled = config.enabled, types = config.types)
+                        },
+                        screen = if (
+                            settings?.leaveRequests?.enabled != true &&
+                            it.screen in setOf(DriverScreen.LeaveRequests, DriverScreen.LeaveRequestDetail, DriverScreen.AddLeaveRequest)
+                        ) DriverScreen.Routes else if (navigateToRoutes) DriverScreen.Routes else it.screen,
+                        notifyNewRoutes = response.notificationPreferences?.notifyNewRoutes ?: it.notifyNewRoutes,
                         imageAuthHeader = repository.imageAuthHeader(),
+                        isStale = cached.stale || !it.isOnline,
+                        lastSuccessfulSyncAtEpochMillis = cached.syncedAtEpochMillis ?: it.lastSuccessfulSyncAtEpochMillis,
                         error = null,
                     )
                 }
+                response.session.driver.id.let { driverId ->
+                    liveSyncClient.start(driverId, response.realtime)
+                    registerPushTokenIfAvailable(driverId)
+                }
+                observeDispatchSheetUploads(response.dispatchSheetReminder?.workDate)
             }.onFailure { throwable ->
-                _state.update { it.copy(error = throwable.message ?: "Wystapil blad.") }
+                reportHandledException("load_routes", throwable, mapOf("date" to date))
+                _state.update {
+                    val apiError = ApiErrorMapper.map(throwable)
+                    it.withApiError(throwable).copy(
+                        screen = when {
+                            apiError.kind == ApiErrorKind.Auth -> DriverScreen.Phone
+                            it.screen == DriverScreen.Initializing -> DriverScreen.Routes
+                            else -> it.screen
+                        },
+                    )
+                }
             }
 
             _state.update {
@@ -107,30 +268,359 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         }
     }
 
-    fun openRoute(routeId: String) = runLoading {
+    fun openRoute(routeId: String) = runLoading("open_route", mapOf("route_id" to routeId)) {
-        val response = repository.route(routeId)
+        val cached = syncRepository.route(routeId)
-        _state.update { it.copy(screen = DriverScreen.Detail, selectedRoute = response.route, error = null) }
+        val response = cached.value
+        photoUploadOutbox.discardConfirmedServerPhotos(response.route)
+        _state.update {
+            it.copy(
+                screen = DriverScreen.Detail,
+                selectedRoute = response.route,
+                feedback = null,
+                isStale = cached.stale || !it.isOnline,
+                lastSuccessfulSyncAtEpochMillis = cached.syncedAtEpochMillis ?: it.lastSuccessfulSyncAtEpochMillis,
+                error = null,
+            )
+        }
+        observePhotoUploads(routeId)
+    }
+
+    fun refreshSelectedRoute() {
+        val routeId = _state.value.selectedRoute?.id ?: return
+
+        viewModelScope.launch {
+            _state.update { it.copy(refreshing = true, feedback = null, error = null) }
+
+            runCatching { syncRepository.route(routeId) }
+                .onSuccess { cached ->
+                    val response = cached.value
+                    photoUploadOutbox.discardConfirmedServerPhotos(response.route)
+                    _state.update {
+                        it.copy(
+                            selectedRoute = response.route,
+                            routes = it.routes.map { route -> if (route.id == routeId) response.route else route },
+                            isStale = cached.stale || !it.isOnline,
+                            lastSuccessfulSyncAtEpochMillis = cached.syncedAtEpochMillis ?: it.lastSuccessfulSyncAtEpochMillis,
+                            error = null,
+                        )
+                    }
+                }
+                .onFailure { throwable ->
+                    _state.update { it.withApiError(throwable) }
+                }
+
+            _state.update { it.copy(refreshing = false) }
+        }
     }
 
     fun openProfile() {
         _state.update { it.copy(screen = DriverScreen.Profile, error = null) }
     }
 
-    fun uploadPhoto(uri: Uri, source: String) = runLoading {
+    fun updateNewRouteNotifications(enabled: Boolean) {
-        val route = _state.value.selectedRoute ?: return@runLoading
+        viewModelScope.launch {
-        repository.uploadPhoto(route.id, uri, source)
+            _state.update { it.copy(refreshing = true, error = null, notificationPermissionDenied = false) }
-        openRoute(route.id)
+            runCatching { repository.updateNotificationPreferences(enabled) }
+                .onSuccess { preferences ->
+                    _state.update {
+                        it.copy(
+                            notifyNewRoutes = preferences.notifyNewRoutes,
+                            feedback = if (preferences.notifyNewRoutes) "Powiadomienia o nowych kursach są włączone." else "Powiadomienia o nowych kursach są wyłączone.",
+                            error = null,
+                        )
+                    }
+                }
+                .onFailure { throwable ->
+                    _state.update { it.withApiError(throwable) }
+                }
+            _state.update { it.copy(refreshing = false) }
+        }
+    }
+
+    fun markNotificationPermissionDenied() {
+        _state.update {
+            it.copy(
+                notifyNewRoutes = false,
+                notificationPermissionDenied = true,
+                error = "Aby otrzymywać powiadomienia o nowych kursach, włącz powiadomienia w ustawieniach aplikacji.",
+            )
+        }
+    }
+
+    fun setThemeMode(themeMode: AppThemeMode) {
+        _state.update { it.copy(themeMode = themeMode) }
+        viewModelScope.launch {
+            runCatching { appPreferencesStore.setThemeMode(themeMode) }
+                .onFailure { throwable -> _state.update { it.withApiError(throwable) } }
+        }
+    }
+
+    fun openPhotoQueue() {
+        _state.update { it.copy(screen = DriverScreen.PhotoQueue, error = null) }
+    }
+
+    fun openLeaveRequests() {
+        if (!DriverLeaveRequestUiRules.isFeatureVisible(_state.value.leaveRequestsConfig)) return
+        loadLeaveRequests(showLoading = true, navigateToList = true)
+    }
+
+    fun refreshLeaveRequests() {
+        if (!DriverLeaveRequestUiRules.isFeatureVisible(_state.value.leaveRequestsConfig)) return
+        loadLeaveRequests(showLoading = false, navigateToList = false)
+    }
+
+    private fun loadLeaveRequests(showLoading: Boolean, navigateToList: Boolean) {
+        viewModelScope.launch {
+            _state.update { it.copy(loading = showLoading, refreshing = !showLoading, error = null, feedback = null) }
+            runCatching { repository.leaveRequests() }
+                .onSuccess { requests ->
+                    _state.update { it.withLoadedLeaveRequests(requests, navigateToList) }
+                }
+                .onFailure { throwable -> _state.update { it.withApiError(throwable) } }
+            _state.update { it.copy(loading = false, refreshing = false) }
+        }
+    }
+
+    fun openLeaveRequest(id: String) {
+        if (!DriverLeaveRequestUiRules.isFeatureVisible(_state.value.leaveRequestsConfig)) return
+        viewModelScope.launch {
+            _state.update { it.copy(loading = true, error = null, feedback = null) }
+            runCatching { repository.leaveRequest(id) }
+                .onSuccess { request ->
+                    _state.update { it.copy(screen = DriverScreen.LeaveRequestDetail, selectedLeaveRequest = request, error = null) }
+                }
+                .onFailure { throwable -> _state.update { it.withApiError(throwable) } }
+            _state.update { it.copy(loading = false) }
+        }
+    }
+
+    fun openAddLeaveRequest() {
+        val config = _state.value.leaveRequestsConfig
+        if (!DriverLeaveRequestUiRules.isFeatureVisible(config)) return
+        val today = LocalDate.now().toString()
+        _state.update {
+            it.copy(
+                screen = DriverScreen.AddLeaveRequest,
+                leaveRequestDateFrom = today,
+                leaveRequestDateTo = today,
+                leaveRequestType = config?.types?.firstOrNull() ?: "URLOP",
+                leaveRequestNote = "",
+                error = null,
+                feedback = null,
+            )
+        }
+    }
+
+    fun updateLeaveRequestDraft(dateFrom: String? = null, dateTo: String? = null, type: String? = null, note: String? = null) {
+        _state.update {
+            val nextFrom = dateFrom ?: it.leaveRequestDateFrom
+            val nextTo = dateTo ?: it.leaveRequestDateTo
+            it.copy(
+                leaveRequestDateFrom = nextFrom,
+                leaveRequestDateTo = if (nextTo < nextFrom) nextFrom else nextTo,
+                leaveRequestType = type ?: it.leaveRequestType,
+                leaveRequestNote = note ?: it.leaveRequestNote,
+            )
+        }
+    }
+
+    fun submitLeaveRequest() {
+        val snapshot = _state.value
+        if (!DriverLeaveRequestUiRules.isFeatureVisible(snapshot.leaveRequestsConfig)) return
+        if (snapshot.leaveRequestDateFrom < LocalDate.now().toString()) {
+            _state.update { it.copy(error = "Data od nie może być z przeszłości.") }
+            return
+        }
+
+        viewModelScope.launch {
+            _state.update { it.copy(loading = true, error = null, feedback = null) }
+            runCatching {
+                repository.createLeaveRequest(
+                    dateFrom = snapshot.leaveRequestDateFrom,
+                    dateTo = snapshot.leaveRequestDateTo,
+                    type = snapshot.leaveRequestType,
+                    note = snapshot.leaveRequestNote.takeIf { it.isNotBlank() },
+                )
+            }.onSuccess { created ->
+                val requests = runCatching { repository.leaveRequests() }.getOrElse { listOf(created) }
+                _state.update {
+                    it.copy(
+                        screen = DriverScreen.LeaveRequestDetail,
+                        selectedLeaveRequest = created,
+                        leaveRequests = requests,
+                        feedback = "Wniosek został wysłany do decyzji.",
+                        error = null,
+                    )
+                }
+            }.onFailure { throwable ->
+                _state.update { it.withApiError(throwable) }
+            }
+            _state.update { it.copy(loading = false) }
+        }
+    }
+
+    fun cancelSelectedLeaveRequest() {
+        val request = _state.value.selectedLeaveRequest ?: return
+        if (!DriverLeaveRequestUiRules.canCancel(request.status, request.dateFrom.orEmpty())) return
+
+        viewModelScope.launch {
+            _state.update { it.copy(loading = true, error = null, feedback = null) }
+            runCatching { repository.cancelLeaveRequest(request.id) }
+                .onSuccess { updated ->
+                    _state.update {
+                        it.copy(
+                            selectedLeaveRequest = updated,
+                            leaveRequests = it.leaveRequests.map { existing -> if (existing.id == updated.id) updated else existing },
+                            feedback = if (updated.status == "cancel_requested") "Anulowanie wysłane do decyzji." else "Wniosek został anulowany.",
+                            error = null,
+                        )
+                    }
+                }
+                .onFailure { throwable -> _state.update { it.withApiError(throwable) } }
+            _state.update { it.copy(loading = false) }
+        }
+    }
+
+    fun uploadPhoto(uri: Uri, source: String, metadata: PhotoUploadMetadata = PhotoUploadMetadata()) {
+        val route = _state.value.selectedRoute ?: return
+        viewModelScope.launch {
+            _state.update { it.copy(error = null) }
+            runCatching { photoUploadOutbox.enqueue(route.id, uri, source, metadata) }
+                .onFailure { throwable ->
+                    _state.update { it.withApiError(throwable) }
+                }
+        }
+    }
+
+    fun uploadDispatchSheetPhoto(uri: Uri, source: String, metadata: PhotoUploadMetadata = PhotoUploadMetadata()) {
+        val reminder = _state.value.dispatchSheetReminder ?: return
+        val workDate = reminder.workDate ?: return
+        if (!reminder.canUpload) return
+
+        viewModelScope.launch {
+            _state.update { it.copy(error = null) }
+            runCatching {
+                dispatchSheetUploadOutbox.enqueue(
+                    workDate = workDate,
+                    replacePhotoId = reminder.photo?.id,
+                    uri = uri,
+                    source = source,
+                    metadata = metadata,
+                )
+            }.onFailure { throwable ->
+                _state.update { it.withApiError(throwable) }
+            }
+        }
+    }
+
+    fun retryPhotoUpload(upload: PhotoUploadEntity) {
+        viewModelScope.launch {
+            runCatching { photoUploadOutbox.retry(upload.clientRequestId) }
+                .onFailure { throwable ->
+                    _state.update { it.withApiError(throwable) }
+                }
+        }
+    }
+
+    fun deletePhoto(photo: RoutePhotoDto) {
+        val route = _state.value.selectedRoute ?: return
+        viewModelScope.launch {
+            _state.update { it.copy(deletingPhotoIds = it.deletingPhotoIds + photo.id, error = null) }
+            runCatching {
+                repository.deletePhoto(photo.id)
+                val response = syncRepository.route(route.id).value
+                photoUploadOutbox.discardConfirmedServerPhotos(response.route)
+                _state.update {
+                    it.copy(
+                        selectedRoute = response.route,
+                        routes = it.routes.map { item -> if (item.id == route.id) response.route else item },
+                        error = null,
+                    )
+                }
+            }.onFailure { throwable ->
+                _state.update { it.withApiError(throwable) }
+            }
+            _state.update { it.copy(deletingPhotoIds = it.deletingPhotoIds - photo.id) }
+        }
+    }
+
+    fun deleteConfirmedUpload(upload: PhotoUploadEntity) {
+        val route = _state.value.selectedRoute ?: return
+        val serverPhotoId = confirmedUploadServerPhotoId(upload.status, upload.serverPhotoId) ?: return
+
+        viewModelScope.launch {
+            _state.update { it.copy(deletingPhotoIds = it.deletingPhotoIds + serverPhotoId, error = null) }
+            runCatching {
+                repository.deletePhoto(serverPhotoId)
+                photoUploadOutbox.discard(upload.clientRequestId)
+                val response = syncRepository.route(route.id).value
+                photoUploadOutbox.discardConfirmedServerPhotos(response.route)
+                _state.update {
+                    it.copy(
+                        selectedRoute = response.route,
+                        routes = it.routes.map { item -> if (item.id == route.id) response.route else item },
+                        error = null,
+                    )
+                }
+            }.onFailure { throwable ->
+                _state.update { it.withApiError(throwable) }
+            }
+            _state.update { it.copy(deletingPhotoIds = it.deletingPhotoIds - serverPhotoId) }
+        }
+    }
+
+    fun completeSelectedRoute() {
+        val route = _state.value.selectedRoute ?: return
+        if (_state.value.completingRoute || !_state.value.isOnline) return
+
+        viewModelScope.launch {
+            _state.update { it.copy(completingRoute = true, feedback = null, error = null) }
+            runCatching {
+                val completed = repository.completeRoute(route.id).route
+                syncRepository.cacheConfirmedRoute(completed, _state.value.selectedDate)
+                val refreshed = runCatching { syncRepository.route(route.id) }
+                    .getOrNull()
+                    ?.takeUnless { it.stale }
+                    ?.value
+                    ?.route
+                    ?: completed
+                photoUploadOutbox.discardConfirmedServerPhotos(refreshed)
+                _state.update {
+                    it.copy(
+                        selectedRoute = refreshed,
+                        routes = it.routes.map { item -> if (item.id == route.id) refreshed else item },
+                        feedback = "Kurs zakończony",
+                        error = null,
+                    )
+                }
+            }.onFailure { throwable ->
+                _state.update { it.withApiError(throwable).copy(feedback = null) }
+            }
+            _state.update { it.copy(completingRoute = false) }
+        }
     }
 
     fun openPhoto(photo: RoutePhotoDto) {
         _state.update { it.copy(screen = DriverScreen.Photo, selectedPhoto = photo) }
     }
 
+    fun openRouteFromNotification(routeId: String?) {
+        if (routeId.isNullOrBlank()) return
+        openRoute(routeId)
+    }
+
     fun back() {
         _state.update {
             when (it.screen) {
                 DriverScreen.Photo -> it.copy(screen = DriverScreen.Detail, selectedPhoto = null)
-                DriverScreen.Detail -> it.copy(screen = DriverScreen.Routes, selectedRoute = null)
+                DriverScreen.PhotoQueue -> it.copy(screen = DriverScreen.Routes)
+                DriverScreen.LeaveRequests -> it.copy(screen = DriverScreen.Routes)
+                DriverScreen.LeaveRequestDetail -> it.copy(screen = DriverScreen.LeaveRequests, selectedLeaveRequest = null, feedback = null)
+                DriverScreen.AddLeaveRequest -> it.copy(screen = DriverScreen.LeaveRequests, feedback = null)
+                DriverScreen.Detail -> {
+                    photoUploadsJob?.cancel()
+                    it.copy(screen = DriverScreen.Routes, selectedRoute = null, photoUploads = emptyList(), feedback = null)
+                }
                 DriverScreen.Profile -> it.copy(screen = DriverScreen.Routes)
                 DriverScreen.Otp -> it.copy(screen = DriverScreen.Phone)
                 else -> it
@@ -138,19 +628,164 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         }
     }
 
-    fun logout() = runLoading {
+    fun logout() = runLoading("logout") {
+        photoUploadsJob?.cancel()
+        dispatchSheetUploadsJob?.cancel()
+        liveSyncClient.stop()
         repository.logout()
-        _state.update { DriverUiState(screen = DriverScreen.Phone) }
+        syncRepository.clearCache()
+        pushTokenRegisteredForDriverId = null
+        AppDiagnostics.clearDriverId()
+        _state.update { DriverUiState(screen = DriverScreen.Phone, loading = false) }
     }
 
-    private fun runLoading(block: suspend () -> Unit) {
+    private fun runLoading(
+        operation: String,
+        keys: Map<String, Any?> = emptyMap(),
+        block: suspend () -> Unit,
+    ) {
         viewModelScope.launch {
             _state.update { it.copy(loading = true, error = null) }
             runCatching { block() }
                 .onFailure { throwable ->
-                    _state.update { it.copy(error = throwable.message ?: "Wystapil blad.") }
+                    reportHandledException(operation, throwable, keys)
+                    _state.update { it.withApiError(throwable) }
                 }
             _state.update { it.copy(loading = false) }
         }
     }
+
+    private fun observePhotoUploads(routeId: String) {
+        photoUploadsJob?.cancel()
+        photoUploadsJob = viewModelScope.launch {
+            photoUploadOutbox.observeVisibleForRoute(routeId).collect { uploads ->
+                _state.update { it.copy(photoUploads = uploads) }
+            }
+        }
+    }
+
+    private fun observeDispatchSheetUploads(workDate: String?) {
+        dispatchSheetUploadsJob?.cancel()
+        if (workDate.isNullOrBlank()) {
+            _state.update { it.copy(dispatchSheetUploads = emptyList()) }
+            return
+        }
+
+        dispatchSheetUploadsJob = viewModelScope.launch {
+            dispatchSheetUploadOutbox.observeVisibleForWorkDate(workDate).collect { uploads ->
+                _state.update { it.copy(dispatchSheetUploads = uploads) }
+            }
+        }
+    }
+
+    private fun refreshCurrentScopeFromSyncState() {
+        val snapshot = _state.value
+        if (snapshot.screen == DriverScreen.Routes) {
+            refreshRoutesSilently()
+            return
+        }
+        if (snapshot.screen == DriverScreen.Detail) {
+            refreshSelectedRoute()
+        }
+        if (snapshot.screen == DriverScreen.LeaveRequests || snapshot.screen == DriverScreen.LeaveRequestDetail) {
+            refreshLeaveRequests()
+        }
+    }
+
+    private suspend fun checkRemoteSyncState() {
+        val snapshot = _state.value
+        val routeId = snapshot.selectedRoute?.id
+        val remote = runCatching { syncRepository.fetchSyncState(snapshot.selectedDate, routeId) }.getOrNull() ?: return
+        val needsRefresh = remote.scopes.any { syncRepository.shouldRefresh(it) }
+
+        if (needsRefresh) {
+            refreshCurrentScopeFromSyncState()
+        } else {
+            syncRepository.saveSyncStates(remote)
+        }
+    }
+
+    private suspend fun handleSyncHint(hint: DriverSyncHint) {
+        if (!syncRepository.shouldRefresh(hint.asScope())) return
+
+        val snapshot = _state.value
+        when (hint.scope) {
+            DriverSyncRepository.SCOPE_ROUTES -> {
+                if (shouldShowRouteDayLiveUpdate(snapshot.selectedDate, hint.date)) {
+                    refreshRoutesSilently()
+                    if (snapshot.screen == DriverScreen.Routes) {
+                        _state.update {
+                            it.copy(routeDayLiveUpdateMessage = "Spedytor zaktualizował zlecenia dla tego dnia.")
+                        }
+                    }
+                } else {
+                    DriverSyncWorker.enqueue(getApplication(), hint.date, null)
+                }
+            }
+            DriverSyncRepository.SCOPE_ROUTE_DETAIL -> {
+                if (hint.routeId == snapshot.selectedRoute?.id) {
+                    refreshSelectedRoute()
+                } else {
+                    DriverSyncWorker.enqueue(getApplication(), hint.date, hint.routeId)
+                }
+            }
+            DriverSyncRepository.SCOPE_SETTINGS -> refreshRoutesSilently()
+            DriverSyncRepository.SCOPE_DISPATCH_SHEET -> refreshRoutesSilently()
+            DriverSyncRepository.SCOPE_LEAVE_REQUESTS -> {
+                if (snapshot.screen == DriverScreen.LeaveRequests || snapshot.screen == DriverScreen.LeaveRequestDetail) {
+                    refreshLeaveRequests()
+                }
+            }
+        }
+    }
+
+    private fun registerPushTokenIfAvailable(driverId: String) {
+        if (pushTokenRegisteredForDriverId == driverId) return
+
+        runCatching {
+            FirebaseMessaging.getInstance().token.addOnSuccessListener { token ->
+                viewModelScope.launch {
+                    runCatching {
+                        repository.storePushToken(token)
+                        pushTokenRegisteredForDriverId = driverId
+                    }.onFailure { throwable ->
+                        reportHandledException("store_push_token", throwable, mapOf("driver_id" to driverId))
+                    }
+                }
+            }.addOnFailureListener { throwable ->
+                reportHandledException("get_push_token", throwable, mapOf("driver_id" to driverId))
+            }
+        }.onFailure { throwable ->
+            reportHandledException("register_push_token", throwable, mapOf("driver_id" to driverId))
+        }
+    }
+
+    private fun reportHandledException(
+        operation: String,
+        throwable: Throwable,
+        keys: Map<String, Any?> = emptyMap(),
+    ) {
+        val apiError = ApiErrorMapper.map(throwable)
+        if (!ApiErrorMapper.shouldReportNonFatal(throwable)) {
+            AppDiagnostics.log("network_failure: $operation: ${throwable.message ?: throwable::class.java.simpleName}")
+            return
+        }
+        AppDiagnostics.reportNonFatal(
+            throwable = throwable,
+            operation = operation,
+            keys = mapOf(
+                "screen" to _state.value.screen.name,
+                "api_error_kind" to apiError.kind.name,
+                "api_error_code" to apiError.code,
+                "api_status_code" to apiError.statusCode,
+                "retryable" to apiError.retryable,
+            ) + keys,
+        )
+    }
+
+    override fun onCleared() {
+        liveSyncClient.close()
+        dispatchSheetUploadsJob?.cancel()
+        super.onCleared()
+    }
 }

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

@@ -0,0 +1,27 @@
+package pl.firmatpp.kierowca.ui
+
+class OtpAutoSubmitPolicy {
+    private var lastSubmittedCode: String? = null
+
+    fun shouldSubmit(code: String, loading: Boolean): Boolean {
+        if (code.length < OTP_LENGTH) {
+            lastSubmittedCode = null
+            return false
+        }
+
+        if (loading || code.length != OTP_LENGTH || code == lastSubmittedCode) {
+            return false
+        }
+
+        lastSubmittedCode = code
+        return true
+    }
+
+    fun reset() {
+        lastSubmittedCode = null
+    }
+
+    private companion object {
+        const val OTP_LENGTH = 6
+    }
+}

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

@@ -0,0 +1,38 @@
+package pl.firmatpp.kierowca.ui
+
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.input.OffsetMapping
+import androidx.compose.ui.text.input.TransformedText
+import androidx.compose.ui.text.input.VisualTransformation
+
+object PolishPhoneNumberVisualTransformation : VisualTransformation {
+    override fun filter(text: AnnotatedString): TransformedText {
+        val rawDigits = text.text.filter(Char::isDigit).take(9)
+        val formatted = rawDigits.chunked(3).joinToString(" ")
+
+        return TransformedText(
+            AnnotatedString(formatted),
+            object : OffsetMapping {
+                override fun originalToTransformed(offset: Int): Int {
+                    val safeOffset = offset.coerceIn(0, rawDigits.length)
+                    val spacesBeforeOffset = when {
+                        safeOffset <= 3 -> 0
+                        safeOffset <= 6 -> 1
+                        else -> 2
+                    }
+
+                    return (safeOffset + spacesBeforeOffset).coerceAtMost(formatted.length)
+                }
+
+                override fun transformedToOriginal(offset: Int): Int {
+                    val safeOffset = offset.coerceIn(0, formatted.length)
+
+                    return formatted
+                        .take(safeOffset)
+                        .count(Char::isDigit)
+                        .coerceAtMost(rawDigits.length)
+                }
+            },
+        )
+    }
+}

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

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

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

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

app/src/main/res/drawable/ic_launcher_background.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector
+    android:height="108dp"
+    android:width="108dp"
+    android:viewportHeight="108"
+    android:viewportWidth="108"
+    xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#FFFFFF"
+          android:pathData="M0,0h108v108h-108z"/>
+</vector>

app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background"/>
+    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+    <monochrome android:drawable="@mipmap/ic_launcher_monochrome"/>
+</adaptive-icon>

app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background"/>
+    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+    <monochrome android:drawable="@mipmap/ic_launcher_monochrome"/>
+</adaptive-icon>

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

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="ic_launcher_background">#0B192E</color>
+</resources>

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

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <string name="app_name">TPP Kierowca</string>
+    <string name="app_name">Firma TPP - Kierowca</string>
 </resources>

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

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

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

@@ -0,0 +1,72 @@
+package pl.firmatpp.kierowca.data
+
+import java.io.IOException
+import java.net.UnknownHostException
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ApiErrorMapperTest {
+    @Test
+    fun mapsNetworkFailuresToRetryableOfflineMessage() {
+        val error = ApiErrorMapper.map(IOException("timeout"))
+
+        assertEquals(ApiErrorKind.Network, error.kind)
+        assertTrue(error.retryable)
+        assertEquals("Nie udało się połączyć z serwerem. Operacja nie została potwierdzona.", error.message)
+    }
+
+    @Test
+    fun mapsUnknownHostToActionableOfflineMessage() {
+        val error = ApiErrorMapper.map(UnknownHostException("api-intranet.firmatpp.pl"))
+
+        assertEquals(ApiErrorKind.Network, error.kind)
+        assertTrue(error.retryable)
+        assertEquals(
+            "Brak internetu lub połączenia z serwerem. Sprawdź zasięg i spróbuj ponownie.",
+            error.message,
+        )
+    }
+
+    @Test
+    fun doesNotReportExpectedNetworkFailuresAsNonFatal() {
+        assertFalse(ApiErrorMapper.shouldReportNonFatal(UnknownHostException("api-intranet.firmatpp.pl")))
+    }
+
+    @Test
+    fun mapsMobileApiProblemCodes() {
+        val error = ApiErrorMapper.mapProblem(
+            statusCode = 422,
+            code = "PHOTO_IDEMPOTENCY_CONFLICT",
+            message = "Ten upload został już użyty dla innego zdjęcia.",
+            retryable = false,
+        )
+
+        assertEquals(ApiErrorKind.Validation, error.kind)
+        assertFalse(error.retryable)
+        assertEquals("PHOTO_IDEMPOTENCY_CONFLICT", error.code)
+        assertEquals("Ten upload został już użyty dla innego zdjęcia.", error.message)
+    }
+
+    @Test
+    fun mapsServerErrorsToRetryableUnconfirmedMessage() {
+        val error = ApiErrorMapper.mapHttpStatus(503, null)
+
+        assertEquals(ApiErrorKind.Server, error.kind)
+        assertTrue(error.retryable)
+        assertEquals("Serwer nie potwierdził operacji. Aplikacja spróbuje ponownie.", error.message)
+    }
+
+    @Test
+    fun keepsRawServerResponseForTroubleshooting() {
+        val body = """{"code":"PHOTO_SERVER_UNAVAILABLE","message":"Storage timeout","retryable":true}"""
+        val error = ApiErrorMapper.mapHttpStatus(503, body)
+
+        assertEquals(ApiErrorKind.Server, error.kind)
+        assertEquals(503, error.statusCode)
+        assertEquals("PHOTO_SERVER_UNAVAILABLE", error.code)
+        assertEquals("Storage timeout", error.message)
+        assertEquals(body, error.responseBody)
+    }
+}

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

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

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

@@ -0,0 +1,38 @@
+package pl.firmatpp.kierowca.data
+
+import okio.Buffer
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Test
+
+class PhotoUploadMetadataTest {
+    @Test
+    fun convertsPresentCameraMetadataToMultipartTextParts() {
+        val parts = PhotoUploadMetadata(
+            takenAt = "2026-06-30T07:38:12Z",
+            latitude = 50.0619474,
+            longitude = 19.9368564,
+            locationAccuracyMeters = 8.5,
+        ).toMultipartTextParts()
+
+        assertEquals("2026-06-30T07:38:12Z", parts.getValue("takenAt").readUtf8())
+        assertEquals("50.0619474", parts.getValue("latitude").readUtf8())
+        assertEquals("19.9368564", parts.getValue("longitude").readUtf8())
+        assertEquals("8.5", parts.getValue("locationAccuracyMeters").readUtf8())
+    }
+
+    @Test
+    fun skipsLocationPartsWhenMetadataIsEmpty() {
+        val parts = PhotoUploadMetadata().toMultipartTextParts()
+
+        assertFalse(parts.containsKey("latitude"))
+        assertFalse(parts.containsKey("longitude"))
+        assertFalse(parts.containsKey("locationAccuracyMeters"))
+    }
+
+    private fun okhttp3.RequestBody.readUtf8(): String {
+        val buffer = Buffer()
+        writeTo(buffer)
+        return buffer.readUtf8()
+    }
+}

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

@@ -0,0 +1,65 @@
+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.DispatchSheetUploadReceiptDto
+
+class DispatchSheetUploadReceiptVerifierTest {
+    private val upload = DispatchSheetUploadEntity(
+        clientRequestId = "6f7a7d10-b7f7-41ab-8f5e-f1afc3e93736",
+        workDate = "2026-07-03",
+        replacePhotoId = "12",
+        localPath = "/tmp/dispatch-sheet.jpg",
+        source = "camera",
+        takenAt = null,
+        latitude = null,
+        longitude = null,
+        locationAccuracyMeters = null,
+        mimeType = "image/jpeg",
+        size = 1200,
+        contentSha256 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+    )
+
+    @Test
+    fun confirmsOnlyMatchingReceipt() {
+        assertTrue(
+            DispatchSheetUploadReceiptVerifier.matches(
+                upload,
+                DispatchSheetUploadReceiptDto(
+                    clientRequestId = upload.clientRequestId,
+                    serverPhotoId = "55",
+                    contentSha256 = upload.contentSha256.uppercase(),
+                    storedAt = "2026-07-03T17:02:00+02:00",
+                ),
+            ),
+        )
+    }
+
+    @Test
+    fun rejectsDifferentRequestOrHash() {
+        assertFalse(
+            DispatchSheetUploadReceiptVerifier.matches(
+                upload,
+                DispatchSheetUploadReceiptDto(
+                    clientRequestId = "other",
+                    serverPhotoId = "55",
+                    contentSha256 = upload.contentSha256,
+                    storedAt = null,
+                ),
+            ),
+        )
+
+        assertFalse(
+            DispatchSheetUploadReceiptVerifier.matches(
+                upload,
+                DispatchSheetUploadReceiptDto(
+                    clientRequestId = upload.clientRequestId,
+                    serverPhotoId = "55",
+                    contentSha256 = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+                    storedAt = null,
+                ),
+            ),
+        )
+    }
+}

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

@@ -0,0 +1,44 @@
+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.ApiError
+import pl.firmatpp.kierowca.data.ApiErrorKind
+
+class PhotoUploadFailureDetailsTest {
+    @Test
+    fun describesServerFailureWithStatusCodeBackendCodeAndResponseBody() {
+        val details = PhotoUploadFailureDetails.fromApiError(
+            ApiError(
+                kind = ApiErrorKind.Server,
+                message = "Storage timeout",
+                retryable = true,
+                code = "PHOTO_STORAGE_FAILED",
+                statusCode = 503,
+                responseBody = """{"code":"PHOTO_STORAGE_FAILED","message":"Storage timeout"}""",
+            ),
+        )
+
+        assertTrue(details.contains("Typ: błąd serwera"))
+        assertTrue(details.contains("HTTP: 503"))
+        assertTrue(details.contains("Kod: PHOTO_STORAGE_FAILED"))
+        assertTrue(details.contains("Odpowiedź serwera:"))
+        assertTrue(details.contains("Storage timeout"))
+    }
+
+    @Test
+    fun describesNetworkFailureWithoutHttpStatus() {
+        val details = PhotoUploadFailureDetails.fromApiError(
+            ApiError(
+                kind = ApiErrorKind.Network,
+                message = "Nie udało się połączyć z serwerem.",
+                retryable = true,
+            ),
+        )
+
+        assertTrue(details.contains("Typ: błąd komunikacji"))
+        assertTrue(details.contains("Nie udało się połączyć z serwerem."))
+        assertFalse(details.contains("HTTP:"))
+    }
+}

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

@@ -0,0 +1,64 @@
+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.PhotoUploadReceiptDto
+
+class PhotoUploadReceiptVerifierTest {
+    private val upload = PhotoUploadEntity(
+        clientRequestId = "6f7a7d10-b7f7-41ab-8f5e-f1afc3e93736",
+        routeId = "10",
+        localPath = "/tmp/photo.jpg",
+        source = "camera",
+        takenAt = null,
+        latitude = null,
+        longitude = null,
+        locationAccuracyMeters = null,
+        mimeType = "image/jpeg",
+        size = 1200,
+        contentSha256 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+    )
+
+    @Test
+    fun confirmsOnlyMatchingReceipt() {
+        assertTrue(
+            PhotoUploadReceiptVerifier.matches(
+                upload,
+                PhotoUploadReceiptDto(
+                    clientRequestId = upload.clientRequestId,
+                    serverPhotoId = "55",
+                    contentSha256 = upload.contentSha256.uppercase(),
+                    storedAt = "2026-07-01T10:00:00+02:00",
+                ),
+            ),
+        )
+    }
+
+    @Test
+    fun rejectsDifferentRequestOrHash() {
+        assertFalse(
+            PhotoUploadReceiptVerifier.matches(
+                upload,
+                PhotoUploadReceiptDto(
+                    clientRequestId = "other",
+                    serverPhotoId = "55",
+                    contentSha256 = upload.contentSha256,
+                    storedAt = null,
+                ),
+            ),
+        )
+
+        assertFalse(
+            PhotoUploadReceiptVerifier.matches(
+                upload,
+                PhotoUploadReceiptDto(
+                    clientRequestId = upload.clientRequestId,
+                    serverPhotoId = "55",
+                    contentSha256 = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+                    storedAt = null,
+                ),
+            ),
+        )
+    }
+}

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

@@ -0,0 +1,29 @@
+package pl.firmatpp.kierowca.data.upload
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class PhotoUploadStatusTest {
+    @Test
+    fun onlyConfirmedStatusIsStoredOnServer() {
+        assertFalse(PhotoUploadStatus.Pending.isStoredOnServer)
+        assertFalse(PhotoUploadStatus.Uploading.isStoredOnServer)
+        assertFalse(PhotoUploadStatus.Verifying.isStoredOnServer)
+        assertFalse(PhotoUploadStatus.FailedRetryable.isStoredOnServer)
+        assertFalse(PhotoUploadStatus.FailedPermanent.isStoredOnServer)
+        assertFalse(PhotoUploadStatus.Cancelled.isStoredOnServer)
+        assertTrue(PhotoUploadStatus.Confirmed.isStoredOnServer)
+    }
+
+    @Test
+    fun statusLabelsMakeUnconfirmedStateExplicit() {
+        assertEquals("Czeka na wysłanie", PhotoUploadStatus.Pending.label)
+        assertEquals("Wysyłam zdjęcie", PhotoUploadStatus.Uploading.label)
+        assertEquals("Sprawdzam zapis", PhotoUploadStatus.Verifying.label)
+        assertEquals("Nie wysłano, ponów", PhotoUploadStatus.FailedRetryable.label)
+        assertEquals("Zdjęcie nie zostało zapisane", PhotoUploadStatus.FailedPermanent.label)
+        assertEquals("Zapisane", PhotoUploadStatus.Confirmed.label)
+    }
+}

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

@@ -0,0 +1,71 @@
+package pl.firmatpp.kierowca.diagnostics
+
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertSame
+import org.junit.Test
+
+class AppDiagnosticsTest {
+    private val sink = RecordingDiagnosticsSink()
+
+    @After
+    fun tearDown() {
+        AppDiagnostics.installSink(NoOpDiagnosticsSink)
+    }
+
+    @Test
+    fun reportNonFatalAddsOperationContextBeforeRecordingException() {
+        AppDiagnostics.installSink(sink)
+        val throwable = IllegalStateException("upload failed")
+
+        AppDiagnostics.reportNonFatal(
+            throwable = throwable,
+            operation = "photo_upload",
+            keys = mapOf("route_id" to "R-42", "retryable" to true),
+        )
+
+        assertEquals(
+            listOf(
+                "key:operation=photo_upload",
+                "key:route_id=R-42",
+                "key:retryable=true",
+                "log:non_fatal: photo_upload: upload failed",
+                "exception:IllegalStateException",
+            ),
+            sink.events,
+        )
+        assertSame(throwable, sink.throwables.single())
+    }
+
+    @Test
+    fun clearDriverIdClearsPreviouslySetUserIdentifier() {
+        AppDiagnostics.installSink(sink)
+
+        AppDiagnostics.setDriverId("driver-7")
+        AppDiagnostics.clearDriverId()
+
+        assertEquals(listOf("user:driver-7", "user:"), sink.events)
+    }
+
+    private class RecordingDiagnosticsSink : DiagnosticsSink {
+        val events = mutableListOf<String>()
+        val throwables = mutableListOf<Throwable>()
+
+        override fun log(message: String) {
+            events += "log:$message"
+        }
+
+        override fun setUserId(userId: String) {
+            events += "user:$userId"
+        }
+
+        override fun setCustomKey(key: String, value: String) {
+            events += "key:$key=$value"
+        }
+
+        override fun recordException(throwable: Throwable) {
+            events += "exception:${throwable::class.simpleName}"
+            throwables += throwable
+        }
+    }
+}

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

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

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

@@ -0,0 +1,46 @@
+package pl.firmatpp.kierowca.sync
+
+import java.time.LocalDate
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import pl.firmatpp.kierowca.data.model.DriverRouteDto
+
+class NewRouteNotificationFormatterTest {
+    @Test
+    fun formatsHumanRouteDates() {
+        val today = LocalDate.of(2026, 7, 2)
+
+        assertEquals("Nowy kurs: dzisiaj", NewRouteNotificationFormatter.title("2026-07-02", today))
+        assertEquals("Nowy kurs: jutro", NewRouteNotificationFormatter.title("2026-07-03", today))
+        assertEquals("Nowy kurs: w sobotę", NewRouteNotificationFormatter.title("2026-07-04", today))
+        assertEquals("Nowy kurs: 12 lipca", NewRouteNotificationFormatter.title("2026-07-12", today))
+    }
+
+    @Test
+    fun formatsCollapsedAndExpandedRouteText() {
+        val route = DriverRouteDto(
+            id = "42",
+            routeDate = "2026-07-03",
+            startsAt = "09:15",
+            originName = "TPP Baza Krakow",
+            destinationName = "Instalacja Odpadowa Slask",
+            contractorName = "TPP Baza Krakow",
+            contractName = "Odpady przemyslowe",
+            contractCode = "TPP-ODP-24",
+            relationLabel = "TPP Baza Krakow -> Instalacja Odpadowa Slask",
+            status = "ZAPLANOWANA",
+            distanceKm = 91.4,
+            notes = null,
+            truck = null,
+        )
+
+        assertEquals(
+            "TPP Baza Krakow → Instalacja Odpadowa Slask · Odpady przemyslowe",
+            NewRouteNotificationFormatter.collapsedText(route),
+        )
+        assertTrue(NewRouteNotificationFormatter.expandedText(route).contains("Skąd: TPP Baza Krakow"))
+        assertTrue(NewRouteNotificationFormatter.expandedText(route).contains("Dokąd: Instalacja Odpadowa Slask"))
+        assertTrue(NewRouteNotificationFormatter.expandedText(route).contains("Kontrakt: Odpady przemyslowe"))
+    }
+}

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

@@ -0,0 +1,51 @@
+package pl.firmatpp.kierowca.ui
+
+import java.time.LocalDate
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class DriverLeaveRequestUiRulesTest {
+    @Test
+    fun featureIsVisibleOnlyWhenServerConfigEnablesIt() {
+        assertFalse(DriverLeaveRequestUiRules.isFeatureVisible(null))
+        assertFalse(DriverLeaveRequestUiRules.isFeatureVisible(LeaveRequestsConfig(enabled = false, types = listOf("URLOP"))))
+        assertTrue(DriverLeaveRequestUiRules.isFeatureVisible(LeaveRequestsConfig(enabled = true, types = listOf("URLOP"))))
+    }
+
+    @Test
+    fun exposesPolishStatusLabels() {
+        assertEquals("Oczekuje", DriverLeaveRequestUiRules.statusLabel("pending"))
+        assertEquals("Zatwierdzony", DriverLeaveRequestUiRules.statusLabel("approved"))
+        assertEquals("Odrzucony", DriverLeaveRequestUiRules.statusLabel("rejected"))
+        assertEquals("Anulowanie do decyzji", DriverLeaveRequestUiRules.statusLabel("cancel_requested"))
+        assertEquals("Anulowany", DriverLeaveRequestUiRules.statusLabel("cancelled"))
+        assertEquals("Cofnięto decyzję", DriverLeaveRequestUiRules.statusLabel("revoked"))
+        assertEquals("Nieznany status", DriverLeaveRequestUiRules.statusLabel("some_raw_status"))
+    }
+
+    @Test
+    fun exposesPolishEventActionLabels() {
+        assertEquals("Wniosek złożony", DriverLeaveRequestUiRules.eventActionLabel("submitted"))
+        assertEquals("Wniosek zatwierdzony", DriverLeaveRequestUiRules.eventActionLabel("approved"))
+        assertEquals("Wniosek odrzucony", DriverLeaveRequestUiRules.eventActionLabel("rejected"))
+        assertEquals("Decyzja cofnięta", DriverLeaveRequestUiRules.eventActionLabel("revoked"))
+        assertEquals("Wniosek anulowany przez kierowcę", DriverLeaveRequestUiRules.eventActionLabel("cancelled_by_driver"))
+        assertEquals("Kierowca poprosił o anulowanie", DriverLeaveRequestUiRules.eventActionLabel("cancellation_requested"))
+        assertEquals("Anulowanie zatwierdzone", DriverLeaveRequestUiRules.eventActionLabel("cancellation_approved"))
+        assertEquals("Anulowanie odrzucone", DriverLeaveRequestUiRules.eventActionLabel("cancellation_rejected"))
+        assertEquals("Aktualizacja wniosku", DriverLeaveRequestUiRules.eventActionLabel("some_raw_action"))
+    }
+
+    @Test
+    fun driverCanCancelPendingAndFutureApprovedRequests() {
+        val tomorrow = LocalDate.now().plusDays(1).toString()
+        val yesterday = LocalDate.now().minusDays(1).toString()
+
+        assertTrue(DriverLeaveRequestUiRules.canCancel(status = "pending", dateFrom = yesterday))
+        assertTrue(DriverLeaveRequestUiRules.canCancel(status = "approved", dateFrom = tomorrow))
+        assertFalse(DriverLeaveRequestUiRules.canCancel(status = "approved", dateFrom = yesterday))
+        assertFalse(DriverLeaveRequestUiRules.canCancel(status = "rejected", dateFrom = tomorrow))
+    }
+}

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

@@ -0,0 +1,269 @@
+package pl.firmatpp.kierowca.ui
+
+import java.time.LocalDate
+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.DriverRouteDto
+import pl.firmatpp.kierowca.data.model.DispatchSheetReminderDto
+import pl.firmatpp.kierowca.data.upload.PhotoUploadEntity
+
+class DriverUiRulesTest {
+    private val today = LocalDate.parse("2026-06-30")
+
+    @Test
+    fun allowsPhotoActionsOnlyForTodayRouteDate() {
+        assertTrue(canManageRoutePhotos("2026-06-30", today))
+        assertFalse(canManageRoutePhotos("2026-06-29", today))
+        assertFalse(canManageRoutePhotos("2026-07-01", today))
+    }
+
+    @Test
+    fun blocksPhotoActionsWhenDateIsInvalid() {
+        assertFalse(canManageRoutePhotos("", today))
+        assertFalse(canManageRoutePhotos("not-a-date", today))
+    }
+
+    @Test
+    fun allowsRouteCompletionOnlyForTodayPlannedOrInProgressRoutes() {
+        assertTrue(canCompleteRouteFromDriverApp(route(status = "ZAPLANOWANA"), "2026-06-30", today))
+        assertTrue(canCompleteRouteFromDriverApp(route(status = "W TRAKCIE"), "2026-06-30", today))
+        assertFalse(canCompleteRouteFromDriverApp(route(status = "ZAKOŃCZONA"), "2026-06-30", today))
+        assertFalse(canCompleteRouteFromDriverApp(route(status = "NIEROZPOZNANA"), "2026-06-30", today))
+        assertFalse(canCompleteRouteFromDriverApp(route(status = "ZAPLANOWANA"), "2026-07-01", today))
+        assertFalse(canCompleteRouteFromDriverApp(route(status = "ZAPLANOWANA"), "2026-06-29", today))
+    }
+
+    @Test
+    fun showsLiveRouteDayUpdateOnlyForViewedDate() {
+        assertTrue(shouldShowRouteDayLiveUpdate(viewedDate = "2026-03-12", hintDate = "2026-03-12"))
+        assertTrue(shouldShowRouteDayLiveUpdate(viewedDate = "2026-03-12", hintDate = null))
+        assertFalse(shouldShowRouteDayLiveUpdate(viewedDate = "2026-03-12", hintDate = "2026-03-13"))
+        assertFalse(shouldShowRouteDayLiveUpdate(viewedDate = "", hintDate = "2026-03-12"))
+    }
+
+    @Test
+    fun formatsRouteDateChipHumanFirstWithShortFallback() {
+        assertEquals("dzisiaj · 30.06", routeDateChipLabel("2026-06-30", today))
+        assertEquals("jutro · 01.07", routeDateChipLabel("2026-07-01", today))
+        assertEquals("w poniedziałek · 06.07", routeDateChipLabel("2026-07-06", today))
+        assertEquals("02.03", routeDateChipLabel("2027-03-02", today))
+        assertEquals("—", routeDateChipLabel("", today))
+    }
+
+    @Test
+    fun calculatesPhotoGridRowsForTwoColumnInlineGallery() {
+        assertEquals(0, inlinePhotoGridRows(0))
+        assertEquals(1, inlinePhotoGridRows(1))
+        assertEquals(1, inlinePhotoGridRows(2))
+        assertEquals(2, inlinePhotoGridRows(3))
+        assertEquals(3, inlinePhotoGridRows(5))
+    }
+
+    @Test
+    fun usesShorterChromeOnCompactScreens() {
+        assertEquals(118, authBrandBannerHeightDp(600))
+        assertEquals(150, authBrandBannerHeightDp(690))
+        assertEquals(190, authBrandBannerHeightDp(780))
+
+        assertEquals(92, appBrandHeaderHeightDp(600))
+        assertEquals(108, appBrandHeaderHeightDp(690))
+        assertEquals(124, appBrandHeaderHeightDp(780))
+
+        assertEquals(72, bottomNavigationHeightDp(600))
+        assertEquals(78, bottomNavigationHeightDp(690))
+        assertEquals(82, bottomNavigationHeightDp(780))
+    }
+
+    @Test
+    fun reducesHorizontalSpaceOnNarrowScreens() {
+        assertEquals(14, screenHorizontalPaddingDp(340))
+        assertEquals(16, screenHorizontalPaddingDp(390))
+        assertEquals(20, screenHorizontalPaddingDp(440))
+
+        assertEquals(70, phonePrefixWidthDp(340))
+        assertEquals(82, phonePrefixWidthDp(390))
+        assertEquals(94, phonePrefixWidthDp(440))
+    }
+
+    @Test
+    fun stacksDenseRouteFactsOnNarrowScreens() {
+        assertEquals(1, routeFactColumns(340))
+        assertEquals(2, routeFactColumns(390))
+    }
+
+    @Test
+    fun countsServerPhotosAndLocalUploadsAsVisibleAttachments() {
+        assertEquals(0, visiblePhotoAttachmentCount(serverPhotoCount = 0, localUploadCount = 0))
+        assertEquals(1, visiblePhotoAttachmentCount(serverPhotoCount = 0, localUploadCount = 1))
+        assertEquals(3, visiblePhotoAttachmentCount(serverPhotoCount = 1, localUploadCount = 2))
+    }
+
+    @Test
+    fun countsOnlyUnconfirmedNonCancelledUploadsInQueue() {
+        assertEquals(0, queuedPhotoUploadCount(emptyList()))
+        assertEquals(
+            4,
+            queuedPhotoUploadCount(
+                listOf(
+                    "PENDING",
+                    "UPLOADING",
+                    "VERIFYING",
+                    "FAILED_RETRYABLE",
+                    "CONFIRMED",
+                    "CANCELLED",
+                ),
+            ),
+        )
+        assertEquals(1, queuedPhotoUploadCount(listOf("FAILED_PERMANENT")))
+    }
+
+    @Test
+    fun usesCreatedAtBeforeTakenAtForNewestFirstPhotoSorting() {
+        val fallback = 100L
+
+        assertEquals(
+            1_782_892_800_000L,
+            routePhotoSortEpochMillis(
+                createdAt = "2026-07-01T10:00:00+02:00",
+                takenAt = "2026-07-01T08:00:00+02:00",
+                fallback = fallback,
+            ),
+        )
+        assertEquals(
+            1_782_885_600_000L,
+            routePhotoSortEpochMillis(
+                createdAt = null,
+                takenAt = "2026-07-01T08:00:00+02:00",
+                fallback = fallback,
+            ),
+        )
+        assertEquals(fallback, routePhotoSortEpochMillis(createdAt = null, takenAt = null, fallback = fallback))
+    }
+
+    @Test
+    fun allowsDeleteIconForConfirmedLocalUploadWithServerPhotoId() {
+        assertEquals("42", confirmedUploadServerPhotoId("CONFIRMED", "42"))
+        assertEquals(null, confirmedUploadServerPhotoId("CONFIRMED", ""))
+        assertEquals(null, confirmedUploadServerPhotoId("UPLOADING", "42"))
+        assertEquals(null, confirmedUploadServerPhotoId("FAILED_RETRYABLE", "42"))
+    }
+
+    @Test
+    fun allowsRetryActionOnlyForRetryableFailedUploads() {
+        assertTrue(canRetryPhotoUpload("FAILED_RETRYABLE"))
+        assertFalse(canRetryPhotoUpload("PENDING"))
+        assertFalse(canRetryPhotoUpload("UPLOADING"))
+        assertFalse(canRetryPhotoUpload("VERIFYING"))
+        assertFalse(canRetryPhotoUpload("CONFIRMED"))
+        assertFalse(canRetryPhotoUpload("FAILED_PERMANENT"))
+        assertFalse(canRetryPhotoUpload("CANCELLED"))
+    }
+
+    @Test
+    fun showsFailureDetailsOnlyForFailedUploadsWithErrorMessage() {
+        assertTrue(canShowPhotoUploadFailureDetails("FAILED_RETRYABLE", "Typ: błąd serwera"))
+        assertTrue(canShowPhotoUploadFailureDetails("FAILED_PERMANENT", "Typ: błąd aplikacji"))
+        assertFalse(canShowPhotoUploadFailureDetails("FAILED_RETRYABLE", null))
+        assertFalse(canShowPhotoUploadFailureDetails("FAILED_RETRYABLE", ""))
+        assertFalse(canShowPhotoUploadFailureDetails("UPLOADING", "Typ: błąd serwera"))
+        assertFalse(canShowPhotoUploadFailureDetails("CONFIRMED", "Typ: błąd serwera"))
+    }
+
+    @Test
+    fun createsFullScreenPreviewForLocalUploadBeforeRouteRefresh() {
+        val photo = localUploadPreviewPhoto(upload(status = "CONFIRMED", serverPhotoId = "55"))
+
+        requireNotNull(photo)
+        assertEquals("local-upload-123", photo.id)
+        assertEquals("10", photo.routeId)
+        assertEquals("file:/tmp/photo.jpg", photo.url)
+        assertEquals("2026-07-01T08:00:00Z", photo.takenAt)
+        assertEquals(50.1, photo.latitude ?: 0.0, 0.0)
+        assertEquals(true, photo.canDelete)
+    }
+
+    @Test
+    fun preciseLocationRequirementAllowsCameraOnlyWithFineLocation() {
+        assertTrue(canLaunchCameraWithLocationPolicy(requirePreciseLocation = false, hasFineLocation = false))
+        assertTrue(canLaunchCameraWithLocationPolicy(requirePreciseLocation = true, hasFineLocation = true))
+        assertFalse(canLaunchCameraWithLocationPolicy(requirePreciseLocation = true, hasFineLocation = false))
+    }
+
+    @Test
+    fun showsDispatchSheetCardOnlyWhenReminderIsDueToday() {
+        assertTrue(shouldShowDispatchSheetReminderCard(dispatchReminder(status = "missing", dueToday = true)))
+        assertTrue(shouldShowDispatchSheetReminderCard(dispatchReminder(status = "uploaded", dueToday = true)))
+        assertFalse(shouldShowDispatchSheetReminderCard(dispatchReminder(status = "not_required", dueToday = false)))
+        assertFalse(shouldShowDispatchSheetReminderCard(null))
+    }
+
+    @Test
+    fun explainsOfflineStateWithoutCachedSync() {
+        assertEquals(
+            "Brak połączenia z serwerem. Sprawdź internet i spróbuj ponownie.",
+            offlineStaleBannerMessage(isOnline = false, isStale = false, syncLabel = "brak zapisanej synchronizacji"),
+        )
+    }
+
+    @Test
+    fun explainsStaleCachedDataWhenOnline() {
+        assertEquals(
+            "Dane mogą być nieaktualne. Ostatnia synchronizacja: 12:30.",
+            offlineStaleBannerMessage(isOnline = true, isStale = true, syncLabel = "12:30"),
+        )
+    }
+
+    @Test
+    fun labelsDispatchSheetActionByStatusAndLocalUploadQueue() {
+        assertEquals("Zrób zdjęcie", dispatchSheetPrimaryActionLabel(dispatchReminder(status = "missing"), hasQueuedUpload = false))
+        assertEquals("Wysyłam zdjęcie...", dispatchSheetPrimaryActionLabel(dispatchReminder(status = "missing"), hasQueuedUpload = true))
+        assertEquals("Popraw", dispatchSheetPrimaryActionLabel(dispatchReminder(status = "uploaded"), hasQueuedUpload = false))
+    }
+
+    private fun route(status: String): DriverRouteDto =
+        DriverRouteDto(
+            id = "1",
+            startsAt = "",
+            originName = "Baza",
+            destinationName = "Instalacja",
+            contractorName = "TPP",
+            contractName = "Kontrakt",
+            contractCode = "TPP-1",
+            relationLabel = "Baza -> Instalacja",
+            status = status,
+            distanceKm = 1.0,
+            notes = null,
+            truck = null,
+        )
+
+    private fun upload(status: String, serverPhotoId: String? = null): PhotoUploadEntity =
+        PhotoUploadEntity(
+            clientRequestId = "local-upload-123",
+            routeId = "10",
+            localPath = "/tmp/photo.jpg",
+            source = "camera",
+            takenAt = "2026-07-01T08:00:00Z",
+            latitude = 50.1,
+            longitude = 19.9,
+            locationAccuracyMeters = 8.0,
+            mimeType = "image/jpeg",
+            size = 1200,
+            contentSha256 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+            status = status,
+            serverPhotoId = serverPhotoId,
+        )
+
+    private fun dispatchReminder(status: String, dueToday: Boolean = true): DispatchSheetReminderDto =
+        DispatchSheetReminderDto(
+            enabled = dueToday,
+            dueToday = dueToday,
+            workDate = "2026-06-30",
+            reason = if (dueToday) "friday" else null,
+            availableUntil = "2026-06-30T23:59:59+02:00",
+            status = status,
+            photo = null,
+            canUpload = dueToday,
+        )
+}

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

@@ -0,0 +1,62 @@
+package pl.firmatpp.kierowca.ui
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import pl.firmatpp.kierowca.data.model.DriverLeaveRequestDto
+import pl.firmatpp.kierowca.ui.theme.AppThemeMode
+
+class DriverUiStateTest {
+    @Test
+    fun startsOnInitializingScreenBeforeTokenCheckCompletes() {
+        val state = DriverUiState()
+
+        assertEquals(DriverScreen.Initializing, state.screen)
+        assertTrue(state.loading)
+    }
+
+    @Test
+    fun startsWithMaterial3ThemeMode() {
+        val state = DriverUiState()
+
+        assertEquals(AppThemeMode.Material3, state.themeMode)
+    }
+
+    @Test
+    fun refreshingLeaveRequestsKeepsDetailScreenOpenAndUpdatesSelectedRequest() {
+        val state = DriverUiState(
+            screen = DriverScreen.LeaveRequestDetail,
+            selectedLeaveRequest = leaveRequest(id = "leave-1", status = "pending"),
+        )
+
+        val refreshed = state.withLoadedLeaveRequests(
+            requests = listOf(leaveRequest(id = "leave-1", status = "approved")),
+            navigateToList = false,
+        )
+
+        assertEquals(DriverScreen.LeaveRequestDetail, refreshed.screen)
+        assertEquals("approved", refreshed.selectedLeaveRequest?.status)
+    }
+
+    @Test
+    fun openingLeaveRequestsNavigatesToList() {
+        val state = DriverUiState(screen = DriverScreen.Routes)
+
+        val refreshed = state.withLoadedLeaveRequests(
+            requests = listOf(leaveRequest(id = "leave-1", status = "pending")),
+            navigateToList = true,
+        )
+
+        assertEquals(DriverScreen.LeaveRequests, refreshed.screen)
+        assertEquals(1, refreshed.leaveRequests.size)
+    }
+
+    private fun leaveRequest(id: String, status: String): DriverLeaveRequestDto =
+        DriverLeaveRequestDto(
+            id = id,
+            dateFrom = "2026-07-10",
+            dateTo = "2026-07-12",
+            type = "URLOP",
+            status = status,
+        )
+}

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

@@ -0,0 +1,41 @@
+package pl.firmatpp.kierowca.ui
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class OtpAutoSubmitPolicyTest {
+    @Test
+    fun submitsWhenSixthDigitIsEntered() {
+        val policy = OtpAutoSubmitPolicy()
+
+        assertFalse(policy.shouldSubmit("12345", loading = false))
+        assertTrue(policy.shouldSubmit("123456", loading = false))
+    }
+
+    @Test
+    fun submitsSmsRetrieverCodeOnlyOnceWhileItStaysTheSame() {
+        val policy = OtpAutoSubmitPolicy()
+
+        assertTrue(policy.shouldSubmit("987654", loading = false))
+        assertFalse(policy.shouldSubmit("987654", loading = false))
+    }
+
+    @Test
+    fun allowsRetryAfterCodeIsEditedBelowSixDigits() {
+        val policy = OtpAutoSubmitPolicy()
+
+        assertTrue(policy.shouldSubmit("111111", loading = false))
+        assertFalse(policy.shouldSubmit("111111", loading = false))
+        assertFalse(policy.shouldSubmit("11111", loading = false))
+        assertTrue(policy.shouldSubmit("111111", loading = false))
+    }
+
+    @Test
+    fun doesNotSubmitWhileLoadingOrForLongerCodes() {
+        val policy = OtpAutoSubmitPolicy()
+
+        assertFalse(policy.shouldSubmit("123456", loading = true))
+        assertFalse(policy.shouldSubmit("1234567", loading = false))
+    }
+}

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

@@ -0,0 +1,27 @@
+package pl.firmatpp.kierowca.ui
+
+import androidx.compose.ui.text.AnnotatedString
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class PolishPhoneNumberVisualTransformationTest {
+    @Test
+    fun formatsPhoneDigitsWithoutChangingUnderlyingTextOffsets() {
+        val transformed = PolishPhoneNumberVisualTransformation.filter(AnnotatedString("1234"))
+
+        assertEquals("123 4", transformed.text.text)
+        assertEquals(5, transformed.offsetMapping.originalToTransformed(4))
+        assertEquals(4, transformed.offsetMapping.transformedToOriginal(5))
+    }
+
+    @Test
+    fun mapsOffsetsAcrossBothInsertedSpaces() {
+        val transformed = PolishPhoneNumberVisualTransformation.filter(AnnotatedString("123456789"))
+
+        assertEquals("123 456 789", transformed.text.text)
+        assertEquals(7, transformed.offsetMapping.originalToTransformed(6))
+        assertEquals(11, transformed.offsetMapping.originalToTransformed(9))
+        assertEquals(6, transformed.offsetMapping.transformedToOriginal(7))
+        assertEquals(9, transformed.offsetMapping.transformedToOriginal(11))
+    }
+}

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

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

build.gradle.kts

@@ -2,4 +2,6 @@ plugins {
     alias(libs.plugins.android.application) apply false
     alias(libs.plugins.kotlin.android) apply false
     alias(libs.plugins.kotlin.compose) apply false
+    alias(libs.plugins.google.services) apply false
+    alias(libs.plugins.firebase.crashlytics) apply false
 }

gradle/libs.versions.toml

@@ -13,9 +13,14 @@ datastore = "1.1.1"
 coil = "2.7.0"
 camerax = "1.4.1"
 work = "2.10.0"
+room = "2.7.0"
+ksp = "2.1.10-1.0.31"
 playServicesAuth = "21.6.0"
 playServicesAuthApiPhone = "18.3.0"
 junit = "4.13.2"
+firebaseBom = "33.7.0"
+googleServices = "4.4.2"
+firebaseCrashlyticsPlugin = "3.0.7"
 
 [libraries]
 activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
@@ -25,6 +30,9 @@ androidx-lifecycle-runtime-compose = { group = "androidx.lifecycle", name = "lif
 androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
 androidx-navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigationCompose" }
 androidx-work-runtime-ktx = { group = "androidx.work", name = "work-runtime-ktx", version.ref = "work" }
+androidx-room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room" }
+androidx-room-ktx = { group = "androidx.room", name = "room-ktx", version.ref = "room" }
+androidx-room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "room" }
 camera-camera2 = { group = "androidx.camera", name = "camera-camera2", version.ref = "camerax" }
 camera-core = { group = "androidx.camera", name = "camera-core", version.ref = "camerax" }
 camera-lifecycle = { group = "androidx.camera", name = "camera-lifecycle", version.ref = "camerax" }
@@ -46,8 +54,14 @@ play-services-auth = { group = "com.google.android.gms", name = "play-services-a
 play-services-auth-api-phone = { group = "com.google.android.gms", name = "play-services-auth-api-phone", version.ref = "playServicesAuthApiPhone" }
 retrofit = { group = "com.squareup.retrofit2", name = "retrofit", version.ref = "retrofit" }
 retrofit-gson = { group = "com.squareup.retrofit2", name = "converter-gson", version.ref = "retrofit" }
+firebase-bom = { group = "com.google.firebase", name = "firebase-bom", version.ref = "firebaseBom" }
+firebase-messaging = { group = "com.google.firebase", name = "firebase-messaging-ktx" }
+firebase-crashlytics = { group = "com.google.firebase", name = "firebase-crashlytics" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
 kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
+google-services = { id = "com.google.gms.google-services", version.ref = "googleServices" }
+firebase-crashlytics = { id = "com.google.firebase.crashlytics", version.ref = "firebaseCrashlyticsPlugin" }

tests/device-metadata.test.mjs

@@ -0,0 +1,27 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = resolve(__dirname, '..');
+
+function readSource(path) {
+  return readFileSync(resolve(root, path), 'utf8');
+}
+
+test('driver app sends Android device metadata during OTP verification', () => {
+  const models = readSource('app/src/main/java/pl/firmatpp/kierowca/data/model/DriverModels.kt');
+  const repository = readSource('app/src/main/java/pl/firmatpp/kierowca/data/DriverRepository.kt');
+  const deviceInfo = readSource('app/src/main/java/pl/firmatpp/kierowca/data/DeviceInfoProvider.kt');
+
+  assert.match(models, /data class DriverDeviceInfo/);
+  assert.match(models, /val device: DriverDeviceInfo/);
+  assert.match(repository, /DeviceInfoProvider/);
+  assert.match(repository, /deviceInfoProvider\.currentDeviceInfo/);
+  assert.match(deviceInfo, /Settings\.Secure\.ANDROID_ID/);
+  assert.match(deviceInfo, /Build\.MANUFACTURER/);
+  assert.match(deviceInfo, /Build\.MODEL/);
+  assert.match(deviceInfo, /BuildConfig\.VERSION_NAME/);
+});