Dodaj odswiezanie i wybor daty kursow

app/build.gradle.kts

@@ -12,8 +12,8 @@ android {
         applicationId = "pl.firmatpp.kierowca"
         minSdk = 26
         targetSdk = 35
-        versionCode = 1
-        versionName = "1.0.0"
+        versionCode = 6
+        versionName = "1.0.5"
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
 
         buildConfigField("String", "API_BASE_URL", "\"https://api-intranet.firmatpp.pl/api/\"")
@@ -64,6 +64,7 @@ dependencies {
     implementation(libs.camera.view)
     implementation(libs.coil.compose)
     implementation(libs.compose.material.icons.extended)
+    implementation("androidx.compose.material:material")
     implementation(libs.compose.material3)
     implementation(libs.compose.ui)
     implementation(libs.compose.ui.graphics)
@@ -71,6 +72,8 @@ dependencies {
     implementation(libs.coroutines.android)
     implementation(libs.okhttp)
     implementation(libs.okhttp.logging)
+    implementation(libs.play.services.auth)
+    implementation(libs.play.services.auth.api.phone)
     implementation(libs.retrofit)
     implementation(libs.retrofit.gson)
 

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

@@ -30,8 +30,8 @@ class DriverRepository(
         return response.driver ?: error("Brak danych kierowcy.")
     }
 
-    suspend fun bootstrap(): BootstrapResponse =
-        api.bootstrap(authHeader(requireToken()))
+    suspend fun bootstrap(date: String? = null): BootstrapResponse =
+        api.bootstrap(authHeader(requireToken()), date)
 
     suspend fun route(routeId: String): RouteResponse =
         api.route(authHeader(requireToken()), routeId)

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

@@ -16,6 +16,7 @@ import retrofit2.http.Multipart
 import retrofit2.http.POST
 import retrofit2.http.Part
 import retrofit2.http.Path
+import retrofit2.http.Query
 
 interface MobileDriverApi {
     @POST("mobile/driver/auth/request-otp")
@@ -28,7 +29,10 @@ interface MobileDriverApi {
     suspend fun logout(@Header("Authorization") authorization: String): Map<String, Boolean>
 
     @GET("mobile/driver/bootstrap")
-    suspend fun bootstrap(@Header("Authorization") authorization: String): BootstrapResponse
+    suspend fun bootstrap(
+        @Header("Authorization") authorization: String,
+        @Query("date") date: String?,
+    ): BootstrapResponse
 
     @GET("mobile/driver/routes/{routeId}")
     suspend fun route(

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

@@ -30,6 +30,16 @@ data class DriverDto(
 data class BootstrapResponse(
     val session: DriverSessionDto,
     val routes: RoutesBucketDto,
+    val driverAppSettings: DriverAppSettingsDto?,
+)
+
+data class DriverAppSettingsDto(
+    val minDate: String,
+    val maxDate: String,
+    val today: String,
+    val selectedDate: String,
+    val maxPastDays: Int,
+    val autoRefreshSeconds: Int,
 )
 
 data class DriverSessionDto(

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

@@ -0,0 +1,8 @@
+package pl.firmatpp.kierowca.domain
+
+object OtpCodeExtractor {
+    private val codePattern = Regex("""(?<!\d)\d{4,10}(?!\d)""")
+
+    fun extract(message: String): String? =
+        codePattern.find(message)?.value
+}

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

@@ -1,27 +1,43 @@
 package pl.firmatpp.kierowca.ui
 
+import android.Manifest
+import android.app.Activity
+import android.content.BroadcastReceiver
 import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageManager
 import android.net.Uri
-import androidx.activity.compose.ManagedActivityResultLauncher
+import android.os.Build
+import androidx.activity.compose.BackHandler
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.PickVisualMediaRequest
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.BorderStroke
+import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.IntrinsicSize
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxHeight
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.navigationBarsPadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.statusBarsPadding
+import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyRow
 import androidx.compose.foundation.lazy.grid.GridCells
 import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
 import androidx.compose.foundation.lazy.grid.items
@@ -31,16 +47,21 @@ import androidx.compose.material.icons.Icons
 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.LocalShipping
-import androidx.compose.material.icons.outlined.Logout
+import androidx.compose.material.icons.outlined.Person
 import androidx.compose.material.icons.outlined.Phone
-import androidx.compose.material.icons.outlined.Refresh
+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.Button
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
@@ -50,6 +71,7 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
@@ -59,31 +81,86 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.ui.unit.dp
+import androidx.core.content.ContextCompat
 import androidx.core.content.FileProvider
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.compose.LocalLifecycleOwner
 import coil.compose.AsyncImage
 import coil.request.ImageRequest
+import com.google.android.gms.auth.api.phone.SmsRetriever
+import com.google.android.gms.common.api.CommonStatusCodes
+import com.google.android.gms.common.api.Status
 import java.io.File
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+import kotlinx.coroutines.delay
+import java.util.Locale
+import pl.firmatpp.kierowca.R
 import pl.firmatpp.kierowca.data.model.DriverRouteDto
 import pl.firmatpp.kierowca.data.model.RoutePhotoDto
+import pl.firmatpp.kierowca.domain.OtpCodeExtractor
 import pl.firmatpp.kierowca.domain.RouteDisplayMapper
 import pl.firmatpp.kierowca.ui.theme.TppColors
 
 @Composable
 fun DriverApp(viewModel: DriverViewModel) {
     val state by viewModel.state.collectAsState()
+    val lifecycleOwner = LocalLifecycleOwner.current
+    var appInForeground by remember { mutableStateOf(true) }
+
+    BackHandler(enabled = state.screen != DriverScreen.Phone && state.screen != DriverScreen.Routes) {
+        viewModel.back()
+    }
+    DisposableEffect(lifecycleOwner, state.screen) {
+        val observer = LifecycleEventObserver { _, event ->
+            when (event) {
+                Lifecycle.Event.ON_START -> {
+                    appInForeground = true
+                    if (state.screen == DriverScreen.Routes) viewModel.refreshRoutesSilently()
+                }
+                Lifecycle.Event.ON_STOP -> appInForeground = false
+                else -> Unit
+            }
+        }
+        lifecycleOwner.lifecycle.addObserver(observer)
+        onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }
+    }
+    LaunchedEffect(state.screen, state.selectedDate, state.autoRefreshSeconds, appInForeground) {
+        if (state.screen != DriverScreen.Routes || !appInForeground) return@LaunchedEffect
+
+        val intervalMillis = state.autoRefreshSeconds.coerceIn(30, 600) * 1000L
+        while (true) {
+            delay(intervalMillis)
+            viewModel.refreshRoutesSilently()
+        }
+    }
+    SmsUserConsentEffect(
+        enabled = state.screen == DriverScreen.Phone || state.screen == DriverScreen.Otp,
+        onCode = viewModel::updateOtpCode,
+    )
 
     Box(Modifier.fillMaxSize().background(TppColors.Surface)) {
         when (state.screen) {
             DriverScreen.Phone -> PhoneScreen(state, viewModel::requestOtp)
-            DriverScreen.Otp -> OtpScreen(state, viewModel::verifyOtp, viewModel::back)
-            DriverScreen.Routes -> RoutesScreen(state, viewModel::refreshRoutes, viewModel::openRoute, viewModel::logout)
+            DriverScreen.Otp -> OtpScreen(state, viewModel::updateOtpCode, viewModel::verifyOtp, viewModel::back)
+            DriverScreen.Routes -> RoutesScreen(
+                state = state,
+                onRefresh = viewModel::refreshRoutesSilently,
+                onDate = viewModel::selectRouteDate,
+                onProfile = viewModel::openProfile,
+                onRoute = viewModel::openRoute,
+            )
+            DriverScreen.Profile -> ProfileScreen(state, viewModel::refreshRoutes, viewModel::openProfile, viewModel::logout)
             DriverScreen.Detail -> DetailScreen(state, viewModel::back, viewModel::uploadPhoto, viewModel::openPhoto)
             DriverScreen.Photo -> PhotoScreen(state, viewModel::back)
         }
@@ -110,24 +187,30 @@ private fun PhoneScreen(state: DriverUiState, onSubmit: (String) -> Unit) {
             singleLine = true,
         )
         ErrorText(state.error)
+        Spacer(Modifier.height(if (state.error.isNullOrBlank()) 18.dp else 8.dp))
         PrimaryButton("Wyslij kod") { onSubmit(phone) }
     }
 }
 
 @Composable
-private fun OtpScreen(state: DriverUiState, onSubmit: (String) -> Unit, onBack: () -> Unit) {
-    var code by remember { mutableStateOf("") }
+private fun OtpScreen(
+    state: DriverUiState,
+    onCodeChange: (String) -> Unit,
+    onSubmit: (String) -> Unit,
+    onBack: () -> Unit,
+) {
     AuthShell(title = "Kod SMS", subtitle = "Wpisz kod wyslany na ${state.maskedPhone}.", onBack = onBack) {
         OutlinedTextField(
-            value = code,
-            onValueChange = { code = it.filter(Char::isDigit).take(6) },
+            value = state.otpCode,
+            onValueChange = { onCodeChange(it) },
             label = { Text("Kod OTP") },
             keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.NumberPassword),
             modifier = Modifier.fillMaxWidth(),
             singleLine = true,
         )
         ErrorText(state.error)
-        PrimaryButton("Zaloguj") { onSubmit(code) }
+        Spacer(Modifier.height(if (state.error.isNullOrBlank()) 18.dp else 8.dp))
+        PrimaryButton("Zaloguj") { onSubmit(state.otpCode) }
     }
 }
 
@@ -144,66 +227,338 @@ private fun AuthShell(title: String, subtitle: String, onBack: (() -> Unit)? = n
     }
 }
 
-@OptIn(ExperimentalMaterial3Api::class)
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterialApi::class)
 @Composable
 private fun RoutesScreen(
     state: DriverUiState,
     onRefresh: () -> Unit,
+    onDate: (String) -> Unit,
+    onProfile: () -> Unit,
     onRoute: (String) -> Unit,
-    onLogout: () -> Unit,
 ) {
     Scaffold(
-        topBar = {
-            TopAppBar(
-                title = { Text("Dzisiejsze kursy") },
-                actions = {
-                    IconButton(onClick = onRefresh) { Icon(Icons.Outlined.Refresh, contentDescription = "Odswiez") }
-                    IconButton(onClick = onLogout) { Icon(Icons.Outlined.Logout, contentDescription = "Wyloguj") }
-                },
-                colors = TopAppBarDefaults.topAppBarColors(containerColor = TppColors.Surface),
+        topBar = { StitchHeader() },
+        bottomBar = {
+            StitchBottomBar(
+                activeScreen = DriverScreen.Routes,
+                onRoutes = onRefresh,
+                onProfile = onProfile,
             )
         },
         containerColor = TppColors.Surface,
     ) { padding ->
-        LazyColumn(
-            Modifier.fillMaxSize().padding(padding),
-            contentPadding = PaddingValues(16.dp),
-            verticalArrangement = Arrangement.spacedBy(16.dp),
-        ) {
-            item {
-                Text("Kierowca: ${state.driver?.displayName.orEmpty()}", color = TppColors.Muted)
+        val pullRefreshState = rememberPullRefreshState(state.refreshing, onRefresh)
+        Box(Modifier.fillMaxSize().padding(padding).pullRefresh(pullRefreshState)) {
+            LazyColumn(
+                Modifier.fillMaxSize(),
+                contentPadding = PaddingValues(start = 16.dp, top = 24.dp, end = 16.dp, bottom = 20.dp),
+                verticalArrangement = Arrangement.spacedBy(18.dp),
+            ) {
+                item {
+                    Row(
+                        Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                        verticalAlignment = Alignment.CenterVertically,
+                    ) {
+                        Text(
+                            routeListTitle(state.selectedDate),
+                            style = MaterialTheme.typography.headlineLarge,
+                            fontWeight = FontWeight.Bold,
+                            color = TppColors.Ink,
+                        )
+                        DateChip(state.selectedDate)
+                    }
+                }
+                item {
+                    RouteDateSelector(
+                        selectedDate = state.selectedDate,
+                        minDate = state.minRouteDate,
+                        maxDate = state.maxRouteDate,
+                        onDate = onDate,
+                    )
+                }
+                if (state.routes.isEmpty()) {
+                    item { EmptyState("Brak kursow na wybrany dzien") }
+                } else {
+                    items(state.routes, key = { it.id }) { route -> StitchRouteCard(route, onRoute) }
+                }
+                item { ErrorText(state.error) }
             }
-            if (state.routes.isEmpty()) {
-                item { EmptyState("Brak kursow na dzisiaj") }
-            } else {
-                items(state.routes, key = { it.id }) { route -> RouteCard(route, onRoute) }
-            }
-            item { ErrorText(state.error) }
+            PullRefreshIndicator(
+                refreshing = state.refreshing,
+                state = pullRefreshState,
+                modifier = Modifier.align(Alignment.TopCenter),
+                backgroundColor = Color.White,
+                contentColor = TppColors.Forest,
+            )
         }
     }
 }
 
 @Composable
-private fun RouteCard(route: DriverRouteDto, onRoute: (String) -> Unit) {
+private fun StitchHeader() {
+    Column(Modifier.fillMaxWidth().background(Color.White).statusBarsPadding()) {
+        Box(
+            Modifier.fillMaxWidth().height(104.dp).padding(horizontal = 24.dp),
+            contentAlignment = Alignment.Center,
+        ) {
+            TppLogo()
+        }
+        HorizontalDivider(color = TppColors.Outline.copy(alpha = 0.8f), thickness = 2.dp)
+    }
+}
+
+@Composable
+private fun TppLogo() {
+    Image(
+        painter = painterResource(R.drawable.tpp5),
+        contentDescription = "TPP",
+        contentScale = ContentScale.Fit,
+        modifier = Modifier.width(142.dp).height(50.dp),
+    )
+}
+
+@Composable
+private fun DateChip(date: String) {
+    val formatter = remember { DateTimeFormatter.ofPattern("d MMM", Locale("pl", "PL")) }
+    val label = remember(date) { LocalDate.parse(date).format(formatter).replace(".", "").replaceFirstChar { it.uppercase() } }
+    Row(
+        modifier = Modifier.background(TppColors.Panel, RoundedCornerShape(12.dp)).padding(horizontal = 16.dp, vertical = 12.dp),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(10.dp),
+    ) {
+        Icon(Icons.Outlined.CalendarToday, contentDescription = null, tint = TppColors.Forest)
+        Text(label, fontFamily = FontFamily.Monospace, color = TppColors.Muted, fontWeight = FontWeight.SemiBold)
+    }
+}
+
+@Composable
+private fun RouteDateSelector(selectedDate: String, minDate: String, maxDate: String, onDate: (String) -> Unit) {
+    val dates = remember(minDate, maxDate) {
+        runCatching {
+            generateSequence(LocalDate.parse(minDate)) { date ->
+                val next = date.plusDays(1)
+                if (next <= LocalDate.parse(maxDate)) next else null
+            }.toList()
+        }.getOrElse { listOf(LocalDate.parse(selectedDate)) }
+    }
+
+    LazyRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+        items(dates, key = { it.toString() }) { date ->
+            DateSelectorChip(
+                date = date,
+                selected = date.toString() == selectedDate,
+                onClick = { onDate(date.toString()) },
+            )
+        }
+    }
+}
+
+@Composable
+private fun DateSelectorChip(date: LocalDate, selected: Boolean, onClick: () -> Unit) {
+    val formatter = remember { DateTimeFormatter.ofPattern("EEE d MMM", Locale("pl", "PL")) }
+    val label = remember(date) { date.format(formatter).replace(".", "").replaceFirstChar { it.uppercase() } }
+    val background = if (selected) TppColors.Forest else Color.White
+    val content = if (selected) Color.White else TppColors.Muted
+
+    Row(
+        modifier = Modifier
+            .background(background, RoundedCornerShape(8.dp))
+            .clickable(onClick = onClick)
+            .padding(horizontal = 14.dp, vertical = 10.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(label, color = content, fontFamily = FontFamily.Monospace, fontWeight = FontWeight.SemiBold)
+    }
+}
+
+private fun routeListTitle(selectedDate: String): String {
+    val today = LocalDate.now()
+    val date = runCatching { LocalDate.parse(selectedDate) }.getOrDefault(today)
+
+    return when (date) {
+        today -> "Dzisiejsze Kursy"
+        today.plusDays(1) -> "Jutrzejsze Kursy"
+        else -> "Kursy"
+    }
+}
+
+@Composable
+private fun StitchRouteCard(route: DriverRouteDto, onRoute: (String) -> Unit) {
     val display = RouteDisplayMapper.toCard(route)
+    val stripColor = routeStatusColor(route.status)
     Card(
-        modifier = Modifier.fillMaxWidth().clickable { onRoute(route.id) },
+        modifier = Modifier.fillMaxWidth(),
         colors = CardDefaults.cardColors(containerColor = Color.White),
         shape = RoundedCornerShape(8.dp),
-        border = CardDefaults.outlinedCardBorder(),
+        border = BorderStroke(1.dp, TppColors.Outline),
     ) {
-        Row(Modifier.fillMaxWidth()) {
-            Box(Modifier.size(width = 5.dp, height = 132.dp).background(TppColors.Forest))
-            Column(Modifier.padding(18.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                Text(display.time, fontFamily = FontFamily.Monospace, color = TppColors.Navy, fontWeight = FontWeight.Bold)
-                Text("${display.origin} -> ${display.destination}", style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold)
-                Text(display.contractLabel, fontFamily = FontFamily.Monospace, color = TppColors.Muted)
-                Text(listOf(display.status, display.distanceLabel).filter { it.isNotBlank() }.joinToString(" / "), color = TppColors.Muted)
+        Row(Modifier.fillMaxWidth().height(IntrinsicSize.Min)) {
+            Box(
+                Modifier
+                    .fillMaxHeight()
+                    .width(8.dp)
+                    .background(stripColor, RoundedCornerShape(topStart = 8.dp, bottomStart = 8.dp)),
+            )
+            Column(Modifier.fillMaxWidth()) {
+                Column(Modifier.padding(start = 24.dp, top = 24.dp, end = 24.dp, bottom = 20.dp)) {
+                    Row(
+                        Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                        verticalAlignment = Alignment.CenterVertically,
+                    ) {
+                        StatusChip(route.status, stripColor)
+                        Text(
+                            "Kontrakt: #${display.contractLabel.trimStart('#')}",
+                            fontFamily = FontFamily.Monospace,
+                            color = TppColors.Ink,
+                            fontWeight = FontWeight.SemiBold,
+                        )
+                    }
+                    Spacer(Modifier.height(26.dp))
+                    RouteTimeline(display.origin, display.destination)
+                }
+                HorizontalDivider(color = TppColors.Outline.copy(alpha = 0.55f))
+                Button(
+                    onClick = { onRoute(route.id) },
+                    modifier = Modifier.fillMaxWidth().padding(16.dp).height(56.dp),
+                    colors = ButtonDefaults.buttonColors(containerColor = stripColor),
+                    shape = RoundedCornerShape(4.dp),
+                ) {
+                    Text("Szczegóły  →", fontFamily = FontFamily.Monospace, fontWeight = FontWeight.Bold)
+                }
             }
         }
     }
 }
 
+@Composable
+private fun StatusChip(status: String, color: Color) {
+    Text(
+        status.ifBlank { "NOWY" }.uppercase(Locale("pl", "PL")),
+        modifier = Modifier
+            .background(color.copy(alpha = 0.18f), RoundedCornerShape(3.dp))
+            .padding(horizontal = 14.dp, vertical = 8.dp),
+        color = color,
+        fontFamily = FontFamily.Monospace,
+        fontWeight = FontWeight.Bold,
+    )
+}
+
+@Composable
+private fun RouteTimeline(origin: String, destination: String) {
+    Row(horizontalArrangement = Arrangement.spacedBy(14.dp)) {
+        Column(horizontalAlignment = Alignment.CenterHorizontally) {
+            Box(Modifier.size(18.dp).background(Color.White, RoundedCornerShape(50)).padding(3.dp)) {
+                Box(Modifier.fillMaxSize().background(TppColors.Forest, RoundedCornerShape(50)))
+            }
+            Box(Modifier.width(3.dp).height(64.dp).background(TppColors.Outline.copy(alpha = 0.8f)))
+            Box(Modifier.size(18.dp).background(TppColors.Navy, RoundedCornerShape(50)))
+        }
+        Column(verticalArrangement = Arrangement.spacedBy(30.dp)) {
+            Column {
+                Text("SKĄD", color = TppColors.Muted, fontFamily = FontFamily.Monospace, fontWeight = FontWeight.Bold)
+                Text(origin, style = MaterialTheme.typography.titleLarge, color = TppColors.Ink, fontWeight = FontWeight.Bold)
+            }
+            Column {
+                Text("DOKĄD", color = TppColors.Muted, fontFamily = FontFamily.Monospace, fontWeight = FontWeight.Bold)
+                Text(destination, style = MaterialTheme.typography.titleLarge, color = TppColors.Ink, fontWeight = FontWeight.Bold)
+            }
+        }
+    }
+}
+
+@Composable
+private fun ProfileScreen(
+    state: DriverUiState,
+    onRoutes: () -> Unit,
+    onProfile: () -> Unit,
+    onLogout: () -> Unit,
+) {
+    Scaffold(
+        topBar = { StitchHeader() },
+        bottomBar = {
+            StitchBottomBar(
+                activeScreen = DriverScreen.Profile,
+                onRoutes = onRoutes,
+                onProfile = onProfile,
+            )
+        },
+        containerColor = TppColors.Surface,
+    ) { padding ->
+        Column(
+            Modifier
+                .fillMaxSize()
+                .padding(padding)
+                .padding(horizontal = 20.dp, vertical = 24.dp),
+            verticalArrangement = Arrangement.spacedBy(18.dp),
+        ) {
+            Card(
+                modifier = Modifier.fillMaxWidth(),
+                colors = CardDefaults.cardColors(containerColor = Color.White),
+                shape = RoundedCornerShape(8.dp),
+                border = BorderStroke(1.dp, TppColors.Outline),
+            ) {
+                Column(Modifier.padding(24.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
+                    Icon(Icons.Outlined.Person, contentDescription = null, tint = TppColors.Forest, modifier = Modifier.size(34.dp))
+                    Text(
+                        "Witaj ${state.driver?.displayName.orEmpty().ifBlank { "Kierowco" }}",
+                        style = MaterialTheme.typography.headlineSmall,
+                        fontWeight = FontWeight.Bold,
+                        color = TppColors.Ink,
+                    )
+                }
+            }
+            Button(
+                onClick = onLogout,
+                modifier = Modifier.fillMaxWidth().height(56.dp),
+                colors = ButtonDefaults.buttonColors(containerColor = TppColors.Forest),
+                shape = RoundedCornerShape(4.dp),
+            ) {
+                Text("Wyloguj", fontWeight = FontWeight.Bold)
+            }
+        }
+    }
+}
+
+@Composable
+private fun StitchBottomBar(activeScreen: DriverScreen, onRoutes: () -> Unit, onProfile: () -> Unit) {
+    Column(Modifier.fillMaxWidth().background(Color.White).navigationBarsPadding()) {
+        HorizontalDivider(color = TppColors.Outline.copy(alpha = 0.9f), thickness = 2.dp)
+        Row(
+            Modifier.fillMaxWidth().height(82.dp),
+            horizontalArrangement = Arrangement.SpaceEvenly,
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            BottomNavItem("Zlecenia", Icons.Outlined.LocalShipping, active = activeScreen == DriverScreen.Routes, onClick = onRoutes)
+            BottomNavItem("Profil", Icons.Outlined.Person, active = activeScreen == DriverScreen.Profile, onClick = onProfile)
+        }
+    }
+}
+
+@Composable
+private fun BottomNavItem(label: String, icon: ImageVector, active: Boolean, onClick: () -> Unit) {
+    Column(
+        modifier = Modifier.heightIn(min = 64.dp).clickable(onClick = onClick).padding(horizontal = 18.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.Center,
+    ) {
+        Icon(icon, contentDescription = label, tint = if (active) TppColors.Forest else TppColors.Muted)
+        Spacer(Modifier.height(6.dp))
+        Text(label, color = if (active) TppColors.Forest else TppColors.Muted, fontFamily = FontFamily.Monospace)
+    }
+}
+
+private fun routeStatusColor(status: String): Color {
+    val normalized = status.uppercase(Locale("pl", "PL"))
+    return when {
+        "NOW" in normalized -> TppColors.Navy
+        "ZAK" in normalized || "GOT" in normalized -> TppColors.Forest
+        "TRAK" in normalized || "START" in normalized -> Color(0xFFF5B800)
+        else -> TppColors.Forest
+    }
+}
+
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 private fun DetailScreen(
@@ -218,6 +573,10 @@ private fun DetailScreen(
         val capturedUri = cameraUri
         if (ok && capturedUri != null) onUpload(capturedUri, "camera")
     }
+    val cameraPermissionLauncher = rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
+        val pendingUri = cameraUri
+        if (granted && pendingUri != null) cameraLauncher.launch(pendingUri)
+    }
     val pickerLauncher = rememberLauncherForActivityResult(ActivityResultContracts.PickVisualMedia()) { uri ->
         if (uri != null) onUpload(uri, "gallery")
     }
@@ -226,6 +585,7 @@ private fun DetailScreen(
     Scaffold(
         topBar = {
             TopAppBar(
+                modifier = Modifier.statusBarsPadding(),
                 title = { Text("Szczegoly kursu") },
                 navigationIcon = { IconButton(onClick = onBack) { Icon(Icons.Outlined.ArrowBack, contentDescription = "Wstecz") } },
                 colors = TopAppBarDefaults.topAppBarColors(containerColor = TppColors.Surface),
@@ -246,7 +606,11 @@ private fun DetailScreen(
                 PhotoGrid(route.photos, state.imageAuthHeader, onPhoto, onCamera = {
                     val newUri = createCameraUri(context)
                     cameraUri = newUri
-                    cameraLauncher.launch(newUri)
+                    if (ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {
+                        cameraLauncher.launch(newUri)
+                    } else {
+                        cameraPermissionLauncher.launch(Manifest.permission.CAMERA)
+                    }
                 }, onGallery = {
                     pickerLauncher.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageOnly))
                 })
@@ -317,6 +681,7 @@ private fun PhotoScreen(state: DriverUiState, onBack: () -> Unit) {
     Scaffold(
         topBar = {
             TopAppBar(
+                modifier = Modifier.statusBarsPadding(),
                 title = { Text("Podglad zdjecia") },
                 navigationIcon = { IconButton(onClick = onBack) { Icon(Icons.Outlined.ArrowBack, contentDescription = "Wstecz") } },
                 colors = TopAppBarDefaults.topAppBarColors(containerColor = Color.Black, titleContentColor = Color.White, navigationIconContentColor = Color.White),
@@ -361,6 +726,68 @@ private fun createCameraUri(context: Context): Uri {
     return FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", file)
 }
 
+@Composable
+private fun SmsUserConsentEffect(enabled: Boolean, onCode: (String) -> Unit) {
+    val context = LocalContext.current
+    val launcher = rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
+        if (result.resultCode == Activity.RESULT_OK) {
+            val message = result.data?.getStringExtra(SmsRetriever.EXTRA_SMS_MESSAGE).orEmpty()
+            OtpCodeExtractor.extract(message)?.let(onCode)
+        }
+    }
+
+    DisposableEffect(enabled, context) {
+        if (!enabled) return@DisposableEffect onDispose { }
+
+        SmsRetriever.getClient(context).startSmsUserConsent(null)
+
+        val receiver = object : BroadcastReceiver() {
+            override fun onReceive(receiverContext: Context?, intent: Intent?) {
+                if (intent?.action != SmsRetriever.SMS_RETRIEVED_ACTION) return
+
+                val status = intent.smsRetrieverStatus() ?: return
+                if (status.statusCode != CommonStatusCodes.SUCCESS) return
+
+                intent.smsConsentIntent()?.let(launcher::launch)
+            }
+        }
+
+        val filter = IntentFilter(SmsRetriever.SMS_RETRIEVED_ACTION)
+        ContextCompat.registerReceiver(
+            context,
+            receiver,
+            filter,
+            SmsRetriever.SEND_PERMISSION,
+            null,
+            ContextCompat.RECEIVER_EXPORTED,
+        )
+
+        onDispose {
+            runCatching { context.unregisterReceiver(receiver) }
+        }
+    }
+}
+
+private fun Intent.smsRetrieverStatus(): Status? {
+    val extras = extras ?: return null
+    @Suppress("DEPRECATION")
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        extras.getParcelable(SmsRetriever.EXTRA_STATUS, Status::class.java)
+    } else {
+        extras.getParcelable(SmsRetriever.EXTRA_STATUS)
+    }
+}
+
+private fun Intent.smsConsentIntent(): Intent? {
+    val extras = extras ?: return null
+    @Suppress("DEPRECATION")
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        extras.getParcelable(SmsRetriever.EXTRA_CONSENT_INTENT, Intent::class.java)
+    } else {
+        extras.getParcelable(SmsRetriever.EXTRA_CONSENT_INTENT)
+    }
+}
+
 @Composable
 private fun imageRequest(url: String?, authorization: String?): ImageRequest {
     val context = LocalContext.current

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

@@ -8,20 +8,27 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
+import java.time.LocalDate
 import pl.firmatpp.kierowca.data.DriverRepository
 import pl.firmatpp.kierowca.data.model.DriverDto
 import pl.firmatpp.kierowca.data.model.DriverRouteDto
 import pl.firmatpp.kierowca.data.model.RoutePhotoDto
 
-enum class DriverScreen { Phone, Otp, Routes, Detail, Photo }
+enum class DriverScreen { Phone, Otp, Routes, Profile, Detail, Photo }
 
 data class DriverUiState(
     val screen: DriverScreen = DriverScreen.Phone,
     val loading: Boolean = false,
+    val refreshing: Boolean = false,
     val phone: String = "",
+    val otpCode: String = "",
     val maskedPhone: String = "",
     val driver: DriverDto? = null,
     val routes: List<DriverRouteDto> = emptyList(),
+    val selectedDate: String = LocalDate.now().toString(),
+    val minRouteDate: String = LocalDate.now().minusDays(7).toString(),
+    val maxRouteDate: String = LocalDate.now().plusDays(1).toString(),
+    val autoRefreshSeconds: Int = 60,
     val selectedRoute: DriverRouteDto? = null,
     val selectedPhoto: RoutePhotoDto? = null,
     val imageAuthHeader: String? = null,
@@ -45,6 +52,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
             it.copy(
                 screen = DriverScreen.Otp,
                 phone = phone,
+                otpCode = "",
                 maskedPhone = response.phoneMasked.orEmpty(),
                 error = null,
             )
@@ -57,16 +65,43 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         refreshRoutes()
     }
 
-    fun refreshRoutes() = runLoading {
-        val response = repository.bootstrap()
-        _state.update {
-            it.copy(
-                screen = DriverScreen.Routes,
-                driver = response.session.driver,
-                routes = response.routes.today,
-                imageAuthHeader = repository.imageAuthHeader(),
-                error = null,
-            )
+    fun updateOtpCode(code: String) {
+        _state.update { it.copy(otpCode = code.filter(Char::isDigit).take(10)) }
+    }
+
+    fun refreshRoutes() = loadRoutes(date = _state.value.selectedDate, showLoading = true, navigateToRoutes = true)
+
+    fun refreshRoutesSilently() = loadRoutes(date = _state.value.selectedDate, showLoading = false, navigateToRoutes = false)
+
+    fun selectRouteDate(date: String) = loadRoutes(date = date, showLoading = true, navigateToRoutes = true)
+
+    private fun loadRoutes(date: String?, showLoading: Boolean, navigateToRoutes: Boolean) {
+        viewModelScope.launch {
+            _state.update { it.copy(loading = showLoading, refreshing = !showLoading, error = null) }
+
+            runCatching {
+                val response = repository.bootstrap(date)
+                val settings = response.driverAppSettings
+                _state.update {
+                    it.copy(
+                        screen = if (navigateToRoutes) DriverScreen.Routes else it.screen,
+                        driver = response.session.driver,
+                        routes = response.routes.today,
+                        selectedDate = settings?.selectedDate ?: date ?: it.selectedDate,
+                        minRouteDate = settings?.minDate ?: it.minRouteDate,
+                        maxRouteDate = settings?.maxDate ?: it.maxRouteDate,
+                        autoRefreshSeconds = settings?.autoRefreshSeconds ?: it.autoRefreshSeconds,
+                        imageAuthHeader = repository.imageAuthHeader(),
+                        error = null,
+                    )
+                }
+            }.onFailure { throwable ->
+                _state.update { it.copy(error = throwable.message ?: "Wystapil blad.") }
+            }
+
+            _state.update {
+                it.copy(loading = false, refreshing = false)
+            }
         }
     }
 
@@ -75,6 +110,10 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
         _state.update { it.copy(screen = DriverScreen.Detail, selectedRoute = response.route, error = null) }
     }
 
+    fun openProfile() {
+        _state.update { it.copy(screen = DriverScreen.Profile, error = null) }
+    }
+
     fun uploadPhoto(uri: Uri, source: String) = runLoading {
         val route = _state.value.selectedRoute ?: return@runLoading
         repository.uploadPhoto(route.id, uri, source)
@@ -90,6 +129,7 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
             when (it.screen) {
                 DriverScreen.Photo -> it.copy(screen = DriverScreen.Detail, selectedPhoto = null)
                 DriverScreen.Detail -> it.copy(screen = DriverScreen.Routes, selectedRoute = null)
+                DriverScreen.Profile -> it.copy(screen = DriverScreen.Routes)
                 DriverScreen.Otp -> it.copy(screen = DriverScreen.Phone)
                 else -> it
             }

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

@@ -0,0 +1,20 @@
+package pl.firmatpp.kierowca.domain
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class OtpCodeExtractorTest {
+    @Test
+    fun extractsFourToTenDigitOtpFromSmsBody() {
+        assertEquals("1234", OtpCodeExtractor.extract("Kod TPP: 1234"))
+        assertEquals("987654", OtpCodeExtractor.extract("Twoj kod weryfikacyjny to 987654."))
+        assertEquals("1234567890", OtpCodeExtractor.extract("Code 1234567890"))
+    }
+
+    @Test
+    fun ignoresNumbersThatAreTooShortOrTooLong() {
+        assertNull(OtpCodeExtractor.extract("Kod 123"))
+        assertNull(OtpCodeExtractor.extract("Kod 12345678901"))
+    }
+}

gradle/libs.versions.toml

@@ -13,6 +13,8 @@ datastore = "1.1.1"
 coil = "2.7.0"
 camerax = "1.4.1"
 work = "2.10.0"
+playServicesAuth = "21.6.0"
+playServicesAuthApiPhone = "18.3.0"
 junit = "4.13.2"
 
 [libraries]
@@ -40,6 +42,8 @@ coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-
 junit = { group = "junit", name = "junit", version.ref = "junit" }
 okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
 okhttp-logging = { group = "com.squareup.okhttp3", name = "logging-interceptor", version.ref = "okhttp" }
+play-services-auth = { group = "com.google.android.gms", name = "play-services-auth", version.ref = "playServicesAuth" }
+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" }