Fix launcher icon safe area for 1.0.20

.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,3 +1,6 @@
+import java.io.File
+import java.util.Properties
+
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.android)
@@ -5,19 +8,57 @@ plugins {
     alias(libs.plugins.ksp)
 }
 
+if (file("google-services.json").exists()) {
+    apply(plugin = "com.google.gms.google-services")
+}
+
+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 = 15
-        versionName = "1.0.14"
+        versionCode = 21
+        versionName = "1.0.20"
+        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 {
@@ -25,6 +66,7 @@ android {
             isMinifyEnabled = false
         }
         release {
+            signingConfig = signingConfigs.getByName("release")
             isMinifyEnabled = false
             proguardFiles(
                 getDefaultProguardFile("proguard-android-optimize.txt"),
@@ -77,6 +119,8 @@ dependencies {
     implementation(libs.compose.ui.graphics)
     implementation(libs.compose.ui.tooling.preview)
     implementation(libs.coroutines.android)
+    implementation(platform(libs.firebase.bom))
+    implementation(libs.firebase.messaging)
     implementation(libs.okhttp)
     implementation(libs.okhttp.logging)
     implementation(libs.play.services.auth)

app/src/main/AndroidManifest.xml

@@ -30,5 +30,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/data/DriverRepository.kt

@@ -12,11 +12,15 @@ 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.DriverDto
 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.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.PhotoUploadEntity
 
@@ -42,6 +46,21 @@ class DriverRepository(
     suspend fun route(routeId: String): RouteResponse =
         api.route(authHeader(requireToken()), routeId)
 
+    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 deletePushToken() {
+        val token = tokenStore.read() ?: return
+        runCatching { api.deletePushToken(authHeader(token)) }
+    }
+
     suspend fun uploadPhoto(
         routeId: String,
         uri: Uri,
@@ -106,6 +125,7 @@ class DriverRepository(
     suspend fun logout() {
         val token = tokenStore.read()
         if (token != null) {
+            runCatching { api.deletePushToken(authHeader(token)) }
             runCatching { api.logout(authHeader(token)) }
         }
         tokenStore.clear()

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

@@ -3,10 +3,14 @@ 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.OtpResponse
 import pl.firmatpp.kierowca.data.model.PhotoUploadResponse
+import pl.firmatpp.kierowca.data.model.PushTokenBody
 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
@@ -15,6 +19,7 @@ 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
@@ -41,6 +46,30 @@ interface MobileDriverApi {
         @Path("routeId") routeId: String,
     ): RouteResponse
 
+    @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>
+
+    @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(

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

@@ -46,6 +46,7 @@ data class BootstrapResponse(
     val session: DriverSessionDto,
     val routes: RoutesBucketDto,
     val driverAppSettings: DriverAppSettingsDto?,
+    val syncState: SyncStateResponse? = null,
 )
 
 data class DriverAppSettingsDto(
@@ -69,6 +70,34 @@ data class RoutesBucketDto(
 
 data class RouteResponse(
     val route: DriverRouteDto,
+    val syncState: SyncStateResponse? = null,
+)
+
+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 DriverRouteDto(

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,127 @@
+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.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 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"
+    }
+}

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/DriverDatabase.kt

@@ -1,29 +1,83 @@
 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],
-    version = 1,
+    entities = [
+        PhotoUploadEntity::class,
+        DriverBootstrapCacheEntity::class,
+        DriverRouteCacheEntity::class,
+        DriverSyncStateEntity::class,
+    ],
+    version = 2,
     exportSchema = false,
 )
 abstract class DriverDatabase : RoomDatabase() {
     abstract fun photoUploadDao(): PhotoUploadDao
+    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)")
+            }
+        }
+
         fun get(context: Context): DriverDatabase =
             instance ?: synchronized(this) {
                 instance ?: Room.databaseBuilder(
                     context.applicationContext,
                     DriverDatabase::class.java,
                     "driver-local-outbox.db",
-                ).build().also { instance = it }
+                ).addMigrations(migration1To2).build().also { instance = it }
             }
     }
 }

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

@@ -24,6 +24,16 @@ interface PhotoUploadDao {
     )
     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

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

@@ -25,6 +25,9 @@ class PhotoUploadOutbox(
     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"
@@ -69,6 +72,13 @@ class PhotoUploadOutbox(
         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) {
         val confirmedRequestIds = route.photos.mapNotNull { it.clientRequestId }.distinct()
         if (confirmedRequestIds.isEmpty()) return

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

@@ -0,0 +1,33 @@
+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_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,135 @@
+package pl.firmatpp.kierowca.sync
+
+import com.google.gson.Gson
+import com.google.gson.JsonObject
+import com.google.gson.JsonParser
+import java.util.concurrent.atomic.AtomicBoolean
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+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.BuildConfig
+import pl.firmatpp.kierowca.data.DriverRepository
+
+class DriverLiveSyncClient(
+    private val repository: DriverRepository,
+    private val onConnected: () -> Unit,
+    private val onHint: (DriverSyncHint) -> Unit,
+    private val client: OkHttpClient = OkHttpClient(),
+    private val gson: Gson = Gson(),
+) {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private val started = AtomicBoolean(false)
+    private var webSocket: WebSocket? = null
+    private var driverId: String? = null
+
+    fun start(driverId: String) {
+        if (BuildConfig.REVERB_APP_KEY.isBlank()) return
+        this.driverId = driverId
+        if (!started.compareAndSet(false, true)) return
+
+        val wsUrl = BuildConfig.REVERB_WS_BASE_URL.trimEnd('/') +
+            "/" + BuildConfig.REVERB_APP_KEY +
+            "?protocol=7&client=android&version=1.0&flash=false"
+
+        webSocket = client.newWebSocket(
+            Request.Builder().url(wsUrl).build(),
+            object : WebSocketListener() {
+                override fun onMessage(webSocket: WebSocket, text: String) {
+                    handleMessage(webSocket, text)
+                }
+
+                override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
+                    started.set(false)
+                    scheduleReconnect()
+                }
+
+                override fun onFailure(webSocket: WebSocket, t: Throwable, response: okhttp3.Response?) {
+                    started.set(false)
+                    scheduleReconnect()
+                }
+            },
+        )
+    }
+
+    fun stop() {
+        started.set(false)
+        webSocket?.close(1000, "logout")
+        webSocket = null
+        driverId = null
+    }
+
+    fun close() {
+        stop()
+        scope.cancel()
+    }
+
+    private fun handleMessage(socket: WebSocket, text: String) {
+        val root = runCatching { JsonParser.parseString(text).asJsonObject }.getOrNull() ?: return
+        val event = root.string("event") ?: return
+
+        when (event) {
+            "pusher:connection_established" -> {
+                val socketId = root.dataObject()?.string("socket_id") ?: return
+                subscribe(socket, socketId)
+                onConnected()
+            }
+            "DriverMobileSyncHint" -> parseHint(root.dataObject())?.let(onHint)
+        }
+    }
+
+    private fun subscribe(socket: WebSocket, socketId: String) {
+        val id = driverId ?: return
+        val channel = "private-driver-mobile.$id"
+
+        scope.launch {
+            runCatching {
+                val auth = repository.broadcastAuth(socketId, channel).auth
+                val payload = mapOf(
+                    "event" to "pusher:subscribe",
+                    "data" to mapOf(
+                        "channel" to channel,
+                        "auth" to auth,
+                    ),
+                )
+                socket.send(gson.toJson(payload))
+            }
+        }
+    }
+
+    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
+
+    private fun scheduleReconnect() {
+        val id = driverId ?: return
+        scope.launch {
+            delay(5_000)
+            if (!started.get() && driverId == id) {
+                start(id)
+            }
+        }
+    }
+}

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,77 @@
+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
+
+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
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (!refreshed) {
+                syncRepository.saveSyncStates(response)
+            }
+
+            Result.success()
+        }.getOrElse { throwable ->
+            val error = ApiErrorMapper.map(throwable)
+            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/ui/DriverApp.kt

@@ -51,6 +51,7 @@ import androidx.compose.material.icons.outlined.AddPhotoAlternate
 import androidx.compose.material.icons.outlined.ArrowBack
 import androidx.compose.material.icons.outlined.CameraAlt
 import androidx.compose.material.icons.outlined.CalendarToday
+import androidx.compose.material.icons.outlined.CloudUpload
 import androidx.compose.material.icons.outlined.Factory
 import androidx.compose.material.icons.outlined.Delete
 import androidx.compose.material.icons.outlined.LocationOn
@@ -62,6 +63,7 @@ import androidx.compose.material.ExperimentalMaterialApi
 import androidx.compose.material.pullrefresh.PullRefreshIndicator
 import androidx.compose.material.pullrefresh.pullRefresh
 import androidx.compose.material.pullrefresh.rememberPullRefreshState
+import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.Card
@@ -75,6 +77,7 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
@@ -113,6 +116,7 @@ import com.google.android.gms.common.api.Status
 import java.io.File
 import java.time.Instant
 import java.time.LocalDate
+import java.time.ZoneId
 import java.time.format.DateTimeFormatter
 import kotlinx.coroutines.delay
 import java.util.Locale
@@ -174,11 +178,26 @@ fun DriverApp(viewModel: DriverViewModel) {
                 onRefresh = viewModel::refreshRoutesSilently,
                 onDate = viewModel::selectRouteDate,
                 onProfile = viewModel::openProfile,
+                onPhotoQueue = viewModel::openPhotoQueue,
                 onRoute = viewModel::openRoute,
             )
             DriverScreen.Profile -> ProfileScreen(state, viewModel::refreshRoutes, viewModel::openProfile, viewModel::logout)
-            DriverScreen.Detail -> DetailScreen(state, viewModel::back, viewModel::uploadPhoto, viewModel::openPhoto, viewModel::deletePhoto, viewModel::retryPhotoUpload, viewModel::refreshSelectedRoute)
+            DriverScreen.Detail -> DetailScreen(
+                state,
+                viewModel::back,
+                viewModel::uploadPhoto,
+                viewModel::openPhoto,
+                viewModel::deletePhoto,
+                viewModel::deleteConfirmedUpload,
+                viewModel::retryPhotoUpload,
+                viewModel::refreshSelectedRoute,
+            )
             DriverScreen.Photo -> PhotoScreen(state, viewModel::back)
+            DriverScreen.PhotoQueue -> PhotoQueueScreen(
+                state = state,
+                onBack = viewModel::back,
+                onRetryUpload = viewModel::retryPhotoUpload,
+            )
         }
 
         if (state.loading && state.screen != DriverScreen.Initializing) {
@@ -395,6 +414,7 @@ private fun RoutesScreen(
     onRefresh: () -> Unit,
     onDate: (String) -> Unit,
     onProfile: () -> Unit,
+    onPhotoQueue: () -> Unit,
     onRoute: (String) -> Unit,
 ) {
     Scaffold(
@@ -438,6 +458,8 @@ private fun RoutesScreen(
                         onDate = onDate,
                     )
                 }
+                item { OfflineStaleBanner(state) }
+                item { PhotoQueueBanner(state.queuedPhotoUploads, onPhotoQueue) }
                 if (state.routes.isEmpty()) {
                     item { EmptyState("Brak kursow na wybrany dzien") }
                 } else {
@@ -456,6 +478,129 @@ private fun RoutesScreen(
     }
 }
 
+@Composable
+private fun PhotoQueueBanner(uploads: List<PhotoUploadEntity>, onPhotoQueue: () -> Unit) {
+    val count = queuedPhotoUploadCount(uploads.map { it.status })
+    if (count <= 0) return
+
+    Card(
+        colors = CardDefaults.cardColors(containerColor = Color.White),
+        border = BorderStroke(1.dp, TppColors.Outline),
+        shape = RoundedCornerShape(8.dp),
+        modifier = Modifier.fillMaxWidth(),
+    ) {
+        Row(
+            Modifier.fillMaxWidth().padding(14.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(12.dp),
+        ) {
+            Box(
+                Modifier.size(42.dp).background(TppColors.ContainerGreen, RoundedCornerShape(6.dp)),
+                contentAlignment = Alignment.Center,
+            ) {
+                Icon(Icons.Outlined.CloudUpload, contentDescription = null, tint = TppColors.Forest)
+            }
+            Text(
+                "W kolejce do wysłania jest $count ${photoCountLabel(count)}.",
+                color = TppColors.Ink,
+                fontWeight = FontWeight.SemiBold,
+                modifier = Modifier.weight(1f),
+            )
+            Button(
+                onClick = onPhotoQueue,
+                colors = ButtonDefaults.buttonColors(containerColor = TppColors.Forest),
+                shape = RoundedCornerShape(4.dp),
+                contentPadding = PaddingValues(horizontal = 14.dp, vertical = 10.dp),
+            ) {
+                Text("Kolejka", color = Color.White, fontWeight = FontWeight.Bold)
+            }
+        }
+    }
+}
+
+@Composable
+private fun PhotoQueueScreen(
+    state: DriverUiState,
+    onBack: () -> Unit,
+    onRetryUpload: (PhotoUploadEntity) -> Unit,
+) {
+    val uploads = state.queuedPhotoUploads.sortedBy { it.createdAtEpochMillis }
+
+    Scaffold(
+        topBar = { DetailHeader(onBack, title = "Kolejka zdjęć") },
+        containerColor = TppColors.Surface,
+    ) { padding ->
+        LazyColumn(
+            Modifier.fillMaxSize().padding(padding),
+            contentPadding = PaddingValues(16.dp),
+            verticalArrangement = Arrangement.spacedBy(14.dp),
+        ) {
+            item { OfflineStaleBanner(state) }
+            if (uploads.isEmpty()) {
+                item { EmptyState("Brak zdjęć oczekujących na przesłanie") }
+            } else {
+                item {
+                    Text(
+                        "Zdjęcia do przesłania (${uploads.size})",
+                        style = MaterialTheme.typography.headlineSmall,
+                        fontWeight = FontWeight.Bold,
+                        color = TppColors.Ink,
+                    )
+                }
+                items(uploads, key = { it.clientRequestId }) { upload ->
+                    PhotoQueueItem(upload, onRetryUpload)
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun PhotoQueueItem(upload: PhotoUploadEntity, onRetryUpload: (PhotoUploadEntity) -> Unit) {
+    val status = upload.statusType
+    Card(
+        colors = CardDefaults.cardColors(containerColor = Color.White),
+        border = BorderStroke(1.dp, TppColors.Outline),
+        shape = RoundedCornerShape(8.dp),
+        modifier = Modifier.fillMaxWidth(),
+    ) {
+        Row(
+            Modifier.fillMaxWidth().padding(12.dp),
+            horizontalArrangement = Arrangement.spacedBy(12.dp),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            AsyncImage(
+                model = File(upload.localPath),
+                contentDescription = "Zdjęcie z kolejki",
+                contentScale = ContentScale.Crop,
+                modifier = Modifier.size(76.dp).background(TppColors.Panel, RoundedCornerShape(6.dp)),
+            )
+            Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(6.dp)) {
+                Text("Kurs #${upload.routeId}", color = TppColors.Ink, fontWeight = FontWeight.Bold)
+                Text(
+                    upload.lastError?.takeIf { status == PhotoUploadStatus.FailedPermanent } ?: status.label,
+                    color = if (status == PhotoUploadStatus.FailedPermanent) TppColors.Error else TppColors.Muted,
+                    fontFamily = FontFamily.Monospace,
+                    style = MaterialTheme.typography.labelMedium,
+                )
+                if (status == PhotoUploadStatus.Uploading || status == PhotoUploadStatus.Verifying) {
+                    androidx.compose.material3.LinearProgressIndicator(
+                        progress = { (upload.progress.coerceIn(0, 100) / 100f) },
+                        modifier = Modifier.fillMaxWidth(),
+                        color = TppColors.Forest,
+                        trackColor = TppColors.Outline.copy(alpha = 0.4f),
+                    )
+                }
+            }
+            if (status == PhotoUploadStatus.FailedRetryable) {
+                TextButton(onClick = { onRetryUpload(upload) }) {
+                    Text("Ponów", color = TppColors.Forest, fontWeight = FontWeight.Bold)
+                }
+            }
+        }
+    }
+}
+
 @Composable
 private fun StitchHeader() {
     Column(Modifier.fillMaxWidth().background(Color.White).statusBarsPadding()) {
@@ -736,6 +881,7 @@ private fun DetailScreen(
     onUpload: (Uri, String, PhotoUploadMetadata) -> Unit,
     onPhoto: (RoutePhotoDto) -> Unit,
     onDeletePhoto: (RoutePhotoDto) -> Unit,
+    onDeleteUpload: (PhotoUploadEntity) -> Unit,
     onRetryUpload: (PhotoUploadEntity) -> Unit,
     onRefresh: () -> Unit,
 ) {
@@ -772,6 +918,7 @@ private fun DetailScreen(
                 verticalArrangement = Arrangement.spacedBy(24.dp),
             ) {
                 item { ManifestSection(route, onNavigate = { openNavigation(context, it) }) }
+                item { OfflineStaleBanner(state) }
                 item {
                     CargoDocumentationSection(
                         photos = route.photos,
@@ -782,6 +929,7 @@ private fun DetailScreen(
                         canManagePhotos = canManagePhotos,
                         onPhoto = onPhoto,
                         onDeletePhoto = onDeletePhoto,
+                        onDeleteUpload = onDeleteUpload,
                         onRetryUpload = onRetryUpload,
                         onCamera = {
                             val newUri = createCameraUri(context)
@@ -812,7 +960,7 @@ private fun DetailScreen(
 }
 
 @Composable
-private fun DetailHeader(onBack: () -> Unit) {
+private fun DetailHeader(onBack: () -> Unit, title: String = "Szczegóły Trasy") {
     Column(Modifier.fillMaxWidth().background(TppColors.Surface).statusBarsPadding()) {
         Row(
             Modifier.fillMaxWidth().height(64.dp).padding(start = 8.dp, end = 16.dp),
@@ -822,7 +970,7 @@ private fun DetailHeader(onBack: () -> Unit) {
                 Icon(Icons.Outlined.ArrowBack, contentDescription = "Wstecz", tint = TppColors.Ink)
             }
             Text(
-                "Szczegóły Trasy",
+                title,
                 style = MaterialTheme.typography.titleLarge,
                 fontWeight = FontWeight.SemiBold,
                 color = TppColors.Ink,
@@ -833,6 +981,13 @@ private fun DetailHeader(onBack: () -> Unit) {
     }
 }
 
+private fun photoCountLabel(count: Int): String =
+    when {
+        count == 1 -> "zdjęcie"
+        count in 2..4 -> "zdjęcia"
+        else -> "zdjęć"
+    }
+
 @Composable
 private fun ManifestSection(route: DriverRouteDto, onNavigate: (NavigationPointDto) -> Unit) {
     val stripColor = routeStatusColor(route.status)
@@ -973,6 +1128,7 @@ private fun CargoDocumentationSection(
     canManagePhotos: Boolean,
     onPhoto: (RoutePhotoDto) -> Unit,
     onDeletePhoto: (RoutePhotoDto) -> Unit,
+    onDeleteUpload: (PhotoUploadEntity) -> Unit,
     onRetryUpload: (PhotoUploadEntity) -> Unit,
     onCamera: () -> Unit,
     onGallery: () -> Unit,
@@ -995,7 +1151,7 @@ private fun CargoDocumentationSection(
                 }
             }
         }
-        PhotoGrid(photos, uploads, deletingPhotoIds, imageAuthHeader, onPhoto, onDeletePhoto, onRetryUpload)
+        PhotoGrid(photos, uploads, deletingPhotoIds, imageAuthHeader, onPhoto, onDeletePhoto, onDeleteUpload, onRetryUpload)
     }
 }
 
@@ -1021,9 +1177,13 @@ private fun PhotoGrid(
     imageAuthHeader: String?,
     onPhoto: (RoutePhotoDto) -> Unit,
     onDeletePhoto: (RoutePhotoDto) -> Unit,
+    onDeleteUpload: (PhotoUploadEntity) -> Unit,
     onRetryUpload: (PhotoUploadEntity) -> Unit,
 ) {
-    val items = uploads.map { PhotoGridItem.Upload(it) } + photos.map { PhotoGridItem.Server(it) }
+    var pendingDelete by remember { mutableStateOf<PhotoDeleteTarget?>(null) }
+    val items = (uploads.map { PhotoGridItem.Upload(it) } + photos.map { PhotoGridItem.Server(it) })
+        .sortedByDescending { it.sortEpochMillis }
+    val visibleAttachmentCount = visiblePhotoAttachmentCount(photos.size, uploads.size)
 
     Card(
         colors = CardDefaults.cardColors(containerColor = Color.White),
@@ -1032,7 +1192,7 @@ private fun PhotoGrid(
     ) {
         Column(Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
             Text(
-                "Załączone zdjęcia (${photos.size})",
+                "Załączone zdjęcia ($visibleAttachmentCount)",
                 color = TppColors.Muted,
                 fontFamily = FontFamily.Monospace,
                 fontWeight = FontWeight.SemiBold,
@@ -1052,11 +1212,13 @@ private fun PhotoGrid(
                                         imageAuthHeader = imageAuthHeader,
                                         isDeleting = item.photo.id in deletingPhotoIds,
                                         onPhoto = onPhoto,
-                                        onDeletePhoto = onDeletePhoto,
+                                        onDeletePhoto = { pendingDelete = PhotoDeleteTarget.Server(it) },
                                         modifier = Modifier.weight(1f),
                                     )
                                     is PhotoGridItem.Upload -> PendingPhotoTile(
                                         upload = item.upload,
+                                        isDeleting = item.upload.serverPhotoId?.let { it in deletingPhotoIds } == true,
+                                        onDelete = { pendingDelete = PhotoDeleteTarget.Upload(it) },
                                         onRetry = onRetryUpload,
                                         modifier = Modifier.weight(1f),
                                     )
@@ -1071,11 +1233,45 @@ private fun PhotoGrid(
             }
         }
     }
+
+    pendingDelete?.let { target ->
+        AlertDialog(
+            onDismissRequest = { pendingDelete = null },
+            title = { Text("Usunąć zdjęcie?", color = TppColors.Ink, fontWeight = FontWeight.Bold) },
+            text = { Text("Czy na pewno chcesz usunąć to zdjęcie?", color = TppColors.Muted) },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        pendingDelete = null
+                        when (target) {
+                            is PhotoDeleteTarget.Server -> onDeletePhoto(target.photo)
+                            is PhotoDeleteTarget.Upload -> onDeleteUpload(target.upload)
+                        }
+                    },
+                ) {
+                    Text("Usuń", color = TppColors.Error, fontWeight = FontWeight.Bold)
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { pendingDelete = null }) {
+                    Text("Anuluj", color = TppColors.Muted)
+                }
+            },
+        )
+    }
 }
 
-private sealed class PhotoGridItem {
-    data class Server(val photo: RoutePhotoDto) : PhotoGridItem()
-    data class Upload(val upload: PhotoUploadEntity) : PhotoGridItem()
+private sealed class PhotoGridItem(open val sortEpochMillis: Long) {
+    data class Server(val photo: RoutePhotoDto) : PhotoGridItem(
+        routePhotoSortEpochMillis(photo.createdAt, photo.takenAt, fallback = 0L),
+    )
+
+    data class Upload(val upload: PhotoUploadEntity) : PhotoGridItem(upload.createdAtEpochMillis)
+}
+
+private sealed class PhotoDeleteTarget {
+    data class Server(val photo: RoutePhotoDto) : PhotoDeleteTarget()
+    data class Upload(val upload: PhotoUploadEntity) : PhotoDeleteTarget()
 }
 
 @Composable
@@ -1127,10 +1323,13 @@ private fun PhotoTile(
 @Composable
 private fun PendingPhotoTile(
     upload: PhotoUploadEntity,
+    isDeleting: Boolean,
+    onDelete: (PhotoUploadEntity) -> Unit,
     onRetry: (PhotoUploadEntity) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val status = upload.statusType
+    val canDeleteServerPhoto = confirmedUploadServerPhotoId(upload.status, upload.serverPhotoId) != null
     Box(modifier.aspectRatio(1f).background(TppColors.Panel, RoundedCornerShape(4.dp))) {
         AsyncImage(
             model = File(upload.localPath),
@@ -1139,6 +1338,33 @@ private fun PendingPhotoTile(
             modifier = Modifier.fillMaxSize(),
         )
         Box(Modifier.fillMaxSize().background(Color.Black.copy(alpha = 0.34f)))
+        if (isDeleting) {
+            Box(
+                Modifier.fillMaxSize().background(Color.White.copy(alpha = 0.72f)),
+                contentAlignment = Alignment.Center,
+            ) {
+                Text("Usuwam", color = TppColors.Muted, fontFamily = FontFamily.Monospace, fontWeight = FontWeight.Bold)
+            }
+        }
+        if (canDeleteServerPhoto) {
+            IconButton(
+                onClick = { onDelete(upload) },
+                enabled = !isDeleting,
+                modifier = Modifier
+                    .align(Alignment.TopEnd)
+                    .padding(8.dp)
+                    .size(40.dp)
+                    .background(TppColors.Surface.copy(alpha = 0.96f), RoundedCornerShape(20.dp))
+                    .border(1.dp, TppColors.Error.copy(alpha = 0.35f), RoundedCornerShape(20.dp)),
+            ) {
+                Icon(
+                    Icons.Outlined.Delete,
+                    contentDescription = "Usuń zdjęcie",
+                    tint = TppColors.Error,
+                    modifier = Modifier.size(19.dp),
+                )
+            }
+        }
         Column(
             Modifier.align(Alignment.BottomStart).fillMaxWidth().background(Color.White.copy(alpha = 0.94f)).padding(10.dp),
             verticalArrangement = Arrangement.spacedBy(8.dp),
@@ -1250,6 +1476,36 @@ private fun ErrorText(error: String?) {
     if (!error.isNullOrBlank()) Text(error, color = TppColors.Error, modifier = Modifier.padding(vertical = 8.dp))
 }
 
+@Composable
+private fun OfflineStaleBanner(state: DriverUiState) {
+    if (state.isOnline && !state.isStale) return
+
+    val syncLabel = state.lastSuccessfulSyncAtEpochMillis?.let(::formatSyncTime) ?: "brak zapisanej synchronizacji"
+    Card(
+        colors = CardDefaults.cardColors(containerColor = Color(0xFFFFF7E6)),
+        border = BorderStroke(1.dp, Color(0xFFE6B85C)),
+        shape = RoundedCornerShape(6.dp),
+        modifier = Modifier.fillMaxWidth(),
+    ) {
+        Text(
+            text = if (state.isOnline) {
+                "Dane mogą być nieaktualne. Ostatnia synchronizacja: $syncLabel."
+            } else {
+                "Brak połączenia z serwerem. Dane z $syncLabel mogą być nieaktualne."
+            },
+            color = Color(0xFF5F4200),
+            fontWeight = FontWeight.SemiBold,
+            modifier = Modifier.padding(12.dp),
+        )
+    }
+}
+
+private fun formatSyncTime(epochMillis: Long): String =
+    runCatching {
+        DateTimeFormatter.ofPattern("HH:mm", Locale("pl", "PL"))
+            .format(Instant.ofEpochMilli(epochMillis).atZone(ZoneId.systemDefault()))
+    }.getOrDefault("nieznana godzina")
+
 private fun polishPhoneDigits(value: String): String {
     val digits = value.filter(Char::isDigit)
     val withoutCountryCode = if (digits.length > 9 && digits.startsWith("48")) digits.drop(2) else digits

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

@@ -1,9 +1,29 @@
 package pl.firmatpp.kierowca.ui
 
 import java.time.LocalDate
+import java.time.OffsetDateTime
 
 fun canManageRoutePhotos(selectedDate: String, today: LocalDate = LocalDate.now()): Boolean =
     runCatching { LocalDate.parse(selectedDate).isEqual(today) }.getOrDefault(false)
 
 fun inlinePhotoGridRows(photoCount: Int): Int =
     if (photoCount <= 0) 0 else (photoCount + 1) / 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() }
+
+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,6 +4,7 @@ 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
@@ -11,15 +12,21 @@ import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import java.time.LocalDate
 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.DriverDto
 import pl.firmatpp.kierowca.data.model.DriverRouteDto
 import pl.firmatpp.kierowca.data.model.RoutePhotoDto
 import pl.firmatpp.kierowca.data.upload.PhotoUploadEntity
 import pl.firmatpp.kierowca.data.upload.PhotoUploadOutbox
+import pl.firmatpp.kierowca.sync.DriverLiveSyncClient
+import pl.firmatpp.kierowca.sync.DriverSyncHint
+import pl.firmatpp.kierowca.sync.DriverSyncWorker
 
-enum class DriverScreen { Initializing, Phone, Otp, Routes, Profile, Detail, Photo }
+enum class DriverScreen { Initializing, Phone, Otp, Routes, Profile, Detail, Photo, PhotoQueue }
 
 data class DriverUiState(
     val screen: DriverScreen = DriverScreen.Initializing,
@@ -38,20 +45,50 @@ data class DriverUiState(
     val selectedRoute: DriverRouteDto? = null,
     val selectedPhoto: RoutePhotoDto? = null,
     val photoUploads: List<PhotoUploadEntity> = emptyList(),
+    val queuedPhotoUploads: List<PhotoUploadEntity> = emptyList(),
     val deletingPhotoIds: Set<String> = emptySet(),
     val imageAuthHeader: String? = null,
+    val isOnline: Boolean = true,
+    val isStale: Boolean = false,
+    val lastSuccessfulSyncAtEpochMillis: Long? = null,
     val error: String? = null,
 )
 
 class DriverViewModel(application: Application) : AndroidViewModel(application) {
     private val repository = DriverRepository(application)
+    private val syncRepository = DriverSyncRepository(application, repository)
+    private val networkMonitor = NetworkMonitor(application)
     private val photoUploadOutbox = PhotoUploadOutbox(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 pushTokenRegisteredForDriverId: String? = null
     val state: StateFlow<DriverUiState> = _state
 
     init {
+        viewModelScope.launch {
+            photoUploadOutbox.observeQueuedUploads().collect { uploads ->
+                _state.update { it.copy(queuedPhotoUploads = uploads) }
+            }
+        }
+        viewModelScope.launch {
+            networkMonitor.isOnline.collect { online ->
+                _state.update {
+                    it.copy(
+                        isOnline = online,
+                        isStale = if (!online && it.lastSuccessfulSyncAtEpochMillis != null) true else it.isStale,
+                    )
+                }
+                if (online && repository.hasToken()) {
+                    refreshCurrentScopeFromSyncState()
+                }
+            }
+        }
         viewModelScope.launch {
             if (repository.hasToken()) {
                 refreshRoutes()
@@ -101,7 +138,8 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
             _state.update { it.copy(loading = showLoading, refreshing = !showLoading, error = null) }
 
             runCatching {
-                val response = repository.bootstrap(date)
+                val cached = syncRepository.bootstrap(date)
+                val response = cached.value
                 val settings = response.driverAppSettings
                 _state.update {
                     it.copy(
@@ -114,14 +152,26 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                         autoRefreshSeconds = settings?.autoRefreshSeconds ?: it.autoRefreshSeconds,
                         allowGalleryUploads = settings?.allowGalleryUploads ?: it.allowGalleryUploads,
                         imageAuthHeader = repository.imageAuthHeader(),
+                        isStale = cached.stale || !it.isOnline,
+                        lastSuccessfulSyncAtEpochMillis = cached.syncedAtEpochMillis ?: it.lastSuccessfulSyncAtEpochMillis,
                         error = null,
                     )
                 }
+                response.session.driver.id.let { driverId ->
+                    liveSyncClient.start(driverId)
+                    registerPushTokenIfAvailable(driverId)
+                }
             }.onFailure { throwable ->
                 _state.update {
+                    val apiError = ApiErrorMapper.map(throwable)
                     it.copy(
-                        screen = if (it.screen == DriverScreen.Initializing) DriverScreen.Phone else it.screen,
-                        error = throwable.message ?: "Wystapil blad.",
+                        screen = when {
+                            apiError.kind == ApiErrorKind.Auth -> DriverScreen.Phone
+                            it.screen == DriverScreen.Initializing -> DriverScreen.Routes
+                            else -> it.screen
+                        },
+                        isStale = it.lastSuccessfulSyncAtEpochMillis != null,
+                        error = apiError.message,
                     )
                 }
             }
@@ -133,9 +183,18 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
     }
 
     fun openRoute(routeId: String) = runLoading {
-        val response = repository.route(routeId)
+        val cached = syncRepository.route(routeId)
+        val response = cached.value
         photoUploadOutbox.discardConfirmedServerPhotos(response.route)
-        _state.update { it.copy(screen = DriverScreen.Detail, selectedRoute = response.route, error = null) }
+        _state.update {
+            it.copy(
+                screen = DriverScreen.Detail,
+                selectedRoute = response.route,
+                isStale = cached.stale || !it.isOnline,
+                lastSuccessfulSyncAtEpochMillis = cached.syncedAtEpochMillis ?: it.lastSuccessfulSyncAtEpochMillis,
+                error = null,
+            )
+        }
         observePhotoUploads(routeId)
     }
 
@@ -145,13 +204,16 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         viewModelScope.launch {
             _state.update { it.copy(refreshing = true, error = null) }
 
-            runCatching { repository.route(routeId) }
-                .onSuccess { response ->
+            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,
                         )
                     }
@@ -168,6 +230,10 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         _state.update { it.copy(screen = DriverScreen.Profile, error = null) }
     }
 
+    fun openPhotoQueue() {
+        _state.update { it.copy(screen = DriverScreen.PhotoQueue, error = null) }
+    }
+
     fun uploadPhoto(uri: Uri, source: String, metadata: PhotoUploadMetadata = PhotoUploadMetadata()) {
         val route = _state.value.selectedRoute ?: return
         viewModelScope.launch {
@@ -194,7 +260,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
             _state.update { it.copy(deletingPhotoIds = it.deletingPhotoIds + photo.id, error = null) }
             runCatching {
                 repository.deletePhoto(photo.id)
-                val response = repository.route(route.id)
+                val response = syncRepository.route(route.id).value
                 photoUploadOutbox.discardConfirmedServerPhotos(response.route)
                 _state.update {
                     it.copy(
@@ -210,6 +276,31 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         }
     }
 
+    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.copy(error = ApiErrorMapper.map(throwable).message) }
+            }
+            _state.update { it.copy(deletingPhotoIds = it.deletingPhotoIds - serverPhotoId) }
+        }
+    }
+
     fun openPhoto(photo: RoutePhotoDto) {
         _state.update { it.copy(screen = DriverScreen.Photo, selectedPhoto = photo) }
     }
@@ -218,6 +309,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         _state.update {
             when (it.screen) {
                 DriverScreen.Photo -> it.copy(screen = DriverScreen.Detail, selectedPhoto = null)
+                DriverScreen.PhotoQueue -> it.copy(screen = DriverScreen.Routes)
                 DriverScreen.Detail -> {
                     photoUploadsJob?.cancel()
                     it.copy(screen = DriverScreen.Routes, selectedRoute = null, photoUploads = emptyList())
@@ -231,7 +323,10 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
 
     fun logout() = runLoading {
         photoUploadsJob?.cancel()
+        liveSyncClient.stop()
         repository.logout()
+        syncRepository.clearCache()
+        pushTokenRegisteredForDriverId = null
         _state.update { DriverUiState(screen = DriverScreen.Phone, loading = false) }
     }
 
@@ -254,4 +349,71 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
             }
         }
     }
+
+    private fun refreshCurrentScopeFromSyncState() {
+        val snapshot = _state.value
+        if (snapshot.screen == DriverScreen.Routes) {
+            refreshRoutesSilently()
+            return
+        }
+        if (snapshot.screen == DriverScreen.Detail) {
+            refreshSelectedRoute()
+        }
+    }
+
+    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 (hint.date == null || hint.date == snapshot.selectedDate) {
+                    refreshRoutesSilently()
+                } 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()
+        }
+    }
+
+    private fun registerPushTokenIfAvailable(driverId: String) {
+        if (pushTokenRegisteredForDriverId == driverId) return
+
+        runCatching {
+            FirebaseMessaging.getInstance().token.addOnSuccessListener { token ->
+                viewModelScope.launch {
+                    runCatching {
+                        repository.storePushToken(token)
+                        pushTokenRegisteredForDriverId = driverId
+                    }
+                }
+            }
+        }
+    }
+
+    override fun onCleared() {
+        liveSyncClient.close()
+        super.onCleared()
+    }
 }

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

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
-    <solid android:color="#F7FAF8" />
+    <solid android:color="#07172B" />
 </shape>

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

@@ -30,4 +30,61 @@ class DriverUiRulesTest {
         assertEquals(2, inlinePhotoGridRows(3))
         assertEquals(3, inlinePhotoGridRows(5))
     }
+
+    @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"))
+    }
 }

build.gradle.kts

@@ -2,4 +2,5 @@ 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
 }

gradle/libs.versions.toml

@@ -18,6 +18,8 @@ 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"
 
 [libraries]
 activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
@@ -51,9 +53,12 @@ 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" }
 
 [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" }