refactor: add shared core foundations

core/src/main/java/com/motionapps/sensorbox/core/error/AppDiagnostics.kt

@@ -0,0 +1,112 @@
+package com.motionapps.sensorbox.core.error
+
+import android.content.Context
+import java.io.File
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+object AppDiagnostics {
+    private val lock = Any()
+    private val pending = ArrayDeque<String>()
+
+    @Volatile
+    private var applicationContext: Context? = null
+
+    @Volatile
+    private var uncaughtHandlerInstalled = false
+
+    fun install(context: Context) {
+        synchronized(lock) {
+            applicationContext = context.applicationContext
+            installUncaughtExceptionHandler()
+            val queued = pending.toList()
+            pending.clear()
+            queued.forEach(::appendSafely)
+        }
+    }
+
+    private fun installUncaughtExceptionHandler() {
+        if (uncaughtHandlerInstalled) return
+        val previous = Thread.getDefaultUncaughtExceptionHandler()
+        Thread.setDefaultUncaughtExceptionHandler { thread, error ->
+            AppError.from(AppError.Kind.UNKNOWN, "Uncaught exception on ${thread.name}", error)
+            previous?.uncaughtException(thread, error)
+        }
+        uncaughtHandlerInstalled = true
+    }
+
+    fun record(error: AppError) {
+        val entry = error.toDiagnosticEntry()
+        synchronized(lock) {
+            if (applicationContext == null) {
+                if (pending.size == MAX_PENDING_ENTRIES) pending.removeFirst()
+                pending.addLast(entry)
+            } else {
+                appendSafely(entry)
+            }
+        }
+    }
+
+    fun readText(): Result<String> = appResult(AppError.Kind.STORAGE, "Read diagnostics") {
+        synchronized(lock) {
+            val file = diagnosticsFile()
+            if (file.exists()) file.readText() else NO_DIAGNOSTICS
+        }
+    }
+
+    fun exportFile(): Result<File> = appResult(AppError.Kind.STORAGE, "Export diagnostics") {
+        synchronized(lock) {
+            diagnosticsFile().also { file ->
+                file.parentFile?.mkdirs()
+                if (!file.exists()) file.writeText(NO_DIAGNOSTICS)
+            }
+        }
+    }
+
+    fun clear(): Result<Unit> = appResult(AppError.Kind.STORAGE, "Clear diagnostics") {
+        synchronized(lock) {
+            val file = diagnosticsFile()
+            check(!file.exists() || file.delete()) { "Unable to delete diagnostics" }
+        }
+    }
+
+    private fun appendSafely(entry: String) {
+        try {
+            val file = diagnosticsFile()
+            file.parentFile?.mkdirs()
+            if (file.length() + entry.length > MAX_FILE_BYTES) rotate(file)
+            file.appendText(entry)
+        } catch (_: Throwable) {
+            // Diagnostics must never become a second failure source.
+        }
+    }
+
+    private fun rotate(file: File) {
+        val previous = File(file.parentFile, PREVIOUS_FILE_NAME)
+        if (previous.exists()) previous.delete()
+        if (file.exists()) file.renameTo(previous)
+    }
+
+    private fun diagnosticsFile(): File {
+        val context = checkNotNull(applicationContext) { "Diagnostics are not initialized" }
+        return File(File(context.filesDir, DIRECTORY_NAME), FILE_NAME)
+    }
+
+    private fun AppError.toDiagnosticEntry(): String = buildString {
+        val timestamp = SimpleDateFormat(TIMESTAMP_FORMAT, Locale.US).format(Date())
+        append(timestamp).append(" | ").append(kind).append(" | ").append(operation).appendLine()
+        append(stackTraceToString().take(MAX_ENTRY_CHARS)).appendLine()
+        appendLine(ENTRY_SEPARATOR)
+    }
+
+    private const val DIRECTORY_NAME = "diagnostics"
+    private const val FILE_NAME = "sensorbox-diagnostics.txt"
+    private const val PREVIOUS_FILE_NAME = "sensorbox-diagnostics-previous.txt"
+    private const val TIMESTAMP_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSSZ"
+    private const val ENTRY_SEPARATOR = "---"
+    private const val NO_DIAGNOSTICS = "No diagnostics have been recorded.\n"
+    private const val MAX_PENDING_ENTRIES = 20
+    private const val MAX_ENTRY_CHARS = 32_000
+    private const val MAX_FILE_BYTES = 1_000_000L
+}

