Wydaj aplikację kierowcy 1.0.69 (122)

.gitignore

@@ -1,5 +1,13 @@
 .gradle/
 build/
 local.properties
+app/google-services.json
+app/google-services.json:Zone.Identifier
 */build/
 *.iml
+keystore.properties
+*.jks
+release-artifacts/
+app/src/main/res_bak/
+scripts/*.json
+scripts/*.json:Zone.Identifier

README.md

@@ -21,3 +21,65 @@ Natywna aplikacja Android Jetpack Compose dla kierowcow TPP.
 ```bash
 ./gradlew :app:testDebugUnitTest
 ```
+
+## Release Gitea i Google Play
+
+Przed wydaniem zapisz wszystkie zmiany źródłowe w commicie. Następnie uruchom:
+
+```bash
+./scripts/release-android.sh
+```
+
+Skrypt automatycznie zwiększa `versionCode` i ostatni człon `versionName`, uruchamia testy,
+buduje podpisany APK oraz AAB, a po poprawnym buildzie pyta, czy wysłać aktualizację do
+Google Play. Po odpowiedzi „tak” publikuje AAB w skonfigurowanym teście zamkniętym i
+wysyła zmiany do weryfikacji. Następnie tworzy commit wersji, tag, push i Gitea Release.
+Artefakty zostają również zapisane lokalnie w `release-artifacts/<tag>/`.
+
+Do publikacji Google Play konto serwisowe musi mieć dla aplikacji
+`pl.firmatpp.kierowca` uprawnienia „Wyświetlanie informacji o aplikacji (tylko do odczytu)”
+oraz „Publikowanie aplikacji na ścieżkach testowych”. Pobrany klucz JSON umieść
+bezpośrednio w folderze `scripts`, na przykład:
+
+```text
+scripts/google-play-service-account.json
+```
+
+Skrypt sam znajduje jedyny plik `scripts/*.json`, sprawdza, czy jest prawidłowym kluczem
+konta serwisowego, i używa go do autoryzacji. Pliki `scripts/*.json` są ignorowane przez
+Git i nie mogą zostać przypadkowo dodane do repozytorium. Jeśli w folderze znajduje się
+więcej niż jeden prawidłowy klucz, skrypt przerwie działanie i poprosi o pozostawienie
+jednego.
+
+`GOOGLE_PLAY_TRACK` musi być identyfikatorem istniejącego testu zamkniętego. Domyślna
+wartość to `alpha`. Opcjonalnie można ustawić `GOOGLE_PLAY_PACKAGE_NAME` i
+`GOOGLE_PLAY_RELEASE_LANGUAGE` (domyślnie `pl-PL`). Zmienna
+`GOOGLE_PLAY_SERVICE_ACCOUNT_CREDENTIALS` pozostaje opcjonalnym sposobem wskazania klucza
+spoza folderu `scripts`. Skrypt nie zapisuje tokenu ani klucza w repozytorium; prywatny
+klucz tymczasowy jest usuwany po zakończeniu.
+
+Przed zatwierdzeniem skrypt waliduje edycję Google Play. Commit edycji jawnie wysyła
+zmiany do weryfikacji. Jeżeli inne zmiany są już sprawdzane, skrypt nie anuluje ich —
+kończy się błędem i można go wznowić po zakończeniu poprzedniej weryfikacji.
+Jeżeli na koncie jest włączone publikowanie zarządzane, po akceptacji Google nadal trzeba
+wybrać „Opublikuj zmiany” w Play Console; bez publikowania zarządzanego zaakceptowane
+wydanie zostanie udostępnione testerom automatycznie.
+
+Awaryjne wydanie wyłącznie do Gitea, bez Google Play:
+
+```bash
+./scripts/release-android.sh --skip-google-play
+```
+
+W środowisku bez interaktywnego terminala decyzję trzeba podać jawnie:
+
+```bash
+./scripts/release-android.sh --publish-google-play
+```
+
+Do autoryzacji Gitea używany jest `GITEA_TOKEN` albo dane zapisane w Git credential helper.
+Jeśli publikacja została przerwana już po utworzeniu commita wersji, można ją wznowić:
+
+```bash
+./scripts/release-android.sh --reuse-current
+```

app/build.gradle.kts

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

app/src/main/AndroidManifest.xml

@@ -2,10 +2,29 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
+
+    <uses-feature
+        android:name="android.hardware.camera"
+        android:required="false" />
+
+    <queries>
+        <intent>
+            <action android:name="android.speech.RecognitionService" />
+        </intent>
+    </queries>
 
     <application
         android:allowBackup="false"
+        android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
+        android:name=".DriverApplication"
+        android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.TppKierowca">
         <activity
@@ -26,5 +45,18 @@
                 android:name="android.support.FILE_PROVIDER_PATHS"
                 android:resource="@xml/file_paths" />
         </provider>
+
+        <service
+            android:name=".sync.DriverFirebaseMessagingService"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="com.google.firebase.MESSAGING_EVENT" />
+            </intent-filter>
+        </service>
+
+        <service
+            android:name=".tracking.ActiveRouteTrackingService"
+            android:exported="false"
+            android:foregroundServiceType="location" />
     </application>
 </manifest>

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

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

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

@@ -3,19 +3,88 @@ package pl.firmatpp.kierowca
 import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
 import pl.firmatpp.kierowca.ui.DriverApp
 import pl.firmatpp.kierowca.ui.DriverViewModel
 import pl.firmatpp.kierowca.ui.theme.TppKierowcaTheme
+import pl.firmatpp.kierowca.update.PlayAppUpdateState
+import pl.firmatpp.kierowca.update.PlayInAppUpdateController
 
 class MainActivity : ComponentActivity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContent {
-            TppKierowcaTheme {
-                val viewModel: DriverViewModel = viewModel()
-                DriverApp(viewModel = viewModel)
-            }
+    private var notificationRouteId by mutableStateOf<String?>(null)
+    private var notificationRouteTarget by mutableStateOf<String?>(null)
+    private var notificationLeaveRequestId by mutableStateOf<String?>(null)
+    private var playAppUpdateState by mutableStateOf(PlayAppUpdateState())
+    private lateinit var playInAppUpdates: PlayInAppUpdateController
+    private val appUpdateLauncher = registerForActivityResult(
+        ActivityResultContracts.StartIntentSenderForResult(),
+    ) { result ->
+        if (::playInAppUpdates.isInitialized) {
+            playInAppUpdates.onUpdateFlowResult(result.resultCode)
         }
     }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        notificationRouteId = intent.getStringExtra(EXTRA_ROUTE_ID)
+        notificationRouteTarget = intent.getStringExtra(EXTRA_ROUTE_TARGET)
+        notificationLeaveRequestId = intent.getStringExtra(EXTRA_LEAVE_REQUEST_ID)
+        playInAppUpdates = PlayInAppUpdateController(
+            activity = this,
+            launcher = appUpdateLauncher,
+            onStateChanged = { playAppUpdateState = it },
+        )
+        setContent {
+            val viewModel: DriverViewModel = viewModel()
+            val state by viewModel.state.collectAsStateWithLifecycle()
+
+            TppKierowcaTheme(themeMode = state.themeMode) {
+                DriverApp(
+                    viewModel = viewModel,
+                    initialRouteId = notificationRouteId,
+                    initialRouteTarget = notificationRouteTarget,
+                    initialLeaveRequestId = notificationLeaveRequestId,
+                    playAppUpdateState = playAppUpdateState,
+                    onStartAppUpdate = playInAppUpdates::startUpdate,
+                    onCompleteAppUpdate = playInAppUpdates::completeDownloadedUpdate,
+                )
+            }
+        }
+        playInAppUpdates.checkForUpdate()
+    }
+
+    override fun onResume() {
+        super.onResume()
+        if (::playInAppUpdates.isInitialized) {
+            playInAppUpdates.checkForUpdate()
+        }
+    }
+
+    override fun onDestroy() {
+        if (::playInAppUpdates.isInitialized) {
+            playInAppUpdates.dispose()
+        }
+        super.onDestroy()
+    }
+
+    override fun onNewIntent(intent: android.content.Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+        notificationRouteId = intent.getStringExtra(EXTRA_ROUTE_ID)
+        notificationRouteTarget = intent.getStringExtra(EXTRA_ROUTE_TARGET)
+        notificationLeaveRequestId = intent.getStringExtra(EXTRA_LEAVE_REQUEST_ID)
+    }
+
+    companion object {
+        const val EXTRA_ROUTE_ID = "pl.firmatpp.kierowca.EXTRA_ROUTE_ID"
+        const val EXTRA_ROUTE_TARGET = "pl.firmatpp.kierowca.EXTRA_ROUTE_TARGET"
+        const val EXTRA_LEAVE_REQUEST_ID = "pl.firmatpp.kierowca.EXTRA_LEAVE_REQUEST_ID"
+        const val ROUTE_TARGET_DETAIL = "detail"
+        const val ROUTE_TARGET_FINISH = "finish"
+    }
 }

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

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