Add Firebase Crashlytics diagnostics

app/build.gradle.kts

@@ -10,6 +10,7 @@ plugins {
 
 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")
@@ -33,8 +34,8 @@ android {
         applicationId = "pl.firmatpp.kierowca"
         minSdk = 26
         targetSdk = 35
-        versionCode = 38
-        versionName = "1.0.37"
+        versionCode = 42
+        versionName = "1.0.41"
         setProperty("archivesBaseName", "pl.firmatpp.kierowca")
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
 
@@ -123,6 +124,7 @@ dependencies {
     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)

app/src/main/AndroidManifest.xml

@@ -10,6 +10,7 @@
         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">

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

@@ -13,14 +13,20 @@ 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()
-                DriverApp(viewModel = viewModel, initialRouteId = notificationRouteId)
+                DriverApp(
+                    viewModel = viewModel,
+                    initialRouteId = notificationRouteId,
+                    initialLeaveRequestId = notificationLeaveRequestId,
+                )
             }
         }
     }
@@ -29,9 +35,11 @@ class MainActivity : ComponentActivity() {
         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/DriverRepository.kt

@@ -14,8 +14,11 @@ 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
@@ -51,6 +54,18 @@ class DriverRepository(
     suspend fun route(routeId: String): RouteResponse =
         api.route(authHeader(requireToken()), routeId)
 
+    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)
 

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

@@ -5,8 +5,13 @@ 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
@@ -56,6 +61,35 @@ interface MobileDriverApi {
         @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,

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

@@ -65,6 +65,12 @@ data class DriverAppSettingsDto(
     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(
@@ -157,6 +163,58 @@ 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,

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

@@ -151,5 +151,6 @@ class DriverSyncRepository(
         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/upload/DispatchSheetUploadWorker.kt

@@ -8,6 +8,7 @@ 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,
@@ -64,6 +65,17 @@ class DispatchSheetUploadWorker(
             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,

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

@@ -8,6 +8,7 @@ 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,
@@ -64,6 +65,18 @@ class PhotoUploadWorker(
             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,

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

@@ -31,6 +31,21 @@ class DriverFirebaseMessagingService : FirebaseMessagingService() {
             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(

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

@@ -17,6 +17,7 @@ import okhttp3.WebSocket
 import okhttp3.WebSocketListener
 import pl.firmatpp.kierowca.data.DriverRepository
 import pl.firmatpp.kierowca.data.model.RealtimeConfigDto
+import pl.firmatpp.kierowca.diagnostics.AppDiagnostics
 
 class DriverLiveSyncClient(
     private val repository: DriverRepository,
@@ -66,6 +67,7 @@ class DriverLiveSyncClient(
 
                 override fun onFailure(webSocket: WebSocket, t: Throwable, response: okhttp3.Response?) {
                     stopHeartbeat()
+                    AppDiagnostics.log("realtime_error: ${t.message ?: response?.message ?: "unknown"}")
                     reportRealtimeStatus("error", t.message ?: response?.message)
                     started.set(false)
                     scheduleReconnect()

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

@@ -14,6 +14,7 @@ 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,
@@ -47,6 +48,10 @@ class DriverSyncWorker(
                             syncRepository.bootstrap(scope.date ?: date)
                             refreshed = true
                         }
+                        DriverSyncRepository.SCOPE_LEAVE_REQUESTS -> {
+                            syncRepository.saveSyncStates(response)
+                            refreshed = true
+                        }
                     }
                 }
             }
@@ -58,6 +63,18 @@ class DriverSyncWorker(
             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()
         }
 

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

@@ -26,6 +26,7 @@ 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(
@@ -76,6 +77,17 @@ class NewRouteNotificationWorker(
                 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()
             }
         }

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

@@ -74,6 +74,8 @@ import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.DatePickerDialog
+import androidx.compose.material3.DateRangePicker
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
@@ -86,6 +88,7 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.rememberDateRangePickerState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
@@ -127,12 +130,14 @@ import java.io.File
 import java.time.Instant
 import java.time.LocalDate
 import java.time.ZoneId
+import java.time.ZoneOffset
 import java.time.format.DateTimeFormatter
 import kotlinx.coroutines.delay
 import java.util.Locale
 import pl.firmatpp.kierowca.R
 import pl.firmatpp.kierowca.data.PhotoUploadMetadata
 import pl.firmatpp.kierowca.data.model.DispatchSheetReminderDto
+import pl.firmatpp.kierowca.data.model.DriverLeaveRequestDto
 import pl.firmatpp.kierowca.data.model.DriverRouteDto
 import pl.firmatpp.kierowca.data.model.NavigationPointDto
 import pl.firmatpp.kierowca.data.model.RoutePhotoDto
@@ -144,7 +149,7 @@ import pl.firmatpp.kierowca.domain.RouteDisplayMapper
 import pl.firmatpp.kierowca.ui.theme.TppColors
 
 @Composable
-fun DriverApp(viewModel: DriverViewModel, initialRouteId: String? = null) {
+fun DriverApp(viewModel: DriverViewModel, initialRouteId: String? = null, initialLeaveRequestId: String? = null) {
     val state by viewModel.state.collectAsState()
     val lifecycleOwner = LocalLifecycleOwner.current
     val context = LocalContext.current
@@ -192,6 +197,11 @@ fun DriverApp(viewModel: DriverViewModel, initialRouteId: String? = null) {
     LaunchedEffect(initialRouteId) {
         viewModel.openRouteFromNotification(initialRouteId)
     }
+    LaunchedEffect(initialLeaveRequestId, state.leaveRequestsConfig) {
+        if (!initialLeaveRequestId.isNullOrBlank() && DriverLeaveRequestUiRules.isFeatureVisible(state.leaveRequestsConfig)) {
+            viewModel.openLeaveRequest(initialLeaveRequestId)
+        }
+    }
 
     Box(Modifier.fillMaxSize().background(TppColors.Surface)) {
         when (state.screen) {
@@ -213,6 +223,7 @@ fun DriverApp(viewModel: DriverViewModel, initialRouteId: String? = null) {
                 onRoutes = viewModel::refreshRoutes,
                 onProfile = viewModel::openProfile,
                 onLogout = viewModel::logout,
+                onLeaveRequests = viewModel::openLeaveRequests,
                 onNewRouteNotificationsChanged = { enabled ->
                     if (!enabled) {
                         viewModel.updateNewRouteNotifications(false)
@@ -243,6 +254,24 @@ fun DriverApp(viewModel: DriverViewModel, initialRouteId: String? = null) {
                 onBack = viewModel::back,
                 onRetryUpload = viewModel::retryPhotoUpload,
             )
+            DriverScreen.LeaveRequests -> LeaveRequestsScreen(
+                state = state,
+                onBack = viewModel::back,
+                onRefresh = viewModel::refreshLeaveRequests,
+                onAdd = viewModel::openAddLeaveRequest,
+                onOpen = viewModel::openLeaveRequest,
+            )
+            DriverScreen.LeaveRequestDetail -> LeaveRequestDetailScreen(
+                state = state,
+                onBack = viewModel::back,
+                onCancel = viewModel::cancelSelectedLeaveRequest,
+            )
+            DriverScreen.AddLeaveRequest -> AddLeaveRequestScreen(
+                state = state,
+                onBack = viewModel::back,
+                onDraft = viewModel::updateLeaveRequestDraft,
+                onSubmit = viewModel::submitLeaveRequest,
+            )
         }
 
         if (state.loading && state.screen != DriverScreen.Initializing) {
@@ -761,6 +790,420 @@ private fun RouteDayLiveUpdateBanner(message: String?, modifier: Modifier = Modi
     }
 }
 
+@Composable
+private fun LeaveRequestsEntryCard(requests: List<DriverLeaveRequestDto>, onOpen: () -> Unit) {
+    val decisionCount = requests.count { it.status == "pending" || it.status == "cancel_requested" }
+    Card(
+        colors = CardDefaults.cardColors(containerColor = Color.White),
+        border = BorderStroke(1.dp, TppColors.Outline),
+        shape = RoundedCornerShape(8.dp),
+        modifier = Modifier.fillMaxWidth().clickable(onClick = onOpen),
+    ) {
+        Row(
+            Modifier.fillMaxWidth().padding(16.dp),
+            horizontalArrangement = Arrangement.spacedBy(12.dp),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Box(Modifier.size(44.dp).background(Color(0xFFEAF7EF), RoundedCornerShape(8.dp)), contentAlignment = Alignment.Center) {
+                Icon(Icons.Outlined.CalendarToday, contentDescription = null, tint = TppColors.Forest)
+            }
+            Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(3.dp)) {
+                Text("Wnioski urlopowe", color = TppColors.Ink, fontWeight = FontWeight.Bold, fontSize = 18.sp)
+                Text(
+                    if (decisionCount > 0) "$decisionCount czeka na decyzję" else "Lista, status i nowy wniosek",
+                    color = TppColors.Muted,
+                    fontSize = 14.sp,
+                )
+            }
+            Text("Otwórz", color = TppColors.Forest, fontWeight = FontWeight.Bold)
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterialApi::class)
+@Composable
+private fun LeaveRequestsScreen(
+    state: DriverUiState,
+    onBack: () -> Unit,
+    onRefresh: () -> Unit,
+    onAdd: () -> Unit,
+    onOpen: (String) -> Unit,
+) {
+    val pullRefreshState = rememberPullRefreshState(state.refreshing, onRefresh)
+    Scaffold(
+        topBar = { SimpleTopBar("Wnioski urlopowe", onBack) },
+        containerColor = TppColors.Surface,
+    ) { padding ->
+        Box(Modifier.fillMaxSize().padding(padding).pullRefresh(pullRefreshState)) {
+            LazyColumn(
+                Modifier.fillMaxSize(),
+                contentPadding = PaddingValues(20.dp),
+                verticalArrangement = Arrangement.spacedBy(12.dp),
+            ) {
+                item { FeedbackAndError(state.feedback, state.error) }
+                item {
+                    Button(
+                        onClick = onAdd,
+                        modifier = Modifier.fillMaxWidth().height(56.dp),
+                        colors = ButtonDefaults.buttonColors(containerColor = TppColors.Forest),
+                        shape = RoundedCornerShape(8.dp),
+                    ) {
+                        Icon(Icons.Outlined.CalendarToday, contentDescription = null)
+                        Spacer(Modifier.width(8.dp))
+                        Text("Nowy wniosek", fontWeight = FontWeight.Bold)
+                    }
+                }
+                if (state.leaveRequests.isEmpty()) {
+                    item { EmptyState("Nie masz jeszcze wniosków urlopowych") }
+                } else {
+                    items(state.leaveRequests, key = { it.id }) { request ->
+                        LeaveRequestCard(request, onClick = { onOpen(request.id) })
+                    }
+                }
+            }
+            PullRefreshIndicator(
+                refreshing = state.refreshing,
+                state = pullRefreshState,
+                modifier = Modifier.align(Alignment.TopCenter),
+                backgroundColor = Color.White,
+                contentColor = TppColors.Forest,
+            )
+        }
+    }
+}
+
+@Composable
+private fun LeaveRequestCard(request: DriverLeaveRequestDto, onClick: () -> Unit) {
+    Card(
+        colors = CardDefaults.cardColors(containerColor = Color.White),
+        border = BorderStroke(1.dp, TppColors.Outline),
+        shape = RoundedCornerShape(8.dp),
+        modifier = Modifier.fillMaxWidth().clickable(onClick = onClick),
+    ) {
+        Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(10.dp)) {
+            Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.Top) {
+                Column(Modifier.weight(1f)) {
+                    Text(
+                        "${DriverLeaveRequestUiRules.typeLabel(request.type)} · ${leaveDateRange(request.dateFrom, request.dateTo)}",
+                        color = TppColors.Ink,
+                        fontWeight = FontWeight.Bold,
+                        fontSize = 17.sp,
+                    )
+                    if (!request.note.isNullOrBlank()) {
+                        Text(request.note, color = TppColors.Muted, maxLines = 2, overflow = TextOverflow.Ellipsis)
+                    }
+                }
+                LeaveStatusPill(request.status)
+            }
+            Text("Szczegóły", color = TppColors.Forest, fontWeight = FontWeight.Bold, fontSize = 14.sp)
+        }
+    }
+}
+
+@Composable
+private fun LeaveRequestDetailScreen(
+    state: DriverUiState,
+    onBack: () -> Unit,
+    onCancel: () -> Unit,
+) {
+    val request = state.selectedLeaveRequest
+    Scaffold(topBar = { SimpleTopBar("Szczegóły wniosku", onBack) }, containerColor = TppColors.Surface) { padding ->
+        if (request == null) {
+            Box(Modifier.fillMaxSize().padding(padding), contentAlignment = Alignment.Center) {
+                Text("Nie znaleziono wniosku", color = TppColors.Muted)
+            }
+            return@Scaffold
+        }
+
+        LazyColumn(
+            Modifier.fillMaxSize().padding(padding),
+            contentPadding = PaddingValues(20.dp),
+            verticalArrangement = Arrangement.spacedBy(14.dp),
+        ) {
+            item { FeedbackAndError(state.feedback, state.error) }
+            item {
+                Card(
+                    colors = CardDefaults.cardColors(containerColor = Color.White),
+                    border = BorderStroke(1.dp, TppColors.Outline),
+                    shape = RoundedCornerShape(8.dp),
+                ) {
+                    Column(Modifier.padding(18.dp), verticalArrangement = Arrangement.spacedBy(14.dp)) {
+                        Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.Top) {
+                            Text(DriverLeaveRequestUiRules.typeLabel(request.type), color = TppColors.Ink, fontWeight = FontWeight.Bold, fontSize = 22.sp)
+                            LeaveStatusPill(request.status)
+                        }
+                        DetailLine("Zakres", leaveDateRange(request.dateFrom, request.dateTo))
+                        DetailLine("Złożono", request.submittedAt?.let(::shortDateTime) ?: "-")
+                        DetailLine("Decyzja", request.decidedAt?.let(::shortDateTime) ?: "-")
+                        DetailLine("Notatka", request.note ?: "-")
+                        DetailLine("Komentarz", request.decisionComment ?: "-")
+                        if (DriverLeaveRequestUiRules.canCancel(request.status, request.dateFrom.orEmpty())) {
+                            Button(
+                                onClick = onCancel,
+                                modifier = Modifier.fillMaxWidth().height(54.dp),
+                                colors = ButtonDefaults.buttonColors(containerColor = Color(0xFFB45309)),
+                                shape = RoundedCornerShape(8.dp),
+                            ) {
+                                Text(if (request.status == "approved") "Poproś o anulowanie" else "Anuluj wniosek")
+                            }
+                        }
+                    }
+                }
+            }
+            item {
+                Text("Historia", color = TppColors.Ink, fontWeight = FontWeight.Bold, fontSize = 18.sp)
+            }
+            items(request.events, key = { it.id }) { event ->
+                Card(
+                    colors = CardDefaults.cardColors(containerColor = Color.White),
+                    border = BorderStroke(1.dp, TppColors.Outline.copy(alpha = 0.65f)),
+                    shape = RoundedCornerShape(8.dp),
+                ) {
+                    Column(Modifier.padding(14.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) {
+                        Text(
+                            "${DriverLeaveRequestUiRules.eventActionLabel(event.action)}${event.toStatus?.let { " · ${DriverLeaveRequestUiRules.statusLabel(it)}" } ?: ""}",
+                            color = TppColors.Ink,
+                            fontWeight = FontWeight.Bold,
+                        )
+                        Text(event.createdAt?.let(::shortDateTime) ?: "-", color = TppColors.Muted, fontSize = 13.sp)
+                        if (!event.comment.isNullOrBlank()) Text(event.comment, color = TppColors.Muted)
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun AddLeaveRequestScreen(
+    state: DriverUiState,
+    onBack: () -> Unit,
+    onDraft: (String?, String?, String?, String?) -> Unit,
+    onSubmit: () -> Unit,
+) {
+    var showDateRangePicker by remember { mutableStateOf(false) }
+    val selectedStartMillis = remember(state.leaveRequestDateFrom) {
+        localDateStringToUtcMillis(state.leaveRequestDateFrom)
+    }
+    val selectedEndMillis = remember(state.leaveRequestDateTo) {
+        localDateStringToUtcMillis(state.leaveRequestDateTo)
+    }
+    val dateRangePickerState = rememberDateRangePickerState(
+        initialSelectedStartDateMillis = selectedStartMillis,
+        initialSelectedEndDateMillis = selectedEndMillis,
+    )
+
+    Scaffold(topBar = { SimpleTopBar("Nowy wniosek", onBack) }, containerColor = TppColors.Surface) { padding ->
+        LazyColumn(
+            Modifier.fillMaxSize().padding(padding),
+            contentPadding = PaddingValues(20.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            item { FeedbackAndError(null, state.error) }
+            item {
+                Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
+                    Text("Typ", color = TppColors.Ink, fontWeight = FontWeight.Bold)
+                    LazyRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                        items(state.leaveRequestsConfig?.types.orEmpty()) { type ->
+                            val active = type == state.leaveRequestType
+                            Button(
+                                onClick = { onDraft(null, null, type, null) },
+                                colors = ButtonDefaults.buttonColors(
+                                    containerColor = if (active) TppColors.Forest else Color.White,
+                                    contentColor = if (active) Color.White else TppColors.Ink,
+                                ),
+                                border = BorderStroke(1.dp, if (active) TppColors.Forest else TppColors.Outline),
+                                shape = RoundedCornerShape(8.dp),
+                            ) {
+                                Text(DriverLeaveRequestUiRules.typeLabel(type))
+                            }
+                        }
+                    }
+                }
+            }
+            item {
+                Card(
+                    colors = CardDefaults.cardColors(containerColor = Color.White),
+                    border = BorderStroke(1.dp, TppColors.Outline),
+                    shape = RoundedCornerShape(8.dp),
+                    modifier = Modifier.fillMaxWidth().clickable { showDateRangePicker = true },
+                ) {
+                    Row(
+                        Modifier.fillMaxWidth().padding(16.dp),
+                        horizontalArrangement = Arrangement.spacedBy(12.dp),
+                        verticalAlignment = Alignment.CenterVertically,
+                    ) {
+                        Box(
+                            Modifier.size(44.dp).background(Color(0xFFEAF7EF), RoundedCornerShape(8.dp)),
+                            contentAlignment = Alignment.Center,
+                        ) {
+                            Icon(Icons.Outlined.CalendarToday, contentDescription = null, tint = TppColors.Forest)
+                        }
+                        Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(4.dp)) {
+                            Text("Okres", color = TppColors.Ink, fontWeight = FontWeight.Bold)
+                            Text(
+                                leaveDateRange(state.leaveRequestDateFrom, state.leaveRequestDateTo),
+                                color = TppColors.Muted,
+                            )
+                        }
+                        Text("Zmień", color = TppColors.Forest, fontWeight = FontWeight.Bold)
+                    }
+                }
+            }
+            item {
+                LeaveTextField(
+                    label = "Notatka (opcjonalnie)",
+                    value = state.leaveRequestNote,
+                    onValue = { onDraft(null, null, null, it) },
+                    minLines = 4,
+                )
+            }
+            item {
+                Button(
+                    onClick = onSubmit,
+                    modifier = Modifier.fillMaxWidth().height(58.dp),
+                    colors = ButtonDefaults.buttonColors(containerColor = TppColors.Forest),
+                    shape = RoundedCornerShape(8.dp),
+                ) {
+                    Text("Wyślij wniosek", fontWeight = FontWeight.Bold)
+                }
+            }
+        }
+    }
+
+    if (showDateRangePicker) {
+        DatePickerDialog(
+            onDismissRequest = { showDateRangePicker = false },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        val start = dateRangePickerState.selectedStartDateMillis
+                        val end = dateRangePickerState.selectedEndDateMillis ?: start
+                        if (start != null && end != null) {
+                            onDraft(utcMillisToLocalDateString(start), utcMillisToLocalDateString(end), null, null)
+                        }
+                        showDateRangePicker = false
+                    },
+                    enabled = dateRangePickerState.selectedStartDateMillis != null,
+                ) {
+                    Text("Ustaw", color = TppColors.Forest, fontWeight = FontWeight.Bold)
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { showDateRangePicker = false }) {
+                    Text("Anuluj", color = TppColors.Muted)
+                }
+            },
+        ) {
+            DateRangePicker(
+                state = dateRangePickerState,
+                title = {
+                    Text(
+                        "Wybierz okres urlopu",
+                        modifier = Modifier.padding(start = 24.dp, end = 12.dp, top = 16.dp),
+                        color = TppColors.Ink,
+                        fontWeight = FontWeight.Bold,
+                    )
+                },
+                headline = {
+                    Text(
+                        leaveDateRange(
+                            dateRangePickerState.selectedStartDateMillis?.let(::utcMillisToLocalDateString),
+                            dateRangePickerState.selectedEndDateMillis?.let(::utcMillisToLocalDateString),
+                        ),
+                        modifier = Modifier.padding(start = 24.dp, end = 12.dp, bottom = 12.dp),
+                        color = TppColors.Muted,
+                    )
+                },
+                showModeToggle = false,
+            )
+        }
+    }
+}
+
+@Composable
+private fun SimpleTopBar(title: String, onBack: () -> Unit) {
+    Row(
+        Modifier
+            .fillMaxWidth()
+            .statusBarsPadding()
+            .background(Color.White)
+            .border(0.5.dp, TppColors.Outline.copy(alpha = 0.65f))
+            .padding(horizontal = 10.dp, vertical = 8.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        IconButton(onClick = onBack, modifier = Modifier.size(48.dp)) {
+            Icon(Icons.Outlined.ArrowBack, contentDescription = "Wstecz", tint = TppColors.Ink)
+        }
+        Text(title, color = TppColors.Ink, fontWeight = FontWeight.Bold, fontSize = 20.sp)
+    }
+}
+
+@Composable
+private fun LeaveStatusPill(status: String) {
+    val color = when (status) {
+        "approved" -> Color(0xFFEAF7EF) to TppColors.Forest
+        "rejected" -> Color(0xFFFFEBEE) to Color(0xFFB91C1C)
+        "cancel_requested" -> Color(0xFFFFF7ED) to Color(0xFFB45309)
+        "cancelled", "revoked" -> Color(0xFFF1F5F9) to Color(0xFF475569)
+        else -> Color(0xFFFFF8DB) to Color(0xFF7A5A00)
+    }
+    Text(
+        DriverLeaveRequestUiRules.statusLabel(status),
+        color = color.second,
+        fontWeight = FontWeight.Bold,
+        fontSize = 12.sp,
+        modifier = Modifier.background(color.first, RoundedCornerShape(999.dp)).padding(horizontal = 10.dp, vertical = 6.dp),
+    )
+}
+
+@Composable
+private fun DetailLine(label: String, value: String) {
+    Column(verticalArrangement = Arrangement.spacedBy(3.dp)) {
+        Text(label.uppercase(Locale("pl", "PL")), color = TppColors.Muted, fontSize = 12.sp, fontWeight = FontWeight.Bold)
+        Text(value, color = TppColors.Ink, fontSize = 16.sp)
+    }
+}
+
+@Composable
+private fun FeedbackAndError(feedback: String?, error: String?) {
+    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        if (!feedback.isNullOrBlank()) {
+            Text(feedback, color = TppColors.Forest, fontWeight = FontWeight.Bold)
+        }
+        ErrorText(error)
+    }
+}
+
+@Composable
+private fun LeaveTextField(label: String, value: String, onValue: (String) -> Unit, minLines: Int = 1) {
+    OutlinedTextField(
+        value = value,
+        onValueChange = onValue,
+        label = { Text(label) },
+        minLines = minLines,
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(8.dp),
+    )
+}
+
+private fun leaveDateRange(from: String?, to: String?): String =
+    if (from == to) from ?: "-" else "${from ?: "?"} - ${to ?: "?"}"
+
+private fun localDateStringToUtcMillis(value: String): Long? =
+    runCatching {
+        LocalDate.parse(value).atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli()
+    }.getOrNull()
+
+private fun utcMillisToLocalDateString(value: Long): String =
+    Instant.ofEpochMilli(value).atZone(ZoneOffset.UTC).toLocalDate().toString()
+
+private fun shortDateTime(value: String): String =
+    runCatching {
+        DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm", Locale("pl", "PL"))
+            .format(Instant.parse(value).atZone(ZoneId.systemDefault()))
+    }.getOrDefault(value)
+
 @Composable
 private fun DispatchSheetReminderCard(
     reminder: DispatchSheetReminderDto?,
@@ -1219,6 +1662,7 @@ private fun ProfileScreen(
     onRoutes: () -> Unit,
     onProfile: () -> Unit,
     onLogout: () -> Unit,
+    onLeaveRequests: () -> Unit,
     onNewRouteNotificationsChanged: (Boolean) -> Unit,
     onOpenNotificationSettings: () -> Unit,
 ) {
@@ -1263,6 +1707,9 @@ private fun ProfileScreen(
                         )
                     }
                 }
+                if (DriverLeaveRequestUiRules.isFeatureVisible(state.leaveRequestsConfig)) {
+                    LeaveRequestsEntryCard(state.leaveRequests, onLeaveRequests)
+                }
                 Card(
                     modifier = Modifier.fillMaxWidth(),
                     colors = CardDefaults.cardColors(containerColor = Color.White),

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

@@ -19,17 +19,19 @@ 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
 
-enum class DriverScreen { Initializing, Phone, Otp, Routes, Profile, Detail, Photo, PhotoQueue }
+enum class DriverScreen { Initializing, Phone, Otp, Routes, Profile, Detail, Photo, PhotoQueue, LeaveRequests, LeaveRequestDetail, AddLeaveRequest }
 
 data class DriverUiState(
     val screen: DriverScreen = DriverScreen.Initializing,
@@ -55,6 +57,13 @@ data class DriverUiState(
     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,
@@ -112,7 +121,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         }
     }
 
-    fun requestOtp(phone: String) = runLoading {
+    fun requestOtp(phone: String) = runLoading("request_otp") {
         val response = repository.requestOtp(phone)
         otpAutoSubmitPolicy.reset()
         _state.update {
@@ -126,8 +135,9 @@ 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()
     }
@@ -162,9 +172,9 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                 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,
@@ -176,6 +186,13 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                         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,
@@ -189,6 +206,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                 }
                 observeDispatchSheetUploads(response.dispatchSheetReminder?.workDate)
             }.onFailure { throwable ->
+                reportHandledException("load_routes", throwable, mapOf("date" to date))
                 _state.update {
                     val apiError = ApiErrorMapper.map(throwable)
                     it.copy(
@@ -209,7 +227,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         }
     }
 
-    fun openRoute(routeId: String) = runLoading {
+    fun openRoute(routeId: String) = runLoading("open_route", mapOf("route_id" to routeId)) {
         val cached = syncRepository.route(routeId)
         val response = cached.value
         photoUploadOutbox.discardConfirmedServerPhotos(response.route)
@@ -292,6 +310,135 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         _state.update { it.copy(screen = DriverScreen.PhotoQueue, error = null) }
     }
 
+    fun openLeaveRequests() {
+        if (!DriverLeaveRequestUiRules.isFeatureVisible(_state.value.leaveRequestsConfig)) return
+        loadLeaveRequests(showLoading = true)
+    }
+
+    fun refreshLeaveRequests() {
+        if (!DriverLeaveRequestUiRules.isFeatureVisible(_state.value.leaveRequestsConfig)) return
+        loadLeaveRequests(showLoading = false)
+    }
+
+    private fun loadLeaveRequests(showLoading: Boolean) {
+        viewModelScope.launch {
+            _state.update { it.copy(loading = showLoading, refreshing = !showLoading, error = null, feedback = null) }
+            runCatching { repository.leaveRequests() }
+                .onSuccess { requests ->
+                    _state.update {
+                        it.copy(
+                            screen = DriverScreen.LeaveRequests,
+                            leaveRequests = requests,
+                            selectedLeaveRequest = requests.firstOrNull { request -> request.id == it.selectedLeaveRequest?.id } ?: it.selectedLeaveRequest,
+                            error = null,
+                        )
+                    }
+                }
+                .onFailure { throwable -> _state.update { it.copy(error = ApiErrorMapper.map(throwable).message) } }
+            _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.copy(error = ApiErrorMapper.map(throwable).message) } }
+            _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.copy(error = ApiErrorMapper.map(throwable).message) }
+            }
+            _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.copy(error = ApiErrorMapper.map(throwable).message) } }
+            _state.update { it.copy(loading = false) }
+        }
+    }
+
     fun uploadPhoto(uri: Uri, source: String, metadata: PhotoUploadMetadata = PhotoUploadMetadata()) {
         val route = _state.value.selectedRoute ?: return
         viewModelScope.launch {
@@ -425,6 +572,9 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
             when (it.screen) {
                 DriverScreen.Photo -> it.copy(screen = DriverScreen.Detail, selectedPhoto = null)
                 DriverScreen.PhotoQueue -> it.copy(screen = DriverScreen.Routes)
+                DriverScreen.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)
@@ -436,21 +586,27 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         }
     }
 
-    fun logout() = runLoading {
+    fun logout() = runLoading("logout") {
         photoUploadsJob?.cancel()
         dispatchSheetUploadsJob?.cancel()
         liveSyncClient.stop()
         repository.logout()
         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 ->
+                    reportHandledException(operation, throwable, keys)
                     _state.update { it.copy(error = ApiErrorMapper.map(throwable).message) }
                 }
             _state.update { it.copy(loading = false) }
@@ -489,6 +645,9 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         if (snapshot.screen == DriverScreen.Detail) {
             refreshSelectedRoute()
         }
+        if (snapshot.screen == DriverScreen.LeaveRequests || snapshot.screen == DriverScreen.LeaveRequestDetail) {
+            refreshLeaveRequests()
+        }
     }
 
     private suspend fun checkRemoteSyncState() {
@@ -530,6 +689,11 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
             }
             DriverSyncRepository.SCOPE_SETTINGS -> refreshRoutesSilently()
             DriverSyncRepository.SCOPE_DISPATCH_SHEET -> refreshRoutesSilently()
+            DriverSyncRepository.SCOPE_LEAVE_REQUESTS -> {
+                if (snapshot.screen == DriverScreen.LeaveRequests || snapshot.screen == DriverScreen.LeaveRequestDetail) {
+                    refreshLeaveRequests()
+                }
+            }
         }
     }
 
@@ -542,10 +706,35 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
                     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)
+        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() {

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/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))
+    }
+}

build.gradle.kts

@@ -3,4 +3,5 @@ plugins {
     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

@@ -20,6 +20,7 @@ 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" }
@@ -55,6 +56,7 @@ retrofit = { group = "com.squareup.retrofit2", name = "retrofit", version.ref =
 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" }
@@ -62,3 +64,4 @@ 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" }