core/src/main/java/com/motionapps/sensorbox/core/error/AppError.kt

@@ -0,0 +1,73 @@
+package com.motionapps.sensorbox.core.error
+
+import kotlinx.coroutines.CancellationException
+
+class AppError(val kind: Kind, val operation: String, cause: Throwable? = null) :
+    Exception(message(operation, cause), cause) {
+    init {
+        AppDiagnostics.record(this)
+    }
+
+    enum class Kind {
+        CONNECTIVITY,
+        EXTERNAL_ACTION,
+        MEASUREMENT,
+        PERMISSION,
+        PREFERENCES,
+        STORAGE,
+        UNKNOWN,
+    }
+
+    companion object {
+        fun from(kind: Kind, operation: String, cause: Throwable): AppError =
+            cause as? AppError ?: AppError(kind, operation, cause)
+
+        private fun message(operation: String, cause: Throwable?): String =
+            cause?.message?.takeIf(String::isNotBlank)?.let { "$operation: $it" } ?: "$operation failed"
+    }
+}
+
+@Suppress("TooGenericExceptionCaught")
+inline fun <T> appResult(kind: AppError.Kind, operation: String, block: () -> T): Result<T> = try {
+    Result.success(block())
+} catch (error: CancellationException) {
+    throw error
+} catch (error: Throwable) {
+    Result.failure(AppError.from(kind, operation, error))
+}
+
+@Suppress("TooGenericExceptionCaught")
+suspend inline fun <T> suspendAppResult(
+    kind: AppError.Kind,
+    operation: String,
+    crossinline block: suspend () -> T,
+): Result<T> = try {
+    Result.success(block())
+} catch (error: CancellationException) {
+    throw error
+} catch (error: Throwable) {
+    Result.failure(AppError.from(kind, operation, error))
+}
+
+fun <T> Result<T>.withAppError(kind: AppError.Kind, operation: String): Result<T> = fold(
+    onSuccess = Result.Companion::success,
+    onFailure = { Result.failure(AppError.from(kind, operation, it)) },
+)
+
+inline fun <T, R> Result<T>.flatMap(transform: (T) -> Result<R>): Result<R> = fold(
+    onSuccess = transform,
+    onFailure = Result.Companion::failure,
+)
+
+suspend inline fun <T, R> Result<T>.suspendFlatMap(crossinline transform: suspend (T) -> Result<R>): Result<R> = fold(
+    onSuccess = { transform(it) },
+    onFailure = Result.Companion::failure,
+)
+
+fun Iterable<Result<*>>.combineAppResults(kind: AppError.Kind, operation: String): Result<Unit> {
+    val failures = mapNotNull(Result<*>::exceptionOrNull)
+    if (failures.isEmpty()) return Result.success(Unit)
+    val first = failures.first()
+    failures.drop(1).forEach(first::addSuppressed)
+    return Result.failure(AppError.from(kind, operation, first))
+}

core/src/main/java/com/motionapps/sensorbox/core/preferences/AppPreferences.kt

@@ -0,0 +1,13 @@
+package com.motionapps.sensorbox.core.preferences
+
+data class AppPreferences(
+    val hasCompletedIntro: Boolean = false,
+    val hasAcceptedPolicy: Boolean = false,
+    val gpsIntervalSeconds: Int = 10,
+    val gpsMinDistanceMeters: Int = 20,
+    val sensorSamplingPeriod: Int = 0,
+    val restrictMeasurementOnLowBattery: Boolean = true,
+    val useWakeLock: Boolean = false,
+    val keepPhoneDisplayOn: Boolean = false,
+    val keepWearDisplayOn: Boolean = false,
+)

core/src/main/java/com/motionapps/sensorbox/core/preferences/AppPreferencesDataStoreFactory.kt

@@ -0,0 +1,15 @@
+package com.motionapps.sensorbox.core.preferences
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.preferencesDataStoreFile
+
+object AppPreferencesDataStoreFactory {
+    fun create(context: Context): DataStore<Preferences> = PreferenceDataStoreFactory.create(
+        produceFile = { context.preferencesDataStoreFile(FILE_NAME) },
+    )
+
+    private const val FILE_NAME = "sensorbox"
+}

core/src/main/java/com/motionapps/sensorbox/core/preferences/AppPreferencesIntent.kt

@@ -0,0 +1,21 @@
+package com.motionapps.sensorbox.core.preferences
+
+sealed interface AppPreferencesIntent {
+    data object CompleteIntro : AppPreferencesIntent
+
+    data object AcceptPolicy : AppPreferencesIntent
+
+    data class SetGpsInterval(val seconds: Int) : AppPreferencesIntent
+
+    data class SetGpsMinDistance(val meters: Int) : AppPreferencesIntent
+
+    data class SetSensorSamplingPeriod(val period: Int) : AppPreferencesIntent
+
+    data class SetLowBatteryRestriction(val enabled: Boolean) : AppPreferencesIntent
+
+    data class SetWakeLock(val enabled: Boolean) : AppPreferencesIntent
+
+    data class SetKeepPhoneDisplayOn(val enabled: Boolean) : AppPreferencesIntent
+
+    data class SetKeepWearDisplayOn(val enabled: Boolean) : AppPreferencesIntent
+}

core/src/main/java/com/motionapps/sensorbox/core/preferences/AppPreferencesReducer.kt

@@ -0,0 +1,35 @@
+package com.motionapps.sensorbox.core.preferences
+
+object AppPreferencesReducer {
+    fun reduce(current: AppPreferences, intent: AppPreferencesIntent): AppPreferences = when (intent) {
+        AppPreferencesIntent.AcceptPolicy -> current.copy(hasAcceptedPolicy = true)
+
+        AppPreferencesIntent.CompleteIntro -> current.copy(hasCompletedIntro = true)
+
+        is AppPreferencesIntent.SetGpsInterval -> current.copy(
+            gpsIntervalSeconds = intent.seconds.coerceAtLeast(1),
+        )
+
+        is AppPreferencesIntent.SetGpsMinDistance -> current.copy(
+            gpsMinDistanceMeters = intent.meters.coerceAtLeast(0),
+        )
+
+        is AppPreferencesIntent.SetKeepWearDisplayOn -> current.copy(
+            keepWearDisplayOn = intent.enabled,
+        )
+
+        is AppPreferencesIntent.SetKeepPhoneDisplayOn -> current.copy(
+            keepPhoneDisplayOn = intent.enabled,
+        )
+
+        is AppPreferencesIntent.SetLowBatteryRestriction -> current.copy(
+            restrictMeasurementOnLowBattery = intent.enabled,
+        )
+
+        is AppPreferencesIntent.SetSensorSamplingPeriod -> current.copy(
+            sensorSamplingPeriod = intent.period,
+        )
+
+        is AppPreferencesIntent.SetWakeLock -> current.copy(useWakeLock = intent.enabled)
+    }
+}

core/src/main/java/com/motionapps/sensorbox/core/preferences/AppPreferencesRepository.kt

@@ -0,0 +1,9 @@
+package com.motionapps.sensorbox.core.preferences
+
+import kotlinx.coroutines.flow.Flow
+
+interface AppPreferencesRepository {
+    val preferences: Flow<Result<AppPreferences>>
+
+    suspend fun dispatch(intent: AppPreferencesIntent): Result<Unit>
+}

core/src/main/java/com/motionapps/sensorbox/core/preferences/DataStoreAppPreferencesRepository.kt

@@ -0,0 +1,68 @@
+package com.motionapps.sensorbox.core.preferences
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.booleanPreferencesKey
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.intPreferencesKey
+import com.motionapps.sensorbox.core.error.AppError
+import com.motionapps.sensorbox.core.error.suspendAppResult
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.map
+
+class DataStoreAppPreferencesRepository(private val dataStore: DataStore<Preferences>) : AppPreferencesRepository {
+    override val preferences: Flow<Result<AppPreferences>> = dataStore.data
+        .map { values -> Result.success(values.toAppPreferences()) }
+        .catch { error ->
+            if (error is CancellationException) throw error
+            emit(Result.failure(AppError.from(AppError.Kind.PREFERENCES, "Read preferences", error)))
+        }
+
+    override suspend fun dispatch(intent: AppPreferencesIntent): Result<Unit> = suspendAppResult(
+        AppError.Kind.PREFERENCES,
+        "Update preferences",
+    ) {
+        dataStore.edit { values ->
+            val updated = AppPreferencesReducer.reduce(values.toAppPreferences(), intent)
+            values.write(updated)
+        }
+    }
+
+    private fun Preferences.toAppPreferences(): AppPreferences = AppPreferences(
+        hasCompletedIntro = this[Keys.COMPLETED_INTRO] ?: false,
+        hasAcceptedPolicy = this[Keys.ACCEPTED_POLICY] ?: false,
+        gpsIntervalSeconds = this[Keys.GPS_INTERVAL] ?: 10,
+        gpsMinDistanceMeters = this[Keys.GPS_DISTANCE] ?: 20,
+        sensorSamplingPeriod = this[Keys.SAMPLING_PERIOD] ?: 0,
+        restrictMeasurementOnLowBattery = this[Keys.LOW_BATTERY] ?: true,
+        useWakeLock = this[Keys.WAKE_LOCK] ?: false,
+        keepPhoneDisplayOn = this[Keys.KEEP_PHONE_DISPLAY_ON] ?: false,
+        keepWearDisplayOn = this[Keys.KEEP_DISPLAY_ON] ?: false,
+    )
+
+    private fun androidx.datastore.preferences.core.MutablePreferences.write(value: AppPreferences) {
+        this[Keys.COMPLETED_INTRO] = value.hasCompletedIntro
+        this[Keys.ACCEPTED_POLICY] = value.hasAcceptedPolicy
+        this[Keys.GPS_INTERVAL] = value.gpsIntervalSeconds
+        this[Keys.GPS_DISTANCE] = value.gpsMinDistanceMeters
+        this[Keys.SAMPLING_PERIOD] = value.sensorSamplingPeriod
+        this[Keys.LOW_BATTERY] = value.restrictMeasurementOnLowBattery
+        this[Keys.WAKE_LOCK] = value.useWakeLock
+        this[Keys.KEEP_PHONE_DISPLAY_ON] = value.keepPhoneDisplayOn
+        this[Keys.KEEP_DISPLAY_ON] = value.keepWearDisplayOn
+    }
+
+    private object Keys {
+        val COMPLETED_INTRO = booleanPreferencesKey("completed_intro")
+        val ACCEPTED_POLICY = booleanPreferencesKey("accepted_policy")
+        val GPS_INTERVAL = intPreferencesKey("gps_interval_seconds")
+        val GPS_DISTANCE = intPreferencesKey("gps_min_distance_meters")
+        val SAMPLING_PERIOD = intPreferencesKey("sensor_sampling_period")
+        val LOW_BATTERY = booleanPreferencesKey("restrict_on_low_battery")
+        val WAKE_LOCK = booleanPreferencesKey("use_wake_lock")
+        val KEEP_PHONE_DISPLAY_ON = booleanPreferencesKey("keep_phone_display_on")
+        val KEEP_DISPLAY_ON = booleanPreferencesKey("keep_wear_display_on")
+    }
+}