From 1e55144291ef99eb9d5096c6706fa1737dff5fec Mon Sep 17 00:00:00 2001 From: "Timur Kh." Date: Mon, 19 Oct 2026 14:52:20 +0300 Subject: [PATCH] some backend fixes and add android app --- .gitignore | 8 + Makefile | 14 +- android/README.md | 127 ++++++ android/app/build.gradle.kts | 85 +++++ android/app/src/main/AndroidManifest.xml | 30 ++ .../kadence/android/KadenceApplication.kt | 5 + .../tech/kadence/android/MainActivity.kt | 176 +++++++++ .../tech/kadence/android/data/dto/Dtos.kt | 310 +++++++++++++++ .../tech/kadence/android/data/net/ApiError.kt | 62 +++ .../tech/kadence/android/data/net/Json.kt | 23 ++ .../kadence/android/data/net/KadenceApi.kt | 175 +++++++++ .../android/ui/components/Primitives.kt | 265 +++++++++++++ .../android/ui/components/TabularFigures.kt | 68 ++++ .../android/ui/components/TimerDial.kt | 166 ++++++++ .../kadence/android/ui/theme/KadenceTheme.kt | 179 +++++++++ .../kadence/android/ui/theme/KadenceType.kt | 153 ++++++++ .../res/drawable/ic_launcher_foreground.xml | 29 ++ android/app/src/main/res/font/fraunces.ttf | Bin 0 -> 360440 bytes android/app/src/main/res/font/inter.ttf | Bin 0 -> 876576 bytes .../res/mipmap-anydpi-v26/ic_launcher.xml | 6 + android/app/src/main/res/raw/ofl_fraunces.txt | 93 +++++ android/app/src/main/res/raw/ofl_inter.txt | 93 +++++ .../app/src/main/res/values-night/colors.xml | 5 + android/app/src/main/res/values/colors.xml | 7 + android/app/src/main/res/values/strings.xml | 4 + android/app/src/main/res/values/themes.xml | 13 + .../tech/kadence/android/DtoToleranceTest.kt | 256 +++++++++++++ .../tech/kadence/android/KadenceApiTest.kt | 225 +++++++++++ .../kotlin/tech/kadence/android/ThemeTest.kt | 135 +++++++ .../src/test/resources/fixtures/auth_me.json | 8 + .../test/resources/fixtures/block_events.json | 9 + .../fixtures/blocker_policy_active.json | 17 + .../fixtures/blocker_policy_inactive.json | 17 + .../test/resources/fixtures/daily_report.json | 41 ++ .../resources/fixtures/stats_summary.json | 20 + .../src/test/resources/fixtures/tasks.json | 32 ++ .../fixtures/timer_complete_reply.json | 52 +++ .../resources/fixtures/timer_state_idle.json | 11 + .../fixtures/timer_state_running.json | 29 ++ android/build.gradle.kts | 8 + android/core/build.gradle.kts | 17 + .../main/kotlin/tech/kadence/core/Blocker.kt | 191 +++++++++ .../main/kotlin/tech/kadence/core/Format.kt | 87 +++++ .../src/main/kotlin/tech/kadence/core/Glob.kt | 89 +++++ .../kotlin/tech/kadence/core/GlyphFrame.kt | 224 +++++++++++ .../main/kotlin/tech/kadence/core/Matchers.kt | 200 ++++++++++ .../main/kotlin/tech/kadence/core/Outbox.kt | 245 ++++++++++++ .../kotlin/tech/kadence/core/TimeWindow.kt | 32 ++ .../main/kotlin/tech/kadence/core/Timer.kt | 248 ++++++++++++ .../main/kotlin/tech/kadence/core/Tokens.kt | 203 ++++++++++ .../kotlin/tech/kadence/core/BlockerTest.kt | 243 ++++++++++++ .../kotlin/tech/kadence/core/FormatTest.kt | 111 ++++++ .../test/kotlin/tech/kadence/core/GlobTest.kt | 156 ++++++++ .../tech/kadence/core/GlyphFrameTest.kt | 301 +++++++++++++++ .../kotlin/tech/kadence/core/MatchersTest.kt | 319 ++++++++++++++++ .../kotlin/tech/kadence/core/OutboxTest.kt | 361 ++++++++++++++++++ .../tech/kadence/core/TimeWindowTest.kt | 71 ++++ .../kotlin/tech/kadence/core/TimerTest.kt | 322 ++++++++++++++++ .../tech/kadence/core/TokenParityTest.kt | 261 +++++++++++++ android/gradle.properties | 9 + android/gradle/libs.versions.toml | 49 +++ android/gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 46175 bytes .../gradle/wrapper/gradle-wrapper.properties | 7 + android/gradlew | 248 ++++++++++++ android/gradlew.bat | 93 +++++ android/settings.gradle.kts | 52 +++ desktop/kadence_desktop/qml/ReportPage.qml | 4 +- desktop/kadence_desktop/qml/Theme.qml | 11 + desktop/kadence_desktop/qml/TimerPage.qml | 8 +- 69 files changed, 7111 insertions(+), 7 deletions(-) create mode 100644 android/README.md create mode 100644 android/app/build.gradle.kts create mode 100644 android/app/src/main/AndroidManifest.xml create mode 100644 android/app/src/main/kotlin/tech/kadence/android/KadenceApplication.kt create mode 100644 android/app/src/main/kotlin/tech/kadence/android/MainActivity.kt create mode 100644 android/app/src/main/kotlin/tech/kadence/android/data/dto/Dtos.kt create mode 100644 android/app/src/main/kotlin/tech/kadence/android/data/net/ApiError.kt create mode 100644 android/app/src/main/kotlin/tech/kadence/android/data/net/Json.kt create mode 100644 android/app/src/main/kotlin/tech/kadence/android/data/net/KadenceApi.kt create mode 100644 android/app/src/main/kotlin/tech/kadence/android/ui/components/Primitives.kt create mode 100644 android/app/src/main/kotlin/tech/kadence/android/ui/components/TabularFigures.kt create mode 100644 android/app/src/main/kotlin/tech/kadence/android/ui/components/TimerDial.kt create mode 100644 android/app/src/main/kotlin/tech/kadence/android/ui/theme/KadenceTheme.kt create mode 100644 android/app/src/main/kotlin/tech/kadence/android/ui/theme/KadenceType.kt create mode 100644 android/app/src/main/res/drawable/ic_launcher_foreground.xml create mode 100644 android/app/src/main/res/font/fraunces.ttf create mode 100644 android/app/src/main/res/font/inter.ttf create mode 100644 android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml create mode 100644 android/app/src/main/res/raw/ofl_fraunces.txt create mode 100644 android/app/src/main/res/raw/ofl_inter.txt create mode 100644 android/app/src/main/res/values-night/colors.xml create mode 100644 android/app/src/main/res/values/colors.xml create mode 100644 android/app/src/main/res/values/strings.xml create mode 100644 android/app/src/main/res/values/themes.xml create mode 100644 android/app/src/test/kotlin/tech/kadence/android/DtoToleranceTest.kt create mode 100644 android/app/src/test/kotlin/tech/kadence/android/KadenceApiTest.kt create mode 100644 android/app/src/test/kotlin/tech/kadence/android/ThemeTest.kt create mode 100644 android/app/src/test/resources/fixtures/auth_me.json create mode 100644 android/app/src/test/resources/fixtures/block_events.json create mode 100644 android/app/src/test/resources/fixtures/blocker_policy_active.json create mode 100644 android/app/src/test/resources/fixtures/blocker_policy_inactive.json create mode 100644 android/app/src/test/resources/fixtures/daily_report.json create mode 100644 android/app/src/test/resources/fixtures/stats_summary.json create mode 100644 android/app/src/test/resources/fixtures/tasks.json create mode 100644 android/app/src/test/resources/fixtures/timer_complete_reply.json create mode 100644 android/app/src/test/resources/fixtures/timer_state_idle.json create mode 100644 android/app/src/test/resources/fixtures/timer_state_running.json create mode 100644 android/build.gradle.kts create mode 100644 android/core/build.gradle.kts create mode 100644 android/core/src/main/kotlin/tech/kadence/core/Blocker.kt create mode 100644 android/core/src/main/kotlin/tech/kadence/core/Format.kt create mode 100644 android/core/src/main/kotlin/tech/kadence/core/Glob.kt create mode 100644 android/core/src/main/kotlin/tech/kadence/core/GlyphFrame.kt create mode 100644 android/core/src/main/kotlin/tech/kadence/core/Matchers.kt create mode 100644 android/core/src/main/kotlin/tech/kadence/core/Outbox.kt create mode 100644 android/core/src/main/kotlin/tech/kadence/core/TimeWindow.kt create mode 100644 android/core/src/main/kotlin/tech/kadence/core/Timer.kt create mode 100644 android/core/src/main/kotlin/tech/kadence/core/Tokens.kt create mode 100644 android/core/src/test/kotlin/tech/kadence/core/BlockerTest.kt create mode 100644 android/core/src/test/kotlin/tech/kadence/core/FormatTest.kt create mode 100644 android/core/src/test/kotlin/tech/kadence/core/GlobTest.kt create mode 100644 android/core/src/test/kotlin/tech/kadence/core/GlyphFrameTest.kt create mode 100644 android/core/src/test/kotlin/tech/kadence/core/MatchersTest.kt create mode 100644 android/core/src/test/kotlin/tech/kadence/core/OutboxTest.kt create mode 100644 android/core/src/test/kotlin/tech/kadence/core/TimeWindowTest.kt create mode 100644 android/core/src/test/kotlin/tech/kadence/core/TimerTest.kt create mode 100644 android/core/src/test/kotlin/tech/kadence/core/TokenParityTest.kt create mode 100644 android/gradle.properties create mode 100644 android/gradle/libs.versions.toml create mode 100644 android/gradle/wrapper/gradle-wrapper.jar create mode 100644 android/gradle/wrapper/gradle-wrapper.properties create mode 100755 android/gradlew create mode 100644 android/gradlew.bat create mode 100644 android/settings.gradle.kts diff --git a/.gitignore b/.gitignore index e6e539b..7d3f46f 100644 --- a/.gitignore +++ b/.gitignore @@ -23,3 +23,11 @@ backend/static/ .vscode/ .DS_Store tsconfig.tsbuildinfo +# Android +android/.gradle/ +android/build/ +android/*/build/ +android/local.properties +android/app/libs/*.aar +android/glyph/libs/*.aar +*.keystore diff --git a/Makefile b/Makefile index 17530d6..51eb246 100644 --- a/Makefile +++ b/Makefile @@ -36,10 +36,22 @@ desktop-install: ## Install the launcher entry and icon for your user helper-install: ## Install the privileged blocking helper (asks for sudo) sudo ./desktop/helper/install.sh +android-test: ## Run every Android test (no device, no backend needed) + cd android && ./gradlew :core:test :app:testDebugUnitTest + +android-test-core: ## Run just the pure-logic suite (needs only a JDK) + cd android && ./gradlew :core:test + +android-build: ## Build the debug APK (needs the Android SDK) + cd android && ./gradlew :app:assembleDebug + +android-install: ## Install the debug APK on the connected phone + cd android && ./gradlew :app:installDebug + report: ## Build and send today's report right now cd backend && PYTHONPATH=$$PWD .venv/bin/python -m app.cli report set-password: ## Set/rotate the web login password (asks for a confirm) docker compose exec app python -m app.cli set-password -.PHONY: help up down logs dev test backend-venv web-build desktop desktop-install helper-install report set-password +.PHONY: help up down logs dev test backend-venv web-build desktop desktop-install helper-install android-test android-test-core android-build android-install report set-password diff --git a/android/README.md b/android/README.md new file mode 100644 index 0000000..9d8f6c1 --- /dev/null +++ b/android/README.md @@ -0,0 +1,127 @@ +# Kadence for Android + +The fourth client, for the Nothing Phone (3). Same backend, same editorial design, plus +the three things only a native phone client can do: enforce the focus guard on the phone +itself, surface the running interval as an Android 16 Live Update, and draw the timer on +the rear Glyph Matrix. + +## Two modules, and why + +| Module | What it is | Needs the Android SDK? | +| --- | --- | --- | +| **`core`** | Plain Kotlin on the JVM: the matchers, the policy clock, the timer maths, the outbox reconciliation, the Glyph frame renderer, the design tokens | **No** | +| **`app`** | The Android client: Compose UI, services, Room, the HTTP client, the Glyph toy | Yes | + +Everything with interesting behaviour lives in `core`, deliberately. The result is that +the hard parts — offline reconciliation, glob and mask matching, the blocking policy, +even the 25×25 rear display — are **testable on a laptop with nothing but a JDK**, with +no emulator, no SDK and no phone in the loop: + +```bash +make android-test # both modules: 219 tests, no device, no backend +make android-test-core # just the pure-logic suite: needs only a JDK +``` + +`settings.gradle.kts` only includes `:app` when an SDK is actually present, so that +command works on a machine that has never seen the Android tooling. + +## Running the tests + +``` +./gradlew :core:test :app:testDebugUnitTest +``` + +**219 tests, none of which need a device or a running backend.** The backend lives only +on the dev machine, so the suite feeds on committed JSON fixtures under +`app/src/test/resources/fixtures/` and a `MockWebServer`; there is no step that curls a +live server. + +`:core` (186 tests): + +| Suite | What it pins down | +| --- | --- | +| `GlobTest` | Python `fnmatch` parity — expectations generated from CPython, because the block lists are shared with the backend | +| `BlockerTest` | `blocker_service.py` parity: `expand_entry`, allow-list subtraction, the policy decision and its reason strings, schedule windows incl. midnight wrap | +| `DomainMatcherTest` / `AppMatcherTest` | hostname and app matching, allow-list precedence, and the masks a hosts file cannot express | +| `NormalizeHostTest` | what a browser URL bar actually hands over: bare hosts, full URLs, search phrases, `chrome://`, punycode | +| `ReconcileTest` | one test per row of the conflict matrix — another device taking over, our own replay landing, view-only mode | +| `OutboxCoalesceTest` / `PostconditionTest` / `PartitionForReplayTest` | the offline queue: coalescing, the at-most-once probes, and quarantining intervals that cannot be filed honestly | +| `TickMathTest` / `DialGeometryTest` | the countdown anchor and the dial's tick rule | +| `Glyph*Test` | the rear matrix, asserted as ASCII art | +| `TokenParityTest` | reads `frontend/src/tokens.ts` and `lib/viz.ts` and fails if a single colour channel drifts | +| `AccentTest` | the system-accent policy and its contrast guard | + +`:app` (33 tests, on the JVM via Robolectric): + +| Suite | What it pins down | +| --- | --- | +| `DtoToleranceTest` | every endpoint's fixture decodes — then decodes again with keys stripped, unknown keys added and nulls where values are declared. The backend has no response models, so this is the contract | +| `KadenceApiTest` | `X-API-Token`, the session cookie, 401 routing (and *not* routing on the login path), both FastAPI `detail` shapes, a 422 rendered as `field: message`, an unreachable server as a typed error | +| `ThemeTest` | the palette actually reaching a composable, and that the serif clock is genuinely fixed-advance | + +## Toolchain + +Gradle 9.6 (via the wrapper) on **JDK 21** — newer JDKs are ahead of what AGP +supports: + +```bash +export JAVA_HOME=/usr/lib/jvm/java-21-openjdk +``` + +For the `app` module you also need an Android SDK. AGP 9.4 with Compose 1.12 wants +`compileSdk 37`, which is published under Android's new minor-version scheme as +`platforms;android-37.0` (plain `android-37` does not exist). `targetSdk` stays 36, +because Android 16 is what the phone runs. Point the build at the SDK with +`ANDROID_HOME`, or `android/local.properties`: + +``` +sdk.dir=/home/you/Android/Sdk +``` + +## The Glyph Matrix SDK + +`glyph-matrix-sdk-2.0.aar` is **not on Maven** — it has to be downloaded from +[Nothing's developer kit](https://github.com/Nothing-Developer-Programme/GlyphMatrix-Developer-Kit) +and dropped into `glyph/libs/`. It is git-ignored, and the Glyph code sits behind an +interface with a no-op implementation, so a missing `.aar` disables the rear display and +breaks nothing else. The renderer itself is in `core` and needs none of this to be +tested. + +## Design notes + +* **Fraunces has no tabular figures.** Its digits are proportional — `1` is 1024 units + against `0` at 1461 — and the font ships no `tnum` feature, so the web app's global + `font-variant-numeric: tabular-nums` does nothing for the serif dial clock. Here the + clock goes through `TabularFigures`, which lays every glyph in a box as wide as the + widest digit; `ThemeTest` measures it. Inter *does* ship `tnum`, so the sans numbers + are fixed with a font feature instead. +* **The canvas is Kadence's, the accent is the phone's.** Warm paper, ink type, hairline + rules and Fraunces figures are fixed; the single accent comes from Android's dynamic + palette when available, falling back to the brand ember. `onAccentArgb()` picks the + label colour by WCAG contrast, because a wallpaper-derived accent can be any lightness + — that guard is what keeps "use the system colour" from producing unreadable buttons. +* **Chart colours never follow the accent.** They come from the validated, colour-blind + safe palette in `viz.ts`. A chart has to stay readable; that is a property of the + palette, not of the wallpaper. +* **No `VpnService`, ever.** Android allows exactly one, and it belongs to the user's + always-on VPN. Website blocking reads the browser URL bar through an accessibility + service instead; app blocking polls `UsageStatsManager`. Neither touches the VPN slot. +* **The server owns the clock.** The phone polls, ticks locally from a monotonic anchor, + and re-anchors on every reply. Offline writes go to an outbox and the server's answer + always wins the final word. + +## Verifying on the device + +See the plan at `~/.claude/plans/make-an-app-for-logical-russell.md` for the full manual +script. The short version, once the SDK is installed: + +```bash +make up # backend + web UI on :8000 +ip -4 addr show | grep inet # find the LAN address for the phone +make android-install # ./gradlew :app:installDebug +adb logcat -s Kadence:* +``` + +Note that an always-on VPN can swallow a LAN address; `adb shell curl -s +http://:8000/api/health` is the first thing to check if onboarding cannot reach +the backend. diff --git a/android/app/build.gradle.kts b/android/app/build.gradle.kts new file mode 100644 index 0000000..5f120b0 --- /dev/null +++ b/android/app/build.gradle.kts @@ -0,0 +1,85 @@ +plugins { + // AGP 9 has built-in Kotlin support, so `org.jetbrains.kotlin.android` is gone; + // only the Compose compiler plugin is still applied explicitly. + alias(libs.plugins.android.application) + alias(libs.plugins.kotlin.compose) + alias(libs.plugins.kotlin.serialization) +} + +android { + namespace = "tech.kadence.android" + compileSdk = libs.versions.compileSdk.get().toInt() + + defaultConfig { + applicationId = "tech.kadence.android" + minSdk = libs.versions.minSdk.get().toInt() + targetSdk = libs.versions.targetSdk.get().toInt() + versionCode = 1 + versionName = "0.1.0" + testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" + } + + buildTypes { + debug { + // So a debug build can sit beside a release one on the same phone. + applicationIdSuffix = ".debug" + } + release { + isMinifyEnabled = false + } + } + + buildFeatures { + compose = true + buildConfig = true + } + + compileOptions { + sourceCompatibility = JavaVersion.VERSION_21 + targetCompatibility = JavaVersion.VERSION_21 + } + + testOptions { + unitTests.isIncludeAndroidResources = true + } + + packaging { + resources.excludes += setOf("/META-INF/{AL2.0,LGPL2.1}") + } +} + +dependencies { + // Every piece of logic worth testing lives here, and it has no Android dependency. + implementation(project(":core")) + + implementation(libs.serialization.json) + implementation(libs.okhttp) + + implementation(platform(libs.compose.bom)) + implementation(libs.compose.ui) + implementation(libs.compose.ui.graphics) + implementation(libs.compose.foundation) + implementation(libs.compose.material3) + implementation(libs.compose.ui.tooling.preview) + debugImplementation(libs.compose.ui.tooling) + + implementation(libs.activity.compose) + implementation(libs.navigation.compose) + implementation(libs.lifecycle.viewmodel.compose) + implementation(libs.lifecycle.runtime.compose) + + // Robolectric runs these on the JVM, so the UI layer is verifiable without a + // device or an emulator — the same reason the logic lives in :core. + testImplementation(libs.junit) + testImplementation(libs.kotlin.test) + testImplementation(libs.robolectric) + testImplementation(libs.coroutines.test) + testImplementation(libs.mockwebserver) + testImplementation(platform(libs.compose.bom)) + testImplementation(libs.compose.ui.test.junit4) + debugImplementation(libs.compose.ui.test.manifest) + + androidTestImplementation(platform(libs.compose.bom)) + androidTestImplementation(libs.compose.ui.test.junit4) + debugImplementation(libs.compose.ui.test.manifest) +} diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml new file mode 100644 index 0000000..1f01607 --- /dev/null +++ b/android/app/src/main/AndroidManifest.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + diff --git a/android/app/src/main/kotlin/tech/kadence/android/KadenceApplication.kt b/android/app/src/main/kotlin/tech/kadence/android/KadenceApplication.kt new file mode 100644 index 0000000..5f53d9f --- /dev/null +++ b/android/app/src/main/kotlin/tech/kadence/android/KadenceApplication.kt @@ -0,0 +1,5 @@ +package tech.kadence.android + +import android.app.Application + +class KadenceApplication : Application() diff --git a/android/app/src/main/kotlin/tech/kadence/android/MainActivity.kt b/android/app/src/main/kotlin/tech/kadence/android/MainActivity.kt new file mode 100644 index 0000000..14ace55 --- /dev/null +++ b/android/app/src/main/kotlin/tech/kadence/android/MainActivity.kt @@ -0,0 +1,176 @@ +package tech.kadence.android + +import android.os.Bundle +import androidx.activity.ComponentActivity +import androidx.activity.compose.setContent +import androidx.activity.enableEdgeToEdge +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp +import kotlinx.coroutines.delay +import tech.kadence.android.ui.components.GhostButton +import tech.kadence.android.ui.components.HorizontalRule +import tech.kadence.android.ui.components.PageHeader +import tech.kadence.android.ui.components.Panel +import tech.kadence.android.ui.components.PresetChip +import tech.kadence.android.ui.components.PrimaryButton +import tech.kadence.android.ui.components.SectionTitle +import tech.kadence.android.ui.components.Stat +import tech.kadence.android.ui.components.StatSize +import tech.kadence.android.ui.components.TimerDial +import tech.kadence.android.ui.components.VerticalRule +import tech.kadence.android.ui.theme.KadenceTheme +import tech.kadence.core.Kind +import tech.kadence.core.KIND_LABEL +import tech.kadence.core.humanMinutes + +class MainActivity : ComponentActivity() { + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + enableEdgeToEdge() + setContent { + KadenceTheme { + Surface( + modifier = Modifier.fillMaxSize(), + color = KadenceTheme.colors.paper, + ) { + DesignGallery() + } + } + } + } +} + +/** + * A scratch screen for the design system, standing in until the real Timer screen + * lands. It exists so the tokens, the type and the dial can be checked against the web + * app side by side on a device. + */ +@Composable +private fun DesignGallery() { + val colors = KadenceTheme.colors + val planned = 25 * 60 + + // A live countdown, so the dial and the fixed-advance clock can be watched ticking. + var remaining by remember { mutableIntStateOf(18 * 60 + 24) } + var paused by remember { mutableStateOf(false) } + var preset by remember { mutableIntStateOf(0) } + + LaunchedEffect(paused) { + while (!paused) { + delay(1000) + remaining = if (remaining > 0) remaining - 1 else planned + } + } + + Column( + Modifier + .fillMaxSize() + .verticalScroll(rememberScrollState()) + .padding(horizontal = 20.dp, vertical = 28.dp), + verticalArrangement = Arrangement.spacedBy(22.dp), + ) { + PageHeader( + eyebrow = "Monday, 19 October", + title = KIND_LABEL.getValue(Kind.WORK), + caption = "Tracking \"Fix the flaky importer\"", + ) { + GhostButton(text = if (paused) "Resume" else "Pause", onClick = { paused = !paused }) + PrimaryButton(text = "Finish", onClick = { remaining = planned }) + } + + Panel(padding = 24.dp) { + TimerDial( + label = KIND_LABEL.getValue(Kind.WORK), + remaining = { remaining }, + plannedSeconds = planned, + accent = KadenceTheme.viz.work, + sublabel = "Cycle 2 of 4 before a long break", + paused = paused, + modifier = Modifier.fillMaxWidth(), + ) + Spacer(Modifier.height(14.dp)) + Row( + Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.CenterHorizontally), + ) { + listOf("Classic", "Пара", "Custom").forEachIndexed { index, name -> + PresetChip( + text = name, + selected = preset == index, + onClick = { preset = index }, + ) + } + } + } + + SectionTitle("Today", trailing = "6 of 8") + Panel(padding = 0.dp) { + Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) { + Stat( + label = "Focus today", + value = humanMinutes(155), + caption = "35m resting", + modifier = Modifier.weight(1f).padding(16.dp), + ) + VerticalRule(height = 70.dp) + Stat( + label = "Interruptions", + value = "3", + caption = "counted, not stopped", + tabular = true, + modifier = Modifier.weight(1f).padding(16.dp), + ) + } + HorizontalRule() + Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) { + Stat( + label = "Score", + value = "72", + caption = "out of 100", + size = StatSize.Large, + accent = colors.accent, + tabular = true, + modifier = Modifier.weight(1f).padding(16.dp), + ) + VerticalRule(height = 84.dp) + Stat( + label = "Streak", + value = "4d", + caption = "best 11", + size = StatSize.Large, + modifier = Modifier.weight(1f).padding(16.dp), + ) + } + } + + SectionTitle("Palette") + Panel { + Text( + text = "The accent is taken from the system palette; paper, ink and the " + + "hairlines stay Kadence's. Chart colours never follow the accent.", + style = KadenceTheme.type.bodySmall, + color = colors.inkMuted, + ) + } + } +} diff --git a/android/app/src/main/kotlin/tech/kadence/android/data/dto/Dtos.kt b/android/app/src/main/kotlin/tech/kadence/android/data/dto/Dtos.kt new file mode 100644 index 0000000..89bd5cb --- /dev/null +++ b/android/app/src/main/kotlin/tech/kadence/android/data/dto/Dtos.kt @@ -0,0 +1,310 @@ +/** + * The wire shapes. + * + * The backend has **no response models** — `backend/app/api/schemas.py` only declares + * request bodies, and every response is a plain dict built by a service function. So + * the only contract is the service code plus `frontend/src/lib/types.ts`, and these DTOs + * are reverse-engineered from both. + * + * That means tolerance is the design, not a nicety: **every field has a default and + * every nested object is nullable**, so a backend that grows a key, drops one, or sends + * null where a value is declared can never crash the phone. `DtoToleranceTest` asserts + * exactly that by mutating committed fixtures. + * + * Two details worth not re-learning the hard way: + * * `TimerStateDto.durations` is in **minutes** (`pomodoro.state()`), not seconds. + * * `paused_seconds` exists on the wire but is missing from `types.ts`; the outbox + * reconciliation wants it, so it is declared here. + */ +package tech.kadence.android.data.dto + +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable + +@Serializable +data class TaskRefDto( + val source: String = "", + @SerialName("external_id") val externalId: String = "", + val title: String = "", +) + +@Serializable +data class TimerSessionDto( + val id: Long = 0, + val kind: String = "work", + val status: String = "running", + @SerialName("started_at") val startedAt: String? = null, + @SerialName("ended_at") val endedAt: String? = null, + @SerialName("planned_seconds") val plannedSeconds: Int = 0, + @SerialName("elapsed_seconds") val elapsedSeconds: Int = 0, + @SerialName("remaining_seconds") val remainingSeconds: Int = 0, + @SerialName("paused_seconds") val pausedSeconds: Int = 0, + val interruptions: Int = 0, + @SerialName("cycle_index") val cycleIndex: Int = 0, + val task: TaskRefDto? = null, + val note: String? = null, +) + +@Serializable +data class TimerStateDto( + val current: TimerSessionDto? = null, + @SerialName("next_kind") val nextKind: String = "work", + @SerialName("completed_today") val completedToday: Int = 0, + val goal: Int = 8, + @SerialName("cycle_position") val cyclePosition: Int = 0, + @SerialName("cycles_before_long_break") val cyclesBeforeLongBreak: Int = 4, + /** Minutes per kind, not seconds. */ + val durations: Map = emptyMap(), + @SerialName("server_time") val serverTime: String? = null, + /** Only present on a `complete` reply. */ + val finished: TimerSessionDto? = null, + @SerialName("auto_started") val autoStarted: TimerSessionDto? = null, + val celebration: String? = null, + @SerialName("timer_enabled") val timerEnabled: Boolean = true, +) + +@Serializable +data class TaskDto( + val id: Long = 0, + val source: String = "", + @SerialName("source_label") val sourceLabel: String = "", + @SerialName("external_id") val externalId: String = "", + val title: String = "", + val description: String? = null, + val url: String? = null, + val project: String? = null, + val status: String? = null, + val priority: String? = null, + @SerialName("due_date") val dueDate: String? = null, + @SerialName("start_date") val startDate: String? = null, + val labels: List = emptyList(), + @SerialName("is_done") val isDone: Boolean = false, + val pinned: Boolean = false, + val stale: Boolean = false, + @SerialName("estimated_pomodoros") val estimatedPomodoros: Int? = null, + @SerialName("days_overdue") val daysOverdue: Int = 0, + val bucket: String = "someday", +) + +@Serializable +data class TaskListDto( + val date: String = "", + val tasks: List = emptyList(), + val counts: Map = emptyMap(), + val sources: List = emptyList(), +) + +@Serializable +data class RefreshSourceDto( + val source: String = "", + val label: String = "", + val ok: Boolean = true, + val error: String? = null, + val count: Int = 0, + val closed: Int = 0, +) + +@Serializable +data class RefreshResultDto( + @SerialName("refreshed_at") val refreshedAt: String? = null, + val date: String = "", + val total: Int = 0, + val closed: Int = 0, + val sources: List = emptyList(), +) + +@Serializable +data class BlockerPolicyDto( + val active: Boolean = false, + val reason: String = "", + val mode: String = "during_work", + val enabled: Boolean = false, + val strict: Boolean = false, + @SerialName("redirect_ip") val redirectIp: String = "127.0.0.1", + /** Empty whenever `active` is false — read `all_domains` instead. */ + val domains: List = emptyList(), + /** Likewise empty when inactive. */ + val apps: List = emptyList(), + val unexpandable: List = emptyList(), + @SerialName("kill_apps") val killApps: Boolean = true, + @SerialName("notify_on_block") val notifyOnBlock: Boolean = true, + @SerialName("poll_seconds") val pollSeconds: Int = 5, + @SerialName("session_id") val sessionId: Long? = null, + /** Always populated, whatever `active` says. */ + @SerialName("all_domains") val allDomains: List = emptyList(), + @SerialName("all_apps") val allApps: List = emptyList(), +) + +@Serializable +data class BlockEventDto( + val id: Long = 0, + val kind: String = "app", + val target: String = "", + val action: String = "blocked", + val at: String? = null, + val details: String? = null, +) + +@Serializable +data class TargetCountDto(val target: String = "", val count: Int = 0) + +@Serializable +data class BlockEventsDto( + val date: String = "", + val total: Int = 0, + @SerialName("by_target") val byTarget: List = emptyList(), + val events: List = emptyList(), +) + +@Serializable +data class HourCountDto(val hour: Int = 0, val count: Int = 0) + +@Serializable +data class CompletedTaskDto( + val id: Long = 0, + val title: String = "", + val source: String = "", + val project: String? = null, + val url: String? = null, +) + +@Serializable +data class TaskMinutesDto(val title: String = "", val minutes: Int = 0) + +@Serializable +data class DaySessionDto( + val id: Long = 0, + val kind: String = "work", + val status: String = "completed", + @SerialName("started_at") val startedAt: String? = null, + val minutes: Int = 0, + val task: String? = null, + val interruptions: Int = 0, +) + +@Serializable +data class DayMetricsDto( + val date: String = "", + val pomodoros: Int = 0, + val goal: Int = 8, + @SerialName("goal_pct") val goalPct: Double = 0.0, + @SerialName("goal_met") val goalMet: Boolean = false, + @SerialName("focus_minutes") val focusMinutes: Int = 0, + @SerialName("break_minutes") val breakMinutes: Int = 0, + @SerialName("wasted_minutes") val wastedMinutes: Int = 0, + val abandoned: Int = 0, + @SerialName("breaks_taken") val breaksTaken: Int = 0, + val interruptions: Int = 0, + @SerialName("completion_rate") val completionRate: Double = 0.0, + @SerialName("longest_stretch_minutes") val longestStretchMinutes: Int = 0, + @SerialName("first_start") val firstStart: String? = null, + @SerialName("last_end") val lastEnd: String? = null, + @SerialName("by_hour") val byHour: List = emptyList(), + @SerialName("peak_hour") val peakHour: Int? = null, + @SerialName("tasks_completed") val tasksCompleted: List = emptyList(), + @SerialName("tasks_completed_count") val tasksCompletedCount: Int = 0, + @SerialName("time_by_task") val timeByTask: List = emptyList(), + @SerialName("blocked_attempts") val blockedAttempts: Int = 0, + @SerialName("blocked_top") val blockedTop: List = emptyList(), + val sessions: List = emptyList(), +) + +@Serializable +data class StreakDto( + val current: Int = 0, + val best: Int = 0, + @SerialName("goal_streak") val goalStreak: Int = 0, + @SerialName("total_days") val totalDays: Int = 0, +) + +@Serializable +data class LifetimeDto( + val pomodoros: Int = 0, + @SerialName("focus_minutes") val focusMinutes: Int = 0, + @SerialName("focus_hours") val focusHours: Double = 0.0, + @SerialName("tasks_completed") val tasksCompleted: Int = 0, + @SerialName("blocked_attempts") val blockedAttempts: Int = 0, +) + +@Serializable +data class AverageDto( + val pomodoros: Double = 0.0, + @SerialName("focus_minutes") val focusMinutes: Double = 0.0, +) + +@Serializable +data class ComparisonDto( + val yesterday: Int = 0, + @SerialName("previous_best") val previousBest: Int = 0, +) + +@Serializable +data class AchievementDto( + val code: String = "", + val emoji: String = "", + val title: String = "", + val detail: String = "", +) + +@Serializable +data class DailyReportDto( + val date: String = "", + val metrics: DayMetricsDto = DayMetricsDto(), + val streak: StreakDto = StreakDto(), + @SerialName("average_7d") val average7d: AverageDto = AverageDto(), + val lifetime: LifetimeDto = LifetimeDto(), + val comparison: ComparisonDto = ComparisonDto(), + val achievements: List = emptyList(), + @SerialName("fun_facts") val funFacts: List = emptyList(), + val verdict: String = "", + @SerialName("open_tasks") val openTasks: Map = emptyMap(), + val score: Double = 0.0, +) + +@Serializable +data class DailyReportEnvelopeDto( + val report: DailyReportDto = DailyReportDto(), + @SerialName("sent_at") val sentAt: String? = null, + @SerialName("telegram_preview") val telegramPreview: String = "", +) + +@Serializable +data class RangeDayDto( + val date: String = "", + val pomodoros: Int = 0, + @SerialName("focus_minutes") val focusMinutes: Int = 0, + @SerialName("goal_met") val goalMet: Boolean = false, +) + +@Serializable +data class StatsSummaryDto( + val today: DayMetricsDto = DayMetricsDto(), + val streak: StreakDto = StreakDto(), + val lifetime: LifetimeDto = LifetimeDto(), + @SerialName("average_7d") val average7d: AverageDto = AverageDto(), + val range: List = emptyList(), + val heatmap: List = emptyList(), +) + +@Serializable +data class AuthMeDto( + val authenticated: Boolean = false, + @SerialName("login_required") val loginRequired: Boolean = false, + val username: String = "", + @SerialName("password_login_enabled") val passwordLoginEnabled: Boolean = false, + @SerialName("telegram_login_enabled") val telegramLoginEnabled: Boolean = false, + @SerialName("telegram_bot_username") val telegramBotUsername: String = "", +) + +@Serializable +data class HealthDto( + val status: String = "", + val version: String = "", +) + +@Serializable +data class SessionsResponseDto( + val date: String = "", + val sessions: List = emptyList(), + val metrics: DayMetricsDto = DayMetricsDto(), +) diff --git a/android/app/src/main/kotlin/tech/kadence/android/data/net/ApiError.kt b/android/app/src/main/kotlin/tech/kadence/android/data/net/ApiError.kt new file mode 100644 index 0000000..0fc52cd --- /dev/null +++ b/android/app/src/main/kotlin/tech/kadence/android/data/net/ApiError.kt @@ -0,0 +1,62 @@ +/** + * Error shapes, and what a call can come back as. + * + * FastAPI returns `{"detail": "..."}` for an `HTTPException` and + * `{"detail": [{loc, msg, ...}]}` for a 422. Both existing clients unwrap both forms — + * `frontend/src/lib/api.ts` and `desktop/kadence_desktop/api.py` — so this does too, + * and renders a validation error as `field: message` rather than raw JSON. + */ +package tech.kadence.android.data.net + +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.contentOrNull +import kotlinx.serialization.json.jsonArray +import kotlinx.serialization.json.jsonObject +import kotlinx.serialization.json.jsonPrimitive + +/** The outcome of one call. */ +sealed interface ApiResult { + data class Ok(val value: T) : ApiResult + + /** A 4xx/5xx the server explained. Never retried blindly. */ + data class HttpError(val status: Int, val detail: String) : ApiResult + + /** The session or token is no longer good; the UI drops to the login gate. */ + data class Unauthorized(val detail: String) : ApiResult + + /** + * Nothing came back. **Ambiguous for a write**: the request may or may not have + * been applied, which is why the outbox probes a post-condition instead of + * resending. See `Outbox.kt` in `:core`. + */ + data class NetworkError(val cause: Throwable) : ApiResult +} + +/** Pull a human message out of either `detail` shape; fall back to the status line. */ +fun parseErrorDetail(body: String?, fallback: String): String { + if (body.isNullOrBlank()) return fallback + val element = runCatching { KadenceJson.parseToJsonElement(body) }.getOrNull() ?: return fallback + val detail = (element as? JsonObject)?.get("detail") ?: return fallback + + // The simple case: {"detail": "No interval is running."} + (detail as? JsonPrimitive)?.contentOrNull?.let { return it } + + // The 422 case: {"detail": [{"loc": ["body", "minutes"], "msg": "..."}]} + if (detail is JsonArray) { + val parts = detail.jsonArray.mapNotNull { item -> + val obj = item as? JsonObject ?: return@mapNotNull null + val loc = (obj["loc"] as? JsonArray) + ?.drop(1) + ?.mapNotNull { it.jsonPrimitive.contentOrNull } + ?.joinToString(".") + .orEmpty() + val msg = (obj["msg"] as? JsonPrimitive)?.contentOrNull.orEmpty() + listOf(loc, msg).filter { it.isNotBlank() }.joinToString(": ").ifBlank { null } + } + if (parts.isNotEmpty()) return parts.joinToString("; ") + } + + return fallback +} diff --git a/android/app/src/main/kotlin/tech/kadence/android/data/net/Json.kt b/android/app/src/main/kotlin/tech/kadence/android/data/net/Json.kt new file mode 100644 index 0000000..8f3bf24 --- /dev/null +++ b/android/app/src/main/kotlin/tech/kadence/android/data/net/Json.kt @@ -0,0 +1,23 @@ +/** + * The one JSON configuration. + * + * This object *is* the tolerance strategy for a backend with no response models: + * + * * `ignoreUnknownKeys` — the server may grow a field at any time. + * * `coerceInputValues` — a declared-non-null field arriving as `null` falls back to + * its default instead of throwing. + * * `explicitNulls = false` — we never send `null` for an absent value, which matters + * for the settings PUT: the backend deep-merges, so an explicit null would clobber. + * * `isLenient` — survives the odd unquoted value. + */ +package tech.kadence.android.data.net + +import kotlinx.serialization.json.Json + +val KadenceJson: Json = Json { + ignoreUnknownKeys = true + coerceInputValues = true + explicitNulls = false + isLenient = true + encodeDefaults = false +} diff --git a/android/app/src/main/kotlin/tech/kadence/android/data/net/KadenceApi.kt b/android/app/src/main/kotlin/tech/kadence/android/data/net/KadenceApi.kt new file mode 100644 index 0000000..b8c2ab2 --- /dev/null +++ b/android/app/src/main/kotlin/tech/kadence/android/data/net/KadenceApi.kt @@ -0,0 +1,175 @@ +/** + * The one place that talks to the backend. + * + * Hand-written over OkHttp rather than generated, for two reasons specific to this + * server: the base URL is configured by the user at runtime (so a client that freezes + * it at construction is the wrong shape), and there are no response models to generate + * from anyway. `desktop/kadence_desktop/api.py` does the same job in 150 stdlib lines; + * keeping this file shaped like it means the two clients stay diff-able. + * + * Auth mirrors the other clients: `X-API-Token` when a token is configured, plus a + * cookie jar for the `kadence_session` the browser login sets. Either is sufficient — + * `backend/app/api/deps.py` accepts either. + */ +package tech.kadence.android.data.net + +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import okhttp3.Cookie +import okhttp3.CookieJar +import okhttp3.HttpUrl +import okhttp3.HttpUrl.Companion.toHttpUrlOrNull +import okhttp3.Interceptor +import okhttp3.MediaType.Companion.toMediaType +import okhttp3.OkHttpClient +import okhttp3.Request +import okhttp3.RequestBody.Companion.toRequestBody +import java.io.IOException +import java.util.concurrent.TimeUnit + +private val JSON_MEDIA = "application/json; charset=utf-8".toMediaType() + +/** Where the backend is and how we prove who we are. Both user-supplied at runtime. */ +interface AuthConfig { + val baseUrl: String + val apiToken: String? +} + +/** + * Holds `kadence_session` across calls and process restarts. + * + * In-memory here; the real implementation persists through the Keystore-wrapped store. + * Kept behind an interface so the HTTP tests can use a plain map. + */ +class SimpleCookieJar : CookieJar { + private val cookies = mutableMapOf>() + + override fun saveFromResponse(url: HttpUrl, cookies: List) { + val host = url.host + val existing = this.cookies.getOrPut(host) { mutableListOf() } + for (cookie in cookies) { + existing.removeAll { it.name == cookie.name } + existing.add(cookie) + } + } + + override fun loadForRequest(url: HttpUrl): List = + cookies[url.host]?.filter { it.expiresAt > System.currentTimeMillis() } ?: emptyList() + + fun clear() = cookies.clear() + + fun named(name: String): Cookie? = cookies.values.flatten().firstOrNull { it.name == name } +} + +/** Adds the shared-secret header the desktop client also sends. */ +class AuthInterceptor(private val config: () -> AuthConfig) : Interceptor { + override fun intercept(chain: Interceptor.Chain): okhttp3.Response { + val builder = chain.request().newBuilder() + .header("Accept", "application/json") + config().apiToken?.takeIf { it.isNotBlank() }?.let { + builder.header("X-API-Token", it) + } + return chain.proceed(builder.build()) + } +} + +/** + * A 401 on anything but an `/api/auth/` path means the session died mid-use. + * + * The web app does the same (`api.ts`'s `onUnauthorized`) so the UI can drop to the + * login screen instead of showing a generic "backend unreachable". + */ +class UnauthorizedBus { + private val listeners = mutableSetOf<() -> Unit>() + + fun subscribe(listener: () -> Unit): () -> Unit { + listeners += listener + return { listeners -= listener } + } + + fun publish() = listeners.toList().forEach { it() } +} + +class KadenceApi( + private val config: () -> AuthConfig, + val cookieJar: SimpleCookieJar = SimpleCookieJar(), + val unauthorized: UnauthorizedBus = UnauthorizedBus(), + client: OkHttpClient? = null, +) { + private val http: OkHttpClient = client ?: OkHttpClient.Builder() + .connectTimeout(10, TimeUnit.SECONDS) + .readTimeout(20, TimeUnit.SECONDS) + .retryOnConnectionFailure(false) + .cookieJar(cookieJar) + .addInterceptor(AuthInterceptor(config)) + .build() + + /** Raw request; every typed call below funnels through here. */ + suspend fun request( + method: String, + path: String, + body: String? = null, + ): ApiResult = withContext(Dispatchers.IO) { + val base = config().baseUrl.trimEnd('/') + val url = "$base$path".toHttpUrlOrNull() + ?: return@withContext ApiResult.NetworkError( + IOException("not a usable backend URL: $base"), + ) + + val requestBody = when { + body != null -> body.toRequestBody(JSON_MEDIA) + method == "POST" || method == "PUT" || method == "PATCH" -> + "{}".toRequestBody(JSON_MEDIA) + else -> null + } + + val request = Request.Builder().url(url).method(method, requestBody).build() + + try { + http.newCall(request).execute().use { response -> + val text = response.body?.string() + if (response.code == 401 && !path.startsWith("/api/auth/")) { + unauthorized.publish() + return@withContext ApiResult.Unauthorized( + parseErrorDetail(text, "not authorised"), + ) + } + if (!response.isSuccessful) { + return@withContext ApiResult.HttpError( + response.code, + parseErrorDetail(text, "${response.code} ${response.message}"), + ) + } + ApiResult.Ok(text.orEmpty()) + } + } catch (e: IOException) { + // Deliberately not retried here: for a write this is ambiguous, and the + // outbox resolves it with a post-condition probe. + ApiResult.NetworkError(e) + } + } + + suspend inline fun get(path: String): ApiResult = decode(request("GET", path)) + + suspend inline fun post(path: String, body: String? = null): ApiResult = + decode(request("POST", path, body)) + + suspend inline fun put(path: String, body: String): ApiResult = + decode(request("PUT", path, body)) + + suspend inline fun patch(path: String, body: String): ApiResult = + decode(request("PATCH", path, body)) + + suspend inline fun delete(path: String): ApiResult = + decode(request("DELETE", path)) + + /** Decode a successful body, turning a malformed payload into an HttpError. */ + inline fun decode(result: ApiResult): ApiResult = when (result) { + is ApiResult.Ok -> runCatching { + ApiResult.Ok(KadenceJson.decodeFromString(result.value)) + }.getOrElse { ApiResult.HttpError(200, "unreadable response: ${it.message}") } + is ApiResult.HttpError -> result + is ApiResult.Unauthorized -> result + is ApiResult.NetworkError -> result + } +} diff --git a/android/app/src/main/kotlin/tech/kadence/android/ui/components/Primitives.kt b/android/app/src/main/kotlin/tech/kadence/android/ui/components/Primitives.kt new file mode 100644 index 0000000..070167d --- /dev/null +++ b/android/app/src/main/kotlin/tech/kadence/android/ui/components/Primitives.kt @@ -0,0 +1,265 @@ +/** + * The shared page furniture, ported from `frontend/src/components/Layout.tsx` and the + * QML `components/` set so all clients read as one product. + * + * The rule throughout: a hairline border does the separating. No shadows, no tonal + * elevation, no cards floating over the paper. + */ +package tech.kadence.android.ui.components + +import androidx.compose.foundation.BorderStroke +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.Button +import androidx.compose.material3.ButtonDefaults +import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.dp +import tech.kadence.android.ui.theme.KadenceTheme + +/** One hairline, defined once so no call site hand-rolls a 1px box. */ +@Composable +fun HorizontalRule(modifier: Modifier = Modifier, strong: Boolean = false) { + val colors = KadenceTheme.colors + Box( + modifier + .fillMaxWidth() + .height(1.dp) + .background(if (strong) colors.ruleStrong else colors.rule), + ) +} + +@Composable +fun VerticalRule(modifier: Modifier = Modifier, height: Dp) { + Box(modifier.width(1.dp).height(height).background(KadenceTheme.colors.rule)) +} + +/** The small-caps letterspaced label that sits above a serif title. */ +@Composable +fun Eyebrow(text: String, modifier: Modifier = Modifier, color: Color? = null) { + Text( + text = text.uppercase(), + style = KadenceTheme.type.eyebrow, + color = color ?: KadenceTheme.colors.inkMuted, + modifier = modifier, + ) +} + +/** Eyebrow, serif title, optional caption, then a rule. */ +@Composable +fun PageHeader( + eyebrow: String, + title: String, + caption: String? = null, + modifier: Modifier = Modifier, + actions: (@Composable () -> Unit)? = null, +) { + val colors = KadenceTheme.colors + Column(modifier.fillMaxWidth()) { + Eyebrow(eyebrow) + Column(Modifier.padding(top = 2.dp)) { + Text(text = title, style = KadenceTheme.type.pageTitle, color = colors.ink) + } + if (caption != null) { + Text( + text = caption, + style = KadenceTheme.type.bodySmall, + color = colors.inkMuted, + modifier = Modifier.padding(top = 4.dp), + ) + } + if (actions != null) { + Row( + Modifier.fillMaxWidth().padding(top = 12.dp), + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { actions() } + } + HorizontalRule(Modifier.padding(top = 14.dp)) + } +} + +/** An eyebrow, a rule filling the rest of the row, and an optional trailing note. */ +@Composable +fun SectionTitle( + label: String, + modifier: Modifier = Modifier, + trailing: String? = null, +) { + val colors = KadenceTheme.colors + Row( + modifier.fillMaxWidth(), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(10.dp), + ) { + Eyebrow(label) + HorizontalRule(Modifier.weight(1f)) + if (trailing != null) { + Text(text = trailing, style = KadenceTheme.type.caption, color = colors.inkFaint) + } + } +} + +/** A bordered surface. No shadow, no tint — the border does the separating. */ +@Composable +fun Panel( + modifier: Modifier = Modifier, + padding: Dp = 16.dp, + content: @Composable () -> Unit, +) { + val colors = KadenceTheme.colors + Surface( + modifier = modifier, + shape = RoundedCornerShape(14.dp), + color = colors.surface, + border = BorderStroke(1.dp, colors.rule), + tonalElevation = 0.dp, + shadowElevation = 0.dp, + ) { + Column(Modifier.padding(padding)) { content() } + } +} + +enum class StatSize { Small, Medium, Large } + +/** Label, serif figure, caption — the web app's `Stat`. */ +@Composable +fun Stat( + label: String, + value: String, + modifier: Modifier = Modifier, + caption: String? = null, + size: StatSize = StatSize.Medium, + accent: Color? = null, + tabular: Boolean = false, +) { + val colors = KadenceTheme.colors + val style = when (size) { + StatSize.Small -> KadenceTheme.type.statSmall + StatSize.Medium -> KadenceTheme.type.statMedium + StatSize.Large -> KadenceTheme.type.statLarge + } + Column(modifier) { + Eyebrow(label) + if (tabular) { + TabularFigures( + text = value, + style = style, + color = accent ?: colors.ink, + modifier = Modifier.padding(top = 2.dp), + ) + } else { + Text( + text = value, + style = style, + color = accent ?: colors.ink, + modifier = Modifier.padding(top = 2.dp), + ) + } + if (caption != null) { + Text( + text = caption, + style = KadenceTheme.type.caption, + color = colors.inkFaint, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } + } +} + +/** The filled accent button. Exactly one per view. */ +@Composable +fun PrimaryButton( + text: String, + onClick: () -> Unit, + modifier: Modifier = Modifier, + enabled: Boolean = true, +) { + val colors = KadenceTheme.colors + Button( + onClick = onClick, + modifier = modifier.heightIn(min = 40.dp), + enabled = enabled, + shape = RoundedCornerShape(8.dp), + colors = ButtonDefaults.buttonColors( + containerColor = colors.accent, + contentColor = colors.onAccent, + disabledContainerColor = colors.rule, + disabledContentColor = colors.inkFaint, + ), + elevation = null, + ) { + Text(text = text, style = KadenceTheme.type.button) + } +} + +/** The outlined one. Everything that is not the single primary action. */ +@Composable +fun GhostButton( + text: String, + onClick: () -> Unit, + modifier: Modifier = Modifier, + enabled: Boolean = true, +) { + val colors = KadenceTheme.colors + OutlinedButton( + onClick = onClick, + modifier = modifier.heightIn(min = 40.dp), + enabled = enabled, + shape = RoundedCornerShape(8.dp), + border = BorderStroke(1.dp, colors.ruleStrong), + colors = ButtonDefaults.outlinedButtonColors( + contentColor = colors.ink, + disabledContentColor = colors.inkFaint, + ), + ) { + Text(text = text, style = KadenceTheme.type.button) + } +} + +/** The pill used for timer presets. */ +@Composable +fun PresetChip( + text: String, + selected: Boolean, + onClick: () -> Unit, + modifier: Modifier = Modifier, +) { + val colors = KadenceTheme.colors + Surface( + modifier = modifier.heightIn(min = 32.dp), + shape = RoundedCornerShape(16.dp), + color = if (selected) colors.accent else Color.Transparent, + border = BorderStroke(1.dp, if (selected) colors.accent else colors.rule), + tonalElevation = 0.dp, + shadowElevation = 0.dp, + onClick = onClick, + ) { + Box( + Modifier.padding(horizontal = 14.dp, vertical = 7.dp), + contentAlignment = Alignment.Center, + ) { + Text( + text = text, + style = KadenceTheme.type.button, + color = if (selected) colors.onAccent else colors.ink, + ) + } + } +} diff --git a/android/app/src/main/kotlin/tech/kadence/android/ui/components/TabularFigures.kt b/android/app/src/main/kotlin/tech/kadence/android/ui/components/TabularFigures.kt new file mode 100644 index 0000000..0bf4194 --- /dev/null +++ b/android/app/src/main/kotlin/tech/kadence/android/ui/components/TabularFigures.kt @@ -0,0 +1,68 @@ +/** + * A serif number that does not twitch. + * + * Fraunces has no `tnum` feature and its digits are proportional — "1" is 1024 units + * where "0" is 1461 — so a clock redrawn every second would visibly jump as the digits + * change. This lays each character out in a box as wide as the widest digit in the + * font at that style, which is the only way to get tabular behaviour out of a font that + * does not provide it. + * + * Only worth using for numbers that change in place: the dial clock, the Live Update + * text, a stat figure that ticks. Static figures can use a plain `Text`. + */ +package tech.kadence.android.ui.components + +import androidx.compose.foundation.layout.Row +import androidx.compose.runtime.Composable +import androidx.compose.runtime.remember +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.semantics.clearAndSetSemantics +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.text.rememberTextMeasurer +import androidx.compose.ui.text.AnnotatedString +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.LayoutDirection +import androidx.compose.ui.platform.LocalDensity +import androidx.compose.material3.Text +import androidx.compose.foundation.layout.width +import androidx.compose.ui.text.style.TextAlign + +@Composable +fun TabularFigures( + text: String, + style: TextStyle, + color: Color, + modifier: Modifier = Modifier, +) { + val measurer = rememberTextMeasurer() + val density = LocalDensity.current + + // The widest digit at this exact style, measured once per style change. + val digitWidth: Dp = remember(style, density) { + val widest = (0..9).maxOf { d -> + measurer.measure(AnnotatedString(d.toString()), style = style).size.width + } + with(density) { widest.toDp() } + } + + Row( + modifier = modifier.clearAndSetSemantics { }, + verticalAlignment = Alignment.CenterVertically, + ) { + for (ch in text) { + if (ch.isDigit()) { + Text( + text = ch.toString(), + style = style.copy(textAlign = TextAlign.Center), + color = color, + modifier = Modifier.width(digitWidth), + ) + } else { + // Separators keep their natural width; only digits need a fixed box. + Text(text = ch.toString(), style = style, color = color) + } + } + } +} diff --git a/android/app/src/main/kotlin/tech/kadence/android/ui/components/TimerDial.kt b/android/app/src/main/kotlin/tech/kadence/android/ui/components/TimerDial.kt new file mode 100644 index 0000000..92a58cf --- /dev/null +++ b/android/app/src/main/kotlin/tech/kadence/android/ui/components/TimerDial.kt @@ -0,0 +1,166 @@ +/** + * The dial. + * + * Same geometry as `frontend/src/components/TimerDial.tsx` and + * `desktop/.../qml/components/TimerDial.qml`, with the tick arithmetic coming from + * `:core` (`dialTickCount` / `dialSpentTicks`) so the dial, the Glyph ring and the + * tests can never disagree about what one tick is worth. + * + * `remaining` is passed as a lambda on purpose: the engine emits a value every second, + * and reading it inside the draw scope keeps the 1 Hz tick in the draw phase instead of + * recomposing the whole dial sixty times a minute. + */ +package tech.kadence.android.ui.components + +import androidx.compose.animation.core.LinearEasing +import androidx.compose.animation.core.animateFloatAsState +import androidx.compose.animation.core.tween +import androidx.compose.foundation.Canvas +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.aspectRatio +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.geometry.Size +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.StrokeCap +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.platform.LocalDensity +import androidx.compose.ui.semantics.contentDescription +import androidx.compose.ui.semantics.semantics +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import tech.kadence.android.ui.theme.KadenceTheme +import tech.kadence.core.clock +import tech.kadence.core.dialSpentTicks +import tech.kadence.core.dialTickCount +import tech.kadence.core.progressOf +import kotlin.math.PI +import kotlin.math.cos +import kotlin.math.sin + +@Composable +fun TimerDial( + label: String, + remaining: () -> Int, + plannedSeconds: Int, + accent: Color, + modifier: Modifier = Modifier, + sublabel: String? = null, + paused: Boolean = false, + idle: Boolean = false, +) { + val colors = KadenceTheme.colors + val remainingNow = remaining() + val elapsed = progressOf(remainingNow, plannedSeconds) + + // Glide the arc over the second rather than stepping it, matching the web app's + // `transition: stroke-dashoffset 1s linear`. + val animatedElapsed by animateFloatAsState( + targetValue = elapsed, + animationSpec = tween(durationMillis = 1000, easing = LinearEasing), + label = "dialElapsed", + ) + + val clockAlpha by animateFloatAsState( + targetValue = if (paused) 0.55f else 1f, + animationSpec = tween(durationMillis = 180), + label = "clockAlpha", + ) + + Box( + modifier = modifier + .aspectRatio(1f) + .semantics { + contentDescription = "$label: ${clock(remainingNow)} remaining" + }, + contentAlignment = Alignment.Center, + ) { + val density = LocalDensity.current + Canvas(Modifier.fillMaxWidth().aspectRatio(1f)) { + val side = minOf(size.width, size.height) + // Keep the web app's 26:300 inset ratio so the dial scales rather than + // assuming a 300px box. + val inset = side * (26f / 300f) + val radius = side / 2f - inset + val centre = Offset(size.width / 2f, size.height / 2f) + + val count = dialTickCount(plannedSeconds) + val spent = dialSpentTicks(plannedSeconds, remainingNow) + + // The base ring. + drawCircle( + color = colors.rule, + radius = radius, + center = centre, + style = Stroke(width = with(density) { 1.5.dp.toPx() }), + ) + + // One tick per minute, every fifth one major, spent ticks tinted. + val tickOuter = radius - side * (7f / 300f) + for (i in 0 until count) { + val major = i % 5 == 0 + val lengthPx = side * (if (major) 9f else 5f) / 300f + val angle = i.toFloat() / count * 2f * PI.toFloat() - PI.toFloat() / 2f + val cosA = cos(angle) + val sinA = sin(angle) + val inner = tickOuter - lengthPx + val isSpent = i < spent && !idle + drawLine( + color = if (isSpent) accent else colors.rule, + start = Offset(centre.x + tickOuter * cosA, centre.y + tickOuter * sinA), + end = Offset(centre.x + inner * cosA, centre.y + inner * sinA), + strokeWidth = with(density) { (if (major) 1.4.dp else 1.dp).toPx() }, + cap = StrokeCap.Round, + alpha = if (idle) 0.5f else 1f, + ) + } + + // The remaining arc, draining clockwise from twelve. + if (!idle) { + val stroke = with(density) { 2.5.dp.toPx() } + drawArc( + color = accent, + startAngle = -90f, + sweepAngle = (1f - animatedElapsed) * 360f, + useCenter = false, + topLeft = Offset(centre.x - radius, centre.y - radius), + size = Size(radius * 2, radius * 2), + style = Stroke(width = stroke, cap = StrokeCap.Round), + alpha = if (paused) 0.4f else 1f, + ) + } + } + + Column( + horizontalAlignment = Alignment.CenterHorizontally, + modifier = Modifier.fillMaxWidth(0.7f), + ) { + Eyebrow(label, color = if (idle) colors.inkMuted else accent) + // Fraunces has no tabular figures, so the clock gets fixed-advance boxes. + TabularFigures( + text = clock(remainingNow), + style = KadenceTheme.type.clock, + color = colors.ink.copy(alpha = clockAlpha), + modifier = Modifier.padding(top = 6.dp), + ) + if (sublabel != null) { + Text( + text = sublabel, + style = KadenceTheme.type.caption, + color = colors.inkMuted, + textAlign = TextAlign.Center, + maxLines = 2, + overflow = TextOverflow.Ellipsis, + ) + } + } + } +} diff --git a/android/app/src/main/kotlin/tech/kadence/android/ui/theme/KadenceTheme.kt b/android/app/src/main/kotlin/tech/kadence/android/ui/theme/KadenceTheme.kt new file mode 100644 index 0000000..98ab4bc --- /dev/null +++ b/android/app/src/main/kotlin/tech/kadence/android/ui/theme/KadenceTheme.kt @@ -0,0 +1,179 @@ +/** + * The theme. + * + * Colour values are not defined here — they live in `:core` as ARGB longs, checked + * against `frontend/src/tokens.ts` by `TokenParityTest`. This file only wraps them in + * Compose types and decides the accent. + * + * The palette is semantic (paper / ink / rule / ember), not Material roles, so it rides + * on its own CompositionLocals. A minimal `ColorScheme` is derived from it purely so + * that `Switch`, `TextField` and the rest of M3 behave like Android components instead + * of being restyled from scratch. + */ +package tech.kadence.android.ui.theme + +import android.os.Build +import androidx.compose.foundation.isSystemInDarkTheme +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Shapes +import androidx.compose.material3.darkColorScheme +import androidx.compose.material3.dynamicDarkColorScheme +import androidx.compose.material3.dynamicLightColorScheme +import androidx.compose.material3.lightColorScheme +import androidx.compose.runtime.Composable +import androidx.compose.runtime.Immutable +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.runtime.staticCompositionLocalOf +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.toArgb +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.unit.dp +import tech.kadence.core.KadenceTokens +import tech.kadence.core.VizTokens +import tech.kadence.core.accentArgb +import tech.kadence.core.kadenceTokens +import tech.kadence.core.onAccentArgb +import tech.kadence.core.vizTokens + +/** An `0xAARRGGBB` long from `:core` as a Compose colour. */ +private fun Long.toColor(): Color = Color(this.toInt()) + +/** The semantic palette, as Compose colours. */ +@Immutable +data class KadenceColors( + val paper: Color, + val surface: Color, + val surfaceSunken: Color, + val ink: Color, + val inkMuted: Color, + val inkFaint: Color, + val rule: Color, + val ruleStrong: Color, + val accent: Color, + val onAccent: Color, + val accentSoft: Color, + val pine: Color, + val amber: Color, + val clay: Color, +) + +/** The chart palette. Separate on purpose — see `VizTokens` in `:core`. */ +@Immutable +data class KadenceViz( + val work: Color, + val shortBreak: Color, + val longBreak: Color, + val sequential: List, + val grid: Color, + val axis: Color, + val empty: Color, +) + +private fun colorsFrom(tokens: KadenceTokens, accent: Long, accentSoft: Long): KadenceColors = + KadenceColors( + paper = tokens.paper.toColor(), + surface = tokens.surface.toColor(), + surfaceSunken = tokens.surfaceSunken.toColor(), + ink = tokens.ink.toColor(), + inkMuted = tokens.inkMuted.toColor(), + inkFaint = tokens.inkFaint.toColor(), + rule = tokens.rule.toColor(), + ruleStrong = tokens.ruleStrong.toColor(), + accent = accent.toColor(), + onAccent = onAccentArgb(accent).toColor(), + accentSoft = accentSoft.toColor(), + pine = tokens.pine.toColor(), + amber = tokens.amber.toColor(), + clay = tokens.clay.toColor(), + ) + +private fun vizFrom(tokens: VizTokens): KadenceViz = KadenceViz( + work = tokens.work.toColor(), + shortBreak = tokens.shortBreak.toColor(), + longBreak = tokens.longBreak.toColor(), + sequential = tokens.sequential.map { it.toColor() }, + grid = tokens.grid.toColor(), + axis = tokens.axis.toColor(), + empty = tokens.empty.toColor(), +) + +val LocalKadenceColors = staticCompositionLocalOf { + colorsFrom(kadenceTokens(false), kadenceTokens(false).ember, kadenceTokens(false).emberSoft) +} +val LocalKadenceViz = staticCompositionLocalOf { vizFrom(vizTokens(false)) } +val LocalKadenceTypography = staticCompositionLocalOf { kadenceTypography() } + +/** Reads as `KadenceTheme.colors.ink` at a call site. */ +object KadenceTheme { + val colors: KadenceColors + @Composable get() = LocalKadenceColors.current + val viz: KadenceViz + @Composable get() = LocalKadenceViz.current + val type: KadenceTypography + @Composable get() = LocalKadenceTypography.current +} + +/** + * @param dynamicAccent take the accent from the system's wallpaper-derived palette. + * The canvas stays Kadence's either way; only the single accent changes. See + * `accentArgb` / `onAccentArgb` in `:core` for the policy and its contrast guard. + */ +@Composable +fun KadenceTheme( + dark: Boolean = isSystemInDarkTheme(), + dynamicAccent: Boolean = true, + content: @Composable () -> Unit, +) { + val context = LocalContext.current + val tokens = kadenceTokens(dark) + + val systemAccent: Long? = if (dynamicAccent && Build.VERSION.SDK_INT >= 31) { + val scheme = if (dark) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context) + scheme.primary.toArgb().toLong() and 0xFFFFFFFFL + } else { + null + } + + val accent = accentArgb(systemAccent, dark) + // The soft wash keeps the accent's hue; derive it rather than reusing ember's. + val accentSoft = (accent and 0x00FFFFFFL) or (if (dark) 0x24000000L else 0x1A000000L) + + val colors = colorsFrom(tokens, accent, accentSoft) + val viz = vizFrom(vizTokens(dark)) + + // M3 exists only to make stock components behave; nothing reads these roles for + // layout, and tonal elevation is never used. + val base = if (dark) darkColorScheme() else lightColorScheme() + val scheme = base.copy( + primary = colors.accent, + onPrimary = colors.onAccent, + secondary = colors.pine, + tertiary = colors.amber, + error = colors.clay, + background = colors.paper, + onBackground = colors.ink, + surface = colors.surface, + onSurface = colors.ink, + surfaceVariant = colors.surfaceSunken, + onSurfaceVariant = colors.inkMuted, + outline = colors.ruleStrong, + outlineVariant = colors.rule, + ) + + CompositionLocalProvider( + LocalKadenceColors provides colors, + LocalKadenceViz provides viz, + LocalKadenceTypography provides kadenceTypography(), + ) { + MaterialTheme( + colorScheme = scheme, + shapes = Shapes( + extraSmall = androidx.compose.foundation.shape.RoundedCornerShape(6.dp), + small = androidx.compose.foundation.shape.RoundedCornerShape(8.dp), + medium = androidx.compose.foundation.shape.RoundedCornerShape(12.dp), + large = androidx.compose.foundation.shape.RoundedCornerShape(14.dp), + ), + content = content, + ) + } +} diff --git a/android/app/src/main/kotlin/tech/kadence/android/ui/theme/KadenceType.kt b/android/app/src/main/kotlin/tech/kadence/android/ui/theme/KadenceType.kt new file mode 100644 index 0000000..fae0954 --- /dev/null +++ b/android/app/src/main/kotlin/tech/kadence/android/ui/theme/KadenceType.kt @@ -0,0 +1,153 @@ +/** + * Type. + * + * Fraunces for figures and titles, Inter for everything else — the same pairing as the + * web app and the desktop app, bundled as variable fonts (both SIL OFL; the licences + * ship in `res/raw`). + * + * **The tabular-figures problem.** The web app sets `font-variant-numeric: tabular-nums` + * globally, but Fraunces has no `tnum` feature *and* its digits are proportional — a + * "1" is 1024 units against a "0" at 1461, a 30% difference. So that CSS does nothing + * for the serif clock, and a 1 Hz countdown in Fraunces visibly jiggles. Inter does ship + * `tnum`, so the sans numbers are fixed with a font feature; the serif ones are fixed by + * [tech.kadence.android.ui.components.TabularFigures], which lays every glyph in a box + * the width of the widest digit. + */ +package tech.kadence.android.ui.theme + +import androidx.compose.runtime.Immutable +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.text.font.Font +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontVariation +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.em +import androidx.compose.ui.unit.sp +import tech.kadence.android.R + +private fun fraunces(weight: Int, opsz: Float) = Font( + resId = R.font.fraunces, + weight = FontWeight(weight), + variationSettings = FontVariation.Settings( + FontVariation.weight(weight), + FontVariation.opticalSizing(opsz.sp), + ), +) + +private fun inter(weight: Int) = Font( + resId = R.font.inter, + weight = FontWeight(weight), + variationSettings = FontVariation.Settings(FontVariation.weight(weight)), +) + +/** Display serif. Optical sizing is set per weight, as the web app's `opsz` axis does. */ +val Fraunces = FontFamily( + fraunces(400, 72f), + fraunces(500, 72f), + fraunces(600, 72f), +) + +val Inter = FontFamily( + inter(400), + inter(500), + inter(600), +) + +/** Inter ships `tnum`; this is what keeps the sans numbers from twitching. */ +private const val TABULAR = "tnum" + +@Immutable +data class KadenceTypography( + /** Small-caps-ish eyebrow above a title. Uppercase at the call site, not here. */ + val eyebrow: TextStyle, + val pageTitle: TextStyle, + val statSmall: TextStyle, + val statMedium: TextStyle, + val statLarge: TextStyle, + /** The dial clock; its size is supplied by the dial (~0.21 x its width). */ + val clock: TextStyle, + val body: TextStyle, + val bodySmall: TextStyle, + val caption: TextStyle, + val button: TextStyle, + val mono: TextStyle, +) + +fun kadenceTypography(): KadenceTypography = KadenceTypography( + eyebrow = TextStyle( + fontFamily = Inter, + fontWeight = FontWeight.SemiBold, + fontSize = 10.5.sp, + letterSpacing = 0.12.em, + lineHeight = 16.sp, + ), + pageTitle = TextStyle( + fontFamily = Fraunces, + fontWeight = FontWeight.Medium, + fontSize = 27.sp, + letterSpacing = (-0.02).em, + lineHeight = 32.sp, + ), + statSmall = TextStyle( + fontFamily = Fraunces, + fontWeight = FontWeight.Medium, + fontSize = 24.sp, + letterSpacing = (-0.02).em, + lineHeight = 27.sp, + ), + statMedium = TextStyle( + fontFamily = Fraunces, + fontWeight = FontWeight.Medium, + fontSize = 30.sp, + letterSpacing = (-0.02).em, + lineHeight = 33.sp, + ), + statLarge = TextStyle( + fontFamily = Fraunces, + fontWeight = FontWeight.Medium, + fontSize = 38.sp, + letterSpacing = (-0.02).em, + lineHeight = 42.sp, + ), + clock = TextStyle( + fontFamily = Fraunces, + fontWeight = FontWeight.Normal, + fontSize = 56.sp, + letterSpacing = (-0.03).em, + lineHeight = 60.sp, + textAlign = TextAlign.Center, + ), + body = TextStyle( + fontFamily = Inter, + fontWeight = FontWeight.Normal, + fontSize = 15.sp, + lineHeight = 23.sp, + fontFeatureSettings = TABULAR, + ), + bodySmall = TextStyle( + fontFamily = Inter, + fontWeight = FontWeight.Normal, + fontSize = 13.5.sp, + lineHeight = 21.sp, + fontFeatureSettings = TABULAR, + ), + caption = TextStyle( + fontFamily = Inter, + fontWeight = FontWeight.Normal, + fontSize = 12.sp, + lineHeight = 18.sp, + fontFeatureSettings = TABULAR, + ), + button = TextStyle( + fontFamily = Inter, + fontWeight = FontWeight.Medium, + fontSize = 14.sp, + letterSpacing = 0.em, + ), + mono = TextStyle( + fontFamily = FontFamily.Monospace, + fontSize = 13.sp, + lineHeight = 20.sp, + ), +) diff --git a/android/app/src/main/res/drawable/ic_launcher_foreground.xml b/android/app/src/main/res/drawable/ic_launcher_foreground.xml new file mode 100644 index 0000000..a4db96a --- /dev/null +++ b/android/app/src/main/res/drawable/ic_launcher_foreground.xml @@ -0,0 +1,29 @@ + + + + + + + + + + + + diff --git a/android/app/src/main/res/font/fraunces.ttf b/android/app/src/main/res/font/fraunces.ttf new file mode 100644 index 0000000000000000000000000000000000000000..8210f9488d3c732359a9292dd09aca3f2bae830e GIT binary patch literal 360440 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

_b5`Ec9fq?7KrG-p>D_) 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

Ek&TdifBe7Pd^mmY)(962bN_SP%pQaf-0_4xU_4 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

us)Vd6A*)Kr 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ⅅz?iuH&b8I;Pc4b>A5fi= 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 + + + + + diff --git a/android/app/src/main/res/raw/ofl_fraunces.txt b/android/app/src/main/res/raw/ofl_fraunces.txt new file mode 100644 index 0000000..22fa7ce --- /dev/null +++ b/android/app/src/main/res/raw/ofl_fraunces.txt @@ -0,0 +1,93 @@ +Copyright 2018 The Fraunces Project Authors (https://github.com/undercasetype/Fraunces) + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/android/app/src/main/res/raw/ofl_inter.txt b/android/app/src/main/res/raw/ofl_inter.txt new file mode 100644 index 0000000..21f6aff --- /dev/null +++ b/android/app/src/main/res/raw/ofl_inter.txt @@ -0,0 +1,93 @@ +Copyright 2020 The Inter Project Authors (https://github.com/rsms/inter) + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +https://scripts.sil.org/OFL + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/android/app/src/main/res/values-night/colors.xml b/android/app/src/main/res/values-night/colors.xml new file mode 100644 index 0000000..4fbc4ef --- /dev/null +++ b/android/app/src/main/res/values-night/colors.xml @@ -0,0 +1,5 @@ + + + + #121110 + diff --git a/android/app/src/main/res/values/colors.xml b/android/app/src/main/res/values/colors.xml new file mode 100644 index 0000000..42b11b6 --- /dev/null +++ b/android/app/src/main/res/values/colors.xml @@ -0,0 +1,7 @@ + + + + #FAF7F2 + + #FAF7F2 + diff --git a/android/app/src/main/res/values/strings.xml b/android/app/src/main/res/values/strings.xml new file mode 100644 index 0000000..8e87789 --- /dev/null +++ b/android/app/src/main/res/values/strings.xml @@ -0,0 +1,4 @@ + + + Kadence + diff --git a/android/app/src/main/res/values/themes.xml b/android/app/src/main/res/values/themes.xml new file mode 100644 index 0000000..a49d7b2 --- /dev/null +++ b/android/app/src/main/res/values/themes.xml @@ -0,0 +1,13 @@ + + + + + diff --git a/android/app/src/test/kotlin/tech/kadence/android/DtoToleranceTest.kt b/android/app/src/test/kotlin/tech/kadence/android/DtoToleranceTest.kt new file mode 100644 index 0000000..a4a6c61 --- /dev/null +++ b/android/app/src/test/kotlin/tech/kadence/android/DtoToleranceTest.kt @@ -0,0 +1,256 @@ +package tech.kadence.android + +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.buildJsonObject +import kotlinx.serialization.json.jsonObject +import kotlinx.serialization.json.put +import org.junit.Test +import tech.kadence.android.data.dto.AuthMeDto +import tech.kadence.android.data.dto.BlockEventsDto +import tech.kadence.android.data.dto.BlockerPolicyDto +import tech.kadence.android.data.dto.DailyReportEnvelopeDto +import tech.kadence.android.data.dto.StatsSummaryDto +import tech.kadence.android.data.dto.TaskListDto +import tech.kadence.android.data.dto.TimerStateDto +import tech.kadence.android.data.net.KadenceJson +import kotlin.test.assertEquals +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertTrue + +/** + * The contract test, against committed mock data. + * + * The backend declares no response models, so there is nothing to generate DTOs from + * and nothing to validate them against — the only defence is fixtures plus deliberate + * corruption. Each DTO is decoded from a realistic fixture, then from the same fixture + * with every optional key stripped, with unknown keys added, and with nulls where a + * value is declared. None of that may throw, because the alternative is a phone that + * crashes when the server grows a field. + * + * These tests never touch a network or a running backend. + */ +class DtoToleranceTest { + + private fun fixture(name: String): String = + checkNotNull(javaClass.classLoader.getResourceAsStream("fixtures/$name")) { + "missing fixture: $name" + }.bufferedReader().readText() + + private inline fun decode(name: String): T = + KadenceJson.decodeFromString(fixture(name)) + + /** The same payload with three keys the client has never heard of. */ + private fun withUnknownKeys(raw: String): String { + val obj = KadenceJson.parseToJsonElement(raw).jsonObject + val grown = buildJsonObject { + obj.forEach { (k, v) -> put(k, v) } + put("some_new_field", JsonPrimitive("surprise")) + put("another_one", JsonPrimitive(42)) + put("nested_novelty", buildJsonObject { put("x", JsonPrimitive(1)) }) + } + return grown.toString() + } + + /** Every top-level value replaced with null, as a sloppy serialiser might. */ + private fun allNulls(raw: String): String { + val obj = KadenceJson.parseToJsonElement(raw).jsonObject + val nulled = buildJsonObject { + obj.keys.forEach { k -> put(k, kotlinx.serialization.json.JsonNull) } + } + return nulled.toString() + } + + // --- the happy path, asserting the values that matter --------------------- + + @Test + fun `a running interval decodes`() { + val state = decode("timer_state_running.json") + val current = assertNotNull(state.current) + assertEquals(412L, current.id) + assertEquals("work", current.kind) + assertEquals(1104, current.remainingSeconds) + assertEquals(1500, current.plannedSeconds) + assertEquals(1, current.interruptions) + assertEquals("PLAT-184", current.task?.externalId) + assertEquals(6, state.completedToday) + assertEquals("short_break", state.nextKind) + assertTrue(state.timerEnabled) + } + + @Test + fun `durations are minutes, not seconds`() { + // The trap: `pomodoro.state()` sends minutes. Treating them as seconds would + // make every interval 25 seconds long. + val state = decode("timer_state_running.json") + assertEquals(25, state.durations["work"]) + assertEquals(5, state.durations["short_break"]) + assertEquals(15, state.durations["long_break"]) + } + + @Test + fun `an idle state has no current interval`() { + val state = decode("timer_state_idle.json") + assertNull(state.current) + assertEquals("work", state.nextKind) + assertEquals(45, state.durations["work"], "the Classic preset") + } + + @Test + fun `a complete reply carries finished, auto_started and the celebration`() { + val state = decode("timer_complete_reply.json") + assertEquals(412L, state.finished?.id) + assertEquals("completed", state.finished?.status) + assertEquals(413L, state.autoStarted?.id) + assertEquals("short_break", state.autoStarted?.kind) + assertNotNull(state.celebration) + assertEquals(413L, state.current?.id, "current is the follow-on interval") + } + + @Test + fun `an inactive policy hides its lists but keeps all_domains`() { + // The single most important API detail for the focus guard: `domains` and `apps` + // are empty whenever `active` is false, so a client that reads them would think + // the block list was empty and enforce nothing. + val policy = decode("blocker_policy_inactive.json") + assertTrue(!policy.active) + assertTrue(policy.domains.isEmpty()) + assertTrue(policy.apps.isEmpty()) + assertEquals(3, policy.allDomains.size) + assertEquals(2, policy.allApps.size) + assertNull(policy.sessionId) + } + + @Test + fun `an active policy populates both`() { + val policy = decode("blocker_policy_active.json") + assertTrue(policy.active) + assertEquals(policy.allDomains, policy.domains) + assertEquals(listOf("*gram*"), policy.unexpandable) + assertEquals(412L, policy.sessionId) + } + + @Test + fun `tasks decode with their buckets and sources`() { + val list = decode("tasks.json") + assertEquals(3, list.tasks.size) + assertEquals("overdue", list.tasks[0].bucket) + assertEquals(3, list.tasks[0].daysOverdue) + assertTrue(list.tasks[0].pinned) + assertEquals("local", list.tasks[2].source) + assertEquals(1, list.counts["overdue"]) + } + + @Test + fun `the daily report decodes whole`() { + val envelope = decode("daily_report.json") + val report = envelope.report + assertEquals(6, report.metrics.pomodoros) + assertEquals(155, report.metrics.focusMinutes) + assertEquals(80, report.metrics.longestStretchMinutes) + assertEquals(2, report.achievements.size) + assertEquals("deep_work", report.achievements[0].code) + assertEquals(2, report.funFacts.size) + assertEquals(72.4, report.score) + assertEquals(4, report.streak.current) + assertEquals(16, report.metrics.blockedAttempts) + assertNull(envelope.sentAt) + } + + @Test + fun `stats summary decodes its ranges`() { + val stats = decode("stats_summary.json") + assertEquals(3, stats.range.size) + assertEquals(2, stats.heatmap.size) + assertEquals(162.5, stats.lifetime.focusHours) + assertEquals(5.4, stats.average7d.pomodoros) + } + + @Test + fun `block events decode both kinds`() { + val events = decode("block_events.json") + assertEquals(16, events.total) + assertEquals("domain", events.events[0].kind) + assertEquals("killed", events.events[1].action) + assertEquals("youtube.com", events.byTarget[0].target) + } + + @Test + fun `auth me decodes`() { + val me = decode("auth_me.json") + assertTrue(me.authenticated) + assertTrue(me.loginRequired) + assertEquals("timka", me.username) + } + + // --- the corruption passes ------------------------------------------------ + + @Test + fun `an empty object decodes into every DTO`() { + // A stripped-down or errored response must still produce usable defaults. + assertNull(KadenceJson.decodeFromString("{}").current) + assertEquals(8, KadenceJson.decodeFromString("{}").goal) + assertTrue(KadenceJson.decodeFromString("{}").tasks.isEmpty()) + assertTrue(!KadenceJson.decodeFromString("{}").active) + assertEquals(0.0, KadenceJson.decodeFromString("{}").report.score) + assertEquals(0, KadenceJson.decodeFromString("{}").range.size) + assertEquals(0, KadenceJson.decodeFromString("{}").total) + assertTrue(!KadenceJson.decodeFromString("{}").authenticated) + } + + @Test + fun `unknown keys are ignored everywhere`() { + val grown = withUnknownKeys(fixture("timer_state_running.json")) + assertEquals(412L, KadenceJson.decodeFromString(grown).current?.id) + + val policy = withUnknownKeys(fixture("blocker_policy_active.json")) + assertTrue(KadenceJson.decodeFromString(policy).active) + + val tasks = withUnknownKeys(fixture("tasks.json")) + assertEquals(3, KadenceJson.decodeFromString(tasks).tasks.size) + } + + @Test + fun `nulls where a value is declared fall back to defaults`() { + // `coerceInputValues` is what saves us here; without it this throws. + val nulled = allNulls(fixture("timer_state_running.json")) + val state = KadenceJson.decodeFromString(nulled) + assertNull(state.current) + assertEquals(8, state.goal, "the default survives a null") + assertEquals("work", state.nextKind) + assertTrue(state.timerEnabled) + + val policy = KadenceJson.decodeFromString( + allNulls(fixture("blocker_policy_active.json")), + ) + assertTrue(!policy.active) + assertTrue(policy.allDomains.isEmpty()) + } + + @Test + fun `a nested object arriving as the wrong shape does not take the page down`() { + // A task row missing almost everything still decodes, because every field has + // a default — the list renders with blanks instead of crashing. + val json = """{"date":"2026-10-19","tasks":[{"id":9}],"counts":{},"sources":[]}""" + val list = KadenceJson.decodeFromString(json) + assertEquals(1, list.tasks.size) + assertEquals(9L, list.tasks[0].id) + assertEquals("", list.tasks[0].title) + assertEquals("someday", list.tasks[0].bucket) + } + + @Test + fun `every fixture round-trips through the parser`() { + // Cheap guard that no fixture has drifted into invalid JSON. + val names = listOf( + "timer_state_running.json", "timer_state_idle.json", "timer_complete_reply.json", + "blocker_policy_active.json", "blocker_policy_inactive.json", "tasks.json", + "daily_report.json", "stats_summary.json", "block_events.json", "auth_me.json", + ) + for (name in names) { + val parsed = KadenceJson.parseToJsonElement(fixture(name)) + assertTrue(parsed is JsonObject, "$name should be a JSON object") + } + } +} diff --git a/android/app/src/test/kotlin/tech/kadence/android/KadenceApiTest.kt b/android/app/src/test/kotlin/tech/kadence/android/KadenceApiTest.kt new file mode 100644 index 0000000..ce82c17 --- /dev/null +++ b/android/app/src/test/kotlin/tech/kadence/android/KadenceApiTest.kt @@ -0,0 +1,225 @@ +package tech.kadence.android + +import kotlinx.coroutines.runBlocking +import mockwebserver3.MockResponse +import mockwebserver3.MockWebServer +import org.junit.After +import org.junit.Before +import org.junit.Test +import tech.kadence.android.data.dto.TimerStateDto +import tech.kadence.android.data.net.ApiResult +import tech.kadence.android.data.net.AuthConfig +import tech.kadence.android.data.net.KadenceApi +import kotlin.test.assertEquals +import kotlin.test.assertIs +import kotlin.test.assertNull +import kotlin.test.assertTrue + +/** + * The HTTP layer, against a mock server. + * + * Nothing here needs the real backend running — the backend lives only on the dev + * machine, so a suite that required it would be unrunnable anywhere else. MockWebServer + * serves the committed fixtures instead. + */ +class KadenceApiTest { + + private lateinit var server: MockWebServer + private var token: String? = "s3cret-token" + + private val api: KadenceApi by lazy { + KadenceApi(config = { + object : AuthConfig { + override val baseUrl = server.url("/").toString().trimEnd('/') + override val apiToken = token + } + }) + } + + private fun fixture(name: String): String = + checkNotNull(javaClass.classLoader.getResourceAsStream("fixtures/$name")) + .bufferedReader().readText() + + private fun json(code: Int, body: String) = + MockResponse.Builder() + .code(code) + .addHeader("Content-Type", "application/json") + .body(body) + .build() + + @Before + fun setUp() { + server = MockWebServer() + server.start() + } + + @After + fun tearDown() { + server.close() + } + + @Test + fun `the api token goes out as X-API-Token, like the desktop client`() = runBlocking { + server.enqueue(json(200, fixture("timer_state_running.json"))) + + val result = api.get("/api/timer/state") + assertIs>(result) + assertEquals(412L, result.value.current?.id) + + val recorded = server.takeRequest() + assertEquals("s3cret-token", recorded.headers["X-API-Token"]) + assertEquals("application/json", recorded.headers["Accept"]) + assertEquals("/api/timer/state", recorded.target) + } + + @Test + fun `no token means no header, for a backend that wants none`() = runBlocking { + token = null + server.enqueue(json(200, fixture("timer_state_idle.json"))) + + api.get("/api/timer/state") + + assertNull(server.takeRequest().headers["X-API-Token"]) + token = "s3cret-token" + } + + @Test + fun `the session cookie is kept and sent back`() = runBlocking { + server.enqueue( + MockResponse.Builder() + .code(200) + .addHeader("Content-Type", "application/json") + .addHeader("Set-Cookie", "kadence_session=abc123; Path=/; HttpOnly; Max-Age=2592000") + .body("""{"ok":true}""") + .build(), + ) + server.enqueue(json(200, fixture("timer_state_running.json"))) + + api.post>("/api/auth/login", """{"username":"timka","password":"x"}""") + server.takeRequest() + + api.get("/api/timer/state") + val second = server.takeRequest() + + assertTrue( + second.headers["Cookie"]?.contains("kadence_session=abc123") == true, + "the session cookie should ride along: ${second.headers["Cookie"]}", + ) + assertEquals("abc123", api.cookieJar.named("kadence_session")?.value) + } + + @Test + fun `a 401 on a normal path notifies so the UI can drop to login`() = runBlocking { + var notified = 0 + api.unauthorized.subscribe { notified++ } + + server.enqueue(json(401, """{"detail":"not authenticated"}""")) + val result = api.get("/api/timer/state") + + assertIs(result) + assertEquals("not authenticated", result.detail) + assertEquals(1, notified) + } + + @Test + fun `a 401 on the login path does not, or signing in would loop`() = runBlocking { + var notified = 0 + api.unauthorized.subscribe { notified++ } + + server.enqueue(json(401, """{"detail":"wrong password"}""")) + val result = api.post>("/api/auth/login", """{"username":"a"}""") + + assertIs(result) + assertEquals(401, result.status) + assertEquals("wrong password", result.detail) + assertEquals(0, notified, "a failed sign-in must not trigger the re-auth bus") + } + + @Test + fun `a plain detail string is surfaced as the message`() = runBlocking { + // What `TimerError` produces, e.g. refusing to pause when pausing is off. + server.enqueue(json(400, """{"detail":"Pausing is switched off in your settings."}""")) + + val result = api.post("/api/timer/pause") + assertIs(result) + assertEquals(400, result.status) + assertEquals("Pausing is switched off in your settings.", result.detail) + } + + @Test + fun `a 422 validation body renders as field colon message`() = runBlocking { + server.enqueue( + json( + 422, + """{"detail":[ + {"loc":["body","minutes"],"msg":"Input should be less than or equal to 240"}, + {"loc":["body","kind"],"msg":"Input should be 'work', 'short_break' or 'long_break'"} + ]}""", + ), + ) + + val result = api.post("/api/timer/start", """{"minutes":9999}""") + assertIs(result) + assertEquals(422, result.status) + assertEquals( + "minutes: Input should be less than or equal to 240; " + + "kind: Input should be 'work', 'short_break' or 'long_break'", + result.detail, + ) + } + + @Test + fun `a non-JSON error body falls back to the status line`() = runBlocking { + server.enqueue( + MockResponse.Builder().code(502).body("Bad Gateway").build(), + ) + + val result = api.get("/api/timer/state") + assertIs(result) + assertEquals(502, result.status) + assertTrue(result.detail.startsWith("502"), "got: ${result.detail}") + } + + @Test + fun `an unreachable backend is a NetworkError, never a crash`() = runBlocking { + server.close() // nothing listening any more + + val result = api.get("/api/timer/state") + assertIs(result) + + // Restart so tearDown has something to close. + server = MockWebServer().also { it.start() } + } + + @Test + fun `a successful but unreadable body does not crash the caller`() = runBlocking { + server.enqueue(json(200, """{"current": "this should be an object"}""")) + + val result = api.get("/api/timer/state") + assertIs(result) + assertTrue(result.detail.startsWith("unreadable response"), "got: ${result.detail}") + } + + @Test + fun `a POST with no body still sends an empty object`() = runBlocking { + // FastAPI's request models default every field, but an absent body on a POST + // that declares one is a 422; the desktop client sends `{}` for the same reason. + server.enqueue(json(200, fixture("timer_state_running.json"))) + + api.post("/api/timer/resume") + val recorded = server.takeRequest() + + assertEquals("POST", recorded.method) + assertEquals("{}", recorded.body?.utf8()) + assertTrue(recorded.headers["Content-Type"]?.startsWith("application/json") == true) + } + + @Test + fun `trailing slashes in the configured URL do not produce a double slash`() = runBlocking { + server.enqueue(json(200, fixture("timer_state_idle.json"))) + + api.get("/api/timer/state") + + assertEquals("/api/timer/state", server.takeRequest().target) + } +} diff --git a/android/app/src/test/kotlin/tech/kadence/android/ThemeTest.kt b/android/app/src/test/kotlin/tech/kadence/android/ThemeTest.kt new file mode 100644 index 0000000..6232cde --- /dev/null +++ b/android/app/src/test/kotlin/tech/kadence/android/ThemeTest.kt @@ -0,0 +1,135 @@ +package tech.kadence.android + +import androidx.compose.foundation.layout.Row +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.test.getUnclippedBoundsInRoot +import androidx.compose.ui.test.junit4.createComposeRule +import androidx.compose.ui.test.onNodeWithTag +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.Modifier +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config +import tech.kadence.android.ui.components.TabularFigures +import tech.kadence.android.ui.theme.KadenceTheme +import tech.kadence.core.KADENCE_DARK +import tech.kadence.core.KADENCE_LIGHT +import kotlin.math.abs +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +/** + * The theme and the type, on the JVM. + * + * Robolectric means the Compose layer is checked here rather than on the phone: the + * palette actually reaching a composable, and — the one that matters — that the serif + * clock really is fixed-advance despite Fraunces having no `tnum`. + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34]) +class ThemeTest { + + @get:Rule + val compose = createComposeRule() + + private fun argb(color: Color): Long = color.value.toLong() ushr 32 and 0xFFFFFFFFL + + @Test + fun `the light palette reaching a composable is the core palette`() { + var paper: Color? = null + var ink: Color? = null + var rule: Color? = null + + compose.setContent { + KadenceTheme(dark = false, dynamicAccent = false) { + paper = KadenceTheme.colors.paper + ink = KadenceTheme.colors.ink + rule = KadenceTheme.colors.rule + } + } + + assertEquals(KADENCE_LIGHT.paper, argb(paper!!), "paper") + assertEquals(KADENCE_LIGHT.ink, argb(ink!!), "ink") + assertEquals(KADENCE_LIGHT.rule, argb(rule!!), "rule keeps its 12% alpha") + } + + @Test + fun `the dark palette is the dark one, not a tinted light`() { + var paper: Color? = null + compose.setContent { + KadenceTheme(dark = true, dynamicAccent = false) { + paper = KadenceTheme.colors.paper + } + } + assertEquals(KADENCE_DARK.paper, argb(paper!!)) + } + + @Test + fun `without dynamic colour the accent is the brand ember`() { + var accent: Color? = null + var onAccent: Color? = null + compose.setContent { + KadenceTheme(dark = false, dynamicAccent = false) { + accent = KadenceTheme.colors.accent + onAccent = KadenceTheme.colors.onAccent + } + } + assertEquals(KADENCE_LIGHT.ember, argb(accent!!)) + assertEquals(0xFFFFFFFFL, argb(onAccent!!), "white sits on ember") + } + + @Test + fun `the chart palette does not follow the accent`() { + var work: Color? = null + var accent: Color? = null + compose.setContent { + KadenceTheme(dark = false, dynamicAccent = true) { + work = KadenceTheme.viz.work + accent = KadenceTheme.colors.accent + } + } + assertEquals(0xFFEB6834L, argb(work!!), "work keeps its validated orange") + assertTrue(work != accent || argb(accent!!) == 0xFFEB6834L) + } + + @Test + fun `the serif clock is fixed-advance despite Fraunces having no tnum`() { + // The whole point of TabularFigures. "11:11" is the narrowest possible set of + // digits and "00:00" among the widest; with proportional figures these would + // differ by roughly 30% and the dial would visibly jiggle every second. + compose.setContent { + KadenceTheme(dark = false, dynamicAccent = false) { + Row { + TabularFigures( + text = "11:11", + style = KadenceTheme.type.clock, + color = KadenceTheme.colors.ink, + modifier = Modifier.testTag("ones"), + ) + TabularFigures( + text = "00:00", + style = KadenceTheme.type.clock, + color = KadenceTheme.colors.ink, + modifier = Modifier.testTag("zeros"), + ) + } + } + } + + val ones = compose.onNodeWithTag("ones").getUnclippedBoundsInRoot() + val zeros = compose.onNodeWithTag("zeros").getUnclippedBoundsInRoot() + val onesWidth = (ones.right - ones.left).value + val zerosWidth = (zeros.right - zeros.left).value + + // Guard against a stubbed text measurer: if both came back zero the comparison + // below would pass without proving anything. + assertTrue(onesWidth > 0f, "the figures did not actually measure") + assertTrue( + abs(onesWidth - zerosWidth) < 0.5f, + "11:11 measured $onesWidth dp and 00:00 measured $zerosWidth dp — " + + "the clock would jiggle every second", + ) + } +} diff --git a/android/app/src/test/resources/fixtures/auth_me.json b/android/app/src/test/resources/fixtures/auth_me.json new file mode 100644 index 0000000..2adb984 --- /dev/null +++ b/android/app/src/test/resources/fixtures/auth_me.json @@ -0,0 +1,8 @@ +{ + "authenticated": true, + "login_required": true, + "username": "timka", + "password_login_enabled": true, + "telegram_login_enabled": false, + "telegram_bot_username": "" +} diff --git a/android/app/src/test/resources/fixtures/block_events.json b/android/app/src/test/resources/fixtures/block_events.json new file mode 100644 index 0000000..cb3d0b7 --- /dev/null +++ b/android/app/src/test/resources/fixtures/block_events.json @@ -0,0 +1,9 @@ +{ + "date": "2026-10-19", + "total": 16, + "by_target": [{"target": "youtube.com", "count": 12}, {"target": "reddit.com", "count": 4}], + "events": [ + {"id": 90, "kind": "domain", "target": "youtube.com", "action": "blocked", "at": "2026-10-19T10:04:00+00:00", "details": "chrome"}, + {"id": 91, "kind": "app", "target": "*discord*", "action": "killed", "at": "2026-10-19T10:06:00+00:00", "details": "Discord (com.discord)"} + ] +} diff --git a/android/app/src/test/resources/fixtures/blocker_policy_active.json b/android/app/src/test/resources/fixtures/blocker_policy_active.json new file mode 100644 index 0000000..89f6a4f --- /dev/null +++ b/android/app/src/test/resources/fixtures/blocker_policy_active.json @@ -0,0 +1,17 @@ +{ + "active": true, + "reason": "a work interval is running", + "mode": "during_work", + "enabled": true, + "strict": false, + "redirect_ip": "127.0.0.1", + "domains": ["youtube.com", "www.youtube.com", "m.youtube.com", "reddit.com", "www.reddit.com", "m.reddit.com"], + "apps": ["steam*", "*discord*"], + "unexpandable": ["*gram*"], + "kill_apps": true, + "notify_on_block": true, + "poll_seconds": 5, + "session_id": 412, + "all_domains": ["youtube.com", "www.youtube.com", "m.youtube.com", "reddit.com", "www.reddit.com", "m.reddit.com"], + "all_apps": ["steam*", "*discord*"] +} diff --git a/android/app/src/test/resources/fixtures/blocker_policy_inactive.json b/android/app/src/test/resources/fixtures/blocker_policy_inactive.json new file mode 100644 index 0000000..d35db0a --- /dev/null +++ b/android/app/src/test/resources/fixtures/blocker_policy_inactive.json @@ -0,0 +1,17 @@ +{ + "active": false, + "reason": "no work interval is running", + "mode": "during_work", + "enabled": true, + "strict": false, + "redirect_ip": "127.0.0.1", + "domains": [], + "apps": [], + "unexpandable": ["*gram*"], + "kill_apps": true, + "notify_on_block": true, + "poll_seconds": 5, + "session_id": null, + "all_domains": ["youtube.com", "www.youtube.com", "m.youtube.com"], + "all_apps": ["steam*", "*discord*"] +} diff --git a/android/app/src/test/resources/fixtures/daily_report.json b/android/app/src/test/resources/fixtures/daily_report.json new file mode 100644 index 0000000..e3afe6e --- /dev/null +++ b/android/app/src/test/resources/fixtures/daily_report.json @@ -0,0 +1,41 @@ +{ + "report": { + "date": "2026-10-19", + "metrics": { + "date": "2026-10-19", "pomodoros": 6, "goal": 8, "goal_pct": 75.0, "goal_met": false, + "focus_minutes": 155, "break_minutes": 35, "wasted_minutes": 12, "abandoned": 1, + "breaks_taken": 4, "interruptions": 3, "completion_rate": 0.86, + "longest_stretch_minutes": 80, "first_start": "2026-10-19T09:12:00+00:00", + "last_end": "2026-10-19T18:40:00+00:00", + "by_hour": [{"hour": 9, "count": 1}, {"hour": 10, "count": 2}, {"hour": 14, "count": 3}], + "peak_hour": 10, + "tasks_completed": [ + {"id": 1, "title": "Fix the flaky importer", "source": "jira", "project": "Platform", "url": "https://example.atlassian.net/browse/PLAT-184"} + ], + "tasks_completed_count": 1, + "time_by_task": [{"title": "Fix the flaky importer", "minutes": 75}], + "blocked_attempts": 16, + "blocked_top": [{"target": "youtube.com", "count": 12}, {"target": "reddit.com", "count": 4}], + "sessions": [ + {"id": 412, "kind": "work", "status": "completed", "started_at": "2026-10-19T09:12:00+00:00", "minutes": 25, "task": "Fix the flaky importer", "interruptions": 1} + ] + }, + "streak": {"current": 4, "best": 11, "goal_streak": 2, "total_days": 63}, + "average_7d": {"pomodoros": 5.4, "focus_minutes": 142.3}, + "lifetime": {"pomodoros": 390, "focus_minutes": 9750, "focus_hours": 162.5, "tasks_completed": 88, "blocked_attempts": 512}, + "comparison": {"yesterday": 7, "previous_best": 11}, + "achievements": [ + {"code": "deep_work", "emoji": "🧘", "title": "Deep work", "detail": "80 minutes without breaking the chain."}, + {"code": "gatekeeper", "emoji": "🛡️", "title": "Gatekeeper", "detail": "The blocker turned you away 16 times. It won."} + ], + "fun_facts": [ + "155 minutes of focus — that is 7.0 sitcom episodes you did not watch.", + "Your peak hour was 10:00. Defend it." + ], + "verdict": "Target hit. Now protect the streak. 💪", + "open_tasks": {"overdue": 1, "today": 1, "someday": 1}, + "score": 72.4 + }, + "sent_at": null, + "telegram_preview": "🍅 Daily report — 2026-10-19" +} diff --git a/android/app/src/test/resources/fixtures/stats_summary.json b/android/app/src/test/resources/fixtures/stats_summary.json new file mode 100644 index 0000000..a86c8e2 --- /dev/null +++ b/android/app/src/test/resources/fixtures/stats_summary.json @@ -0,0 +1,20 @@ +{ + "today": { + "date": "2026-10-19", "pomodoros": 6, "goal": 8, "goal_pct": 75.0, "goal_met": false, + "focus_minutes": 155, "break_minutes": 35, "interruptions": 3, + "by_hour": [{"hour": 10, "count": 2}], "peak_hour": 10, + "blocked_attempts": 16, "sessions": [] + }, + "streak": {"current": 4, "best": 11, "goal_streak": 2, "total_days": 63}, + "lifetime": {"pomodoros": 390, "focus_minutes": 9750, "focus_hours": 162.5, "tasks_completed": 88, "blocked_attempts": 512}, + "average_7d": {"pomodoros": 5.4, "focus_minutes": 142.3}, + "range": [ + {"date": "2026-10-17", "pomodoros": 5, "focus_minutes": 125, "goal_met": false}, + {"date": "2026-10-18", "pomodoros": 7, "focus_minutes": 175, "goal_met": false}, + {"date": "2026-10-19", "pomodoros": 6, "focus_minutes": 155, "goal_met": false} + ], + "heatmap": [ + {"date": "2026-10-13", "pomodoros": 8, "focus_minutes": 200, "goal_met": true}, + {"date": "2026-10-14", "pomodoros": 0, "focus_minutes": 0, "goal_met": false} + ] +} diff --git a/android/app/src/test/resources/fixtures/tasks.json b/android/app/src/test/resources/fixtures/tasks.json new file mode 100644 index 0000000..11f95c2 --- /dev/null +++ b/android/app/src/test/resources/fixtures/tasks.json @@ -0,0 +1,32 @@ +{ + "date": "2026-10-19", + "tasks": [ + { + "id": 1, "source": "jira", "source_label": "Jira", "external_id": "PLAT-184", + "title": "Fix the flaky importer", "description": null, + "url": "https://example.atlassian.net/browse/PLAT-184", + "project": "Platform", "status": "In Progress", "priority": "High", + "due_date": "2026-10-16", "start_date": null, "labels": ["backend"], + "is_done": false, "pinned": true, "stale": false, + "estimated_pomodoros": 3, "days_overdue": 3, "bucket": "overdue" + }, + { + "id": 2, "source": "todoist", "source_label": "Todoist", "external_id": "7788", + "title": "Write the design doc", "description": null, "url": null, + "project": "Work", "status": null, "priority": "p2", + "due_date": "2026-10-19", "start_date": null, "labels": [], + "is_done": false, "pinned": false, "stale": false, + "estimated_pomodoros": null, "days_overdue": 0, "bucket": "today" + }, + { + "id": 3, "source": "local", "source_label": "Local", "external_id": "local-3", + "title": "And this too", "description": null, "url": null, + "project": null, "status": null, "priority": null, + "due_date": null, "start_date": null, "labels": [], + "is_done": false, "pinned": false, "stale": false, + "estimated_pomodoros": null, "days_overdue": 0, "bucket": "someday" + } + ], + "counts": {"overdue": 1, "today": 1, "active": 0, "upcoming": 0, "someday": 1}, + "sources": ["jira", "todoist", "local"] +} diff --git a/android/app/src/test/resources/fixtures/timer_complete_reply.json b/android/app/src/test/resources/fixtures/timer_complete_reply.json new file mode 100644 index 0000000..42c7483 --- /dev/null +++ b/android/app/src/test/resources/fixtures/timer_complete_reply.json @@ -0,0 +1,52 @@ +{ + "current": { + "id": 413, + "kind": "short_break", + "status": "running", + "started_at": "2026-10-19T09:37:04+00:00", + "ended_at": null, + "planned_seconds": 300, + "elapsed_seconds": 0, + "remaining_seconds": 300, + "paused_seconds": 0, + "interruptions": 0, + "cycle_index": 3, + "task": null, + "note": null + }, + "finished": { + "id": 412, + "kind": "work", + "status": "completed", + "started_at": "2026-10-19T09:12:04+00:00", + "ended_at": "2026-10-19T09:37:04+00:00", + "planned_seconds": 1500, + "elapsed_seconds": 1500, + "remaining_seconds": 0, + "paused_seconds": 0, + "interruptions": 1, + "cycle_index": 2, + "task": {"source": "jira", "external_id": "PLAT-184", "title": "Fix the flaky importer"}, + "note": null + }, + "auto_started": { + "id": 413, + "kind": "short_break", + "status": "running", + "started_at": "2026-10-19T09:37:04+00:00", + "planned_seconds": 300, + "remaining_seconds": 300, + "interruptions": 0, + "cycle_index": 3, + "task": null + }, + "celebration": "Seven down. The afternoon is yours to lose.", + "next_kind": "work", + "completed_today": 7, + "goal": 8, + "cycle_position": 3, + "cycles_before_long_break": 4, + "durations": {"work": 25, "short_break": 5, "long_break": 15}, + "server_time": "2026-10-19T09:37:04+00:00", + "timer_enabled": true +} diff --git a/android/app/src/test/resources/fixtures/timer_state_idle.json b/android/app/src/test/resources/fixtures/timer_state_idle.json new file mode 100644 index 0000000..0d759c4 --- /dev/null +++ b/android/app/src/test/resources/fixtures/timer_state_idle.json @@ -0,0 +1,11 @@ +{ + "current": null, + "next_kind": "work", + "completed_today": 0, + "goal": 8, + "cycle_position": 0, + "cycles_before_long_break": 4, + "durations": {"work": 45, "short_break": 15, "long_break": 30}, + "server_time": "2026-10-19T08:00:00+00:00", + "timer_enabled": true +} diff --git a/android/app/src/test/resources/fixtures/timer_state_running.json b/android/app/src/test/resources/fixtures/timer_state_running.json new file mode 100644 index 0000000..588b01f --- /dev/null +++ b/android/app/src/test/resources/fixtures/timer_state_running.json @@ -0,0 +1,29 @@ +{ + "current": { + "id": 412, + "kind": "work", + "status": "running", + "started_at": "2026-10-19T09:12:04+00:00", + "ended_at": null, + "planned_seconds": 1500, + "elapsed_seconds": 396, + "remaining_seconds": 1104, + "paused_seconds": 0, + "interruptions": 1, + "cycle_index": 2, + "task": { + "source": "jira", + "external_id": "PLAT-184", + "title": "Fix the flaky importer" + }, + "note": null + }, + "next_kind": "short_break", + "completed_today": 6, + "goal": 8, + "cycle_position": 2, + "cycles_before_long_break": 4, + "durations": {"work": 25, "short_break": 5, "long_break": 15}, + "server_time": "2026-10-19T09:18:40+00:00", + "timer_enabled": true +} diff --git a/android/build.gradle.kts b/android/build.gradle.kts new file mode 100644 index 0000000..8abdaf7 --- /dev/null +++ b/android/build.gradle.kts @@ -0,0 +1,8 @@ +// Plugins are applied per module; this file only declares them so the version +// catalog resolves them once for the whole build. +plugins { + alias(libs.plugins.kotlin.jvm) apply false + alias(libs.plugins.android.application) apply false + alias(libs.plugins.kotlin.compose) apply false + alias(libs.plugins.kotlin.serialization) apply false +} diff --git a/android/core/build.gradle.kts b/android/core/build.gradle.kts new file mode 100644 index 0000000..a7491ef --- /dev/null +++ b/android/core/build.gradle.kts @@ -0,0 +1,17 @@ +plugins { + alias(libs.plugins.kotlin.jvm) +} + +kotlin { + jvmToolchain(21) +} + +dependencies { + testImplementation(libs.kotlin.test) +} + +tasks.test { + testLogging { + events("passed", "failed", "skipped") + } +} diff --git a/android/core/src/main/kotlin/tech/kadence/core/Blocker.kt b/android/core/src/main/kotlin/tech/kadence/core/Blocker.kt new file mode 100644 index 0000000..7cf7f45 --- /dev/null +++ b/android/core/src/main/kotlin/tech/kadence/core/Blocker.kt @@ -0,0 +1,191 @@ +/** + * The blocking policy, ported so the phone can enforce it offline. + * + * The server decides *whether* blocking is on and *what* is on the list + * (`backend/app/services/blocker_service.py`); every client enforces it. Online, the + * server's `policy.active` is authoritative. Offline, this file has to reach the same + * answer on its own — otherwise losing signal would quietly switch the focus guard off, + * which is the one moment you least want it off. + * + * Two API details worth knowing, both verified against `policy()`: + * + * * `policy.domains` and `policy.apps` are **empty whenever `active` is false**, while + * `all_domains` / `all_apps` are always populated. So a client must read the `all_*` + * fields and gate on activity itself — which `desktop/.../controller.py` also does. + * * `mode: "always"` and `"scheduled"` mean the guard runs with no timer at all, so + * enforcement cannot be tied to the timer's lifecycle. + */ +package tech.kadence.core + +import java.time.ZoneId +import java.time.ZonedDateTime + +/** One `blocker.schedule[]` entry. `days` is ISO weekdays with **Monday = 0**. */ +data class BlockWindow( + val label: String = "", + val start: String = "00:00", + val end: String = "23:59", + val days: List = emptyList(), +) + +/** The `blocker` subtree of the settings document. */ +data class BlockerRules( + val enabled: Boolean = false, + val mode: String = "during_work", + val blockDuringBreaks: Boolean = false, + val blockedDomains: List = emptyList(), + val allowedDomains: List = emptyList(), + val subdomainExpansions: List = DEFAULT_SUBDOMAINS, + val blockedApps: List = emptyList(), + val killBlockedApps: Boolean = true, + val schedule: List = emptyList(), + val strict: Boolean = false, + val notifyOnBlock: Boolean = true, +) { + companion object { + /** The backend's `subdomain_expansions` default. */ + val DEFAULT_SUBDOMAINS = listOf("www", "m", "mobile", "app", "web", "i", "old", "new") + } +} + +/** Just enough of the running interval for the policy to be decided. */ +data class IntervalFacts( + val kind: String, + val status: String, +) { + val isActiveStatus: Boolean get() = status == "running" || status == "paused" + val isWork: Boolean get() = kind == "work" +} + +/** The verdict, carrying the same `reason` string the server would have sent. */ +data class PolicyVerdict(val active: Boolean, val reason: String) + +/** + * `youtube.com` -> itself plus `www.` and `m.`; `*.youtube.com` -> the bare domain plus + * every configured subdomain; `*gram*` -> nothing expandable, returned as a leftover. + * + * A port of `expand_entry()`. Returns `(hostnames, unexpandablePattern)`. + */ +fun expandEntry(raw: String, subdomains: List): Pair, String?> { + val entry = raw.trim().lowercase().trimStart('.') + if (entry.isEmpty()) return emptyList() to null + + if (entry.startsWith("*.")) { + val base = entry.removePrefix("*.") + if (base.isEmpty() || '*' in base) return emptyList() to entry + return (listOf(base) + subdomains.map { "$it.$base" }) to null + } + + if ('*' in entry) return emptyList() to entry + + return listOf(entry, "www.$entry", "m.$entry") to null +} + +/** Whether an allow-list entry — itself maskable — covers this hostname. */ +fun isAllowed(host: String, allowMasks: List): Boolean = + allowMasks.any { globMatches(it, host) } + +/** Normalised, de-duplicated allow masks, the way `expand_domains()` prepares them. */ +fun allowMasksOf(rules: BlockerRules): List = rules.allowedDomains + .filter { it.isNotBlank() } + .map { it.trim().lowercase().trimStart('.') } + +private fun subdomainsOf(rules: BlockerRules): List = rules.subdomainExpansions + .filter { it.isNotBlank() } + .map { it.trim().lowercase() } + +/** + * Every hostname a hosts file would be pointed at the redirect IP, allow list already + * subtracted — the client-side twin of `expand_domains()`, used when offline and as a + * cross-check against the server's `all_domains`. + */ +fun expandDomains(rules: BlockerRules): List = expandDomainsWithOrigin(rules).keys.toList() + +/** + * The same expansion, but remembering which block-list entry produced each hostname. + * + * Worth keeping, because the host alone does not identify the rule: `*.reddit.com` + * expands to the bare `reddit.com`, yet the mask does not *match* that bare name (see + * [globMatches]). Without the provenance the overlay would have to say "blocked: + * reddit.com" when the honest answer is "blocked by `*.reddit.com`". + * + * Insertion-ordered, and the first entry to claim a host keeps it. + */ +fun expandDomainsWithOrigin(rules: BlockerRules): Map { + val allowMasks = allowMasksOf(rules) + val subdomains = subdomainsOf(rules) + val origin = LinkedHashMap() + for (raw in rules.blockedDomains) { + val entry = raw.trim().lowercase().trimStart('.') + val (expanded, _) = expandEntry(raw, subdomains) + for (host in expanded) { + if (!isAllowed(host, allowMasks)) origin.putIfAbsent(host, entry) + } + } + return origin +} + +/** Block-list entries a hosts file cannot express, so the UI can flag them. */ +fun unexpandableMasks(rules: BlockerRules): List { + val subdomains = subdomainsOf(rules) + val leftovers = LinkedHashSet() + for (raw in rules.blockedDomains) { + val (_, pattern) = expandEntry(raw, subdomains) + if (pattern != null) leftovers.add(pattern) + } + return leftovers.toList() +} + +/** + * Whether any schedule window covers this moment. + * + * Both the weekday and the time of day are read in the **server's** timezone, so + * travelling does not shift your blocking windows. (The backend's `schedule_active()` + * takes the weekday from the process's local clock while taking the time from the + * configured zone; reading both from one zone is the behaviour that was intended.) + */ +fun scheduleActive(rules: BlockerRules, now: ZonedDateTime): Boolean { + val weekday = now.dayOfWeek.value - 1 + val moment = now.toLocalTime() + return rules.schedule.any { window -> + if (weekday !in window.days) return@any false + val start = parseClockTime(window.start) ?: return@any false + val end = parseClockTime(window.end) ?: return@any false + inWindow(moment, start, end) + } +} + +/** + * The port of `policy()`'s decision, reason strings included — so the Blocker screen + * reads identically whether the verdict came from the server or from here. + */ +fun evaluatePolicy( + rules: BlockerRules, + current: IntervalFacts?, + now: ZonedDateTime, +): PolicyVerdict { + if (!rules.enabled) return PolicyVerdict(false, "disabled") + + return when (rules.mode) { + "always" -> PolicyVerdict(true, "always on") + "scheduled" -> if (scheduleActive(rules, now)) { + PolicyVerdict(true, "inside a blocking window") + } else { + PolicyVerdict(false, "outside every window") + } + else -> when { + current != null && current.isWork && current.isActiveStatus -> + PolicyVerdict(true, "a work interval is running") + + current != null && !current.isWork && rules.blockDuringBreaks && + current.isActiveStatus -> + PolicyVerdict(true, "blocking stays on through breaks") + + else -> PolicyVerdict(false, "no work interval is running") + } + } +} + +/** Convenience for callers that only have an IANA zone id string. */ +fun zoneOrDefault(timezone: String?): ZoneId = + runCatching { ZoneId.of(timezone?.trim().orEmpty()) }.getOrElse { ZoneId.systemDefault() } diff --git a/android/core/src/main/kotlin/tech/kadence/core/Format.kt b/android/core/src/main/kotlin/tech/kadence/core/Format.kt new file mode 100644 index 0000000..8017156 --- /dev/null +++ b/android/core/src/main/kotlin/tech/kadence/core/Format.kt @@ -0,0 +1,87 @@ +/** + * Formatting shared by every screen, so numbers read the same everywhere. + * + * A literal port of `frontend/src/lib/format.ts`, down to the rounding. The web app, + * the QML `Theme.humanMinutes()` and this file have to agree: the same pomodoro seen + * in a browser, on the desktop and on the phone must not render three different ways. + * `FormatTest` asserts the exact outputs the TypeScript produces. + */ +package tech.kadence.core + +import java.time.LocalDate +import kotlin.math.roundToInt + +/** `"18:24"`, and `"1:05:00"` only once there is an hour to show. */ +fun clock(totalSeconds: Int): String { + val safe = totalSeconds.coerceAtLeast(0) + val hours = safe / 3600 + val minutes = (safe % 3600) / 60 + val seconds = safe % 60 + return if (hours > 0) { + "$hours:${pad(minutes)}:${pad(seconds)}" + } else { + "${pad(minutes)}:${pad(seconds)}" + } +} + +/** The web app's `clock()` takes a float and rounds; a drifting tick can land here. */ +fun clock(totalSeconds: Double): String = clock(totalSeconds.roundToInt()) + +/** + * `125` -> `"2h 5m"`, `120` -> `"2h"`, `5` -> `"5m"`. + * + * Negative input is clamped to zero rather than reproducing JavaScript's `"-1h -5m"`: + * a negative duration is a bug upstream, and printing it as nonsense hides it. + */ +fun humanMinutes(minutes: Int): String { + val rounded = minutes.coerceAtLeast(0) + val hours = rounded / 60 + val rest = rounded % 60 + return when { + hours > 0 && rest > 0 -> "${hours}h ${rest}m" + hours > 0 -> "${hours}h" + else -> "${rest}m" + } +} + +fun humanMinutes(minutes: Double): String = humanMinutes(minutes.roundToInt()) + +/** Interval kind -> the label every client shows. */ +val KIND_LABEL: Map = mapOf( + "work" to "Focus", + "short_break" to "Short break", + "long_break" to "Long break", +) + +/** + * Task bucket -> heading. + * + * Note `active`: the web app says "Would be nice to start" where the QML desktop says + * "In progress". The web app is the design reference for this client, so the web + * wording wins — see `frontend/src/lib/format.ts`. + */ +val BUCKET_LABEL: Map = mapOf( + "overdue" to "Overdue", + "today" to "Due today", + "active" to "Would be nice to start", + "upcoming" to "Coming up", + "someday" to "No deadline", +) + +/** The order the buckets are laid out in, top to bottom. */ +val BUCKET_ORDER: List = listOf("overdue", "today", "active", "upcoming", "someday") + +/** `""` when undated, `"3d overdue"` when late, otherwise the ISO due date. */ +fun dueLabel(dueDate: String?, daysOverdue: Int): String = when { + dueDate.isNullOrBlank() -> "" + daysOverdue > 0 -> "${daysOverdue}d overdue" + else -> dueDate +} + +/** `"2026-10-19"` -> `"10/19"`, for a chart axis with no room for a year. */ +fun shortDate(iso: String): String = iso.drop(5).replaceFirst("-", "/") + +/** Monday = 0, matching the backend's `BlockWindow.days` and the heatmap's columns. */ +fun weekdayOf(iso: String): Int = LocalDate.parse(iso).dayOfWeek.value - 1 + +private fun pad(value: Int): String = value.toString().padStart(2, '0') diff --git a/android/core/src/main/kotlin/tech/kadence/core/Glob.kt b/android/core/src/main/kotlin/tech/kadence/core/Glob.kt new file mode 100644 index 0000000..842ebdd --- /dev/null +++ b/android/core/src/main/kotlin/tech/kadence/core/Glob.kt @@ -0,0 +1,89 @@ +/** + * Python's `fnmatch`, in Kotlin. + * + * The block lists are shared across clients and were written for a Python backend: + * `steam*`, `*discord*`, `*.youtube.com`. Both the server + * (`backend/app/services/blocker_service.py`) and the desktop enforcer + * (`desktop/kadence_desktop/blocking/processes.py`) match them with `fnmatch`, so the + * phone has to use the same grammar or the same list would mean two different things. + * + * `fnmatch` is not shell globbing: `*` matches *everything*, separators included, which + * is exactly why `*gram*` catches `instagram.com`. + */ +package tech.kadence.core + +/** The wildcard characters whose presence makes an entry a mask rather than a literal. */ +private const val WILDCARDS = "*?[" + +/** Whether this entry is a mask at all — the branch `processes.matches()` takes first. */ +fun isMask(pattern: String): Boolean = pattern.any { it in WILDCARDS } + +/** + * Translate an `fnmatch` pattern to a `Regex` anchored at both ends. + * + * Compiled patterns are cached: the app matcher runs this against every block-list + * entry several times a second while a focus interval is live. + */ +fun globToRegex(pattern: String): Regex = globCache.getOrPut(pattern) { + val out = StringBuilder() + var i = 0 + while (i < pattern.length) { + when (val c = pattern[i]) { + '*' -> { + out.append(".*") + i++ + } + '?' -> { + out.append('.') + i++ + } + '[' -> { + // Find the closing bracket. `]` immediately after `[` or `[!` is a + // literal, which is why the scan starts past it. + var j = i + 1 + if (j < pattern.length && (pattern[j] == '!' || pattern[j] == '^')) j++ + if (j < pattern.length && pattern[j] == ']') j++ + while (j < pattern.length && pattern[j] != ']') j++ + if (j >= pattern.length) { + // Unterminated class: `fnmatch` treats the `[` as a literal. + out.append("\\[") + i++ + } else { + val body = pattern.substring(i + 1, j) + out.append('[') + when { + body.startsWith('!') -> out.append('^').append(quoteClass(body.drop(1))) + body.startsWith('^') -> out.append("\\^").append(quoteClass(body.drop(1))) + else -> out.append(quoteClass(body)) + } + out.append(']') + i = j + 1 + } + } + else -> { + out.append(Regex.escape(c.toString())) + i++ + } + } + } + Regex(out.toString(), RegexOption.DOT_MATCHES_ALL) +} + +/** `fnmatch(text, pattern)` — case-sensitive, like Python's on Linux. */ +fun globMatches(pattern: String, text: String): Boolean = + globToRegex(pattern).matches(text) + +/** + * Inside a character class only `]`, `\` and `^` need care; `*` and `?` are literal + * there, so they must not be escaped into something a regex reads differently. + */ +private fun quoteClass(body: String): String = buildString { + for (c in body) { + when (c) { + '\\', ']', '^', '[', '&' -> append('\\').append(c) + else -> append(c) + } + } +} + +private val globCache = HashMap() diff --git a/android/core/src/main/kotlin/tech/kadence/core/GlyphFrame.kt b/android/core/src/main/kotlin/tech/kadence/core/GlyphFrame.kt new file mode 100644 index 0000000..594e911 --- /dev/null +++ b/android/core/src/main/kotlin/tech/kadence/core/GlyphFrame.kt @@ -0,0 +1,224 @@ +/** + * What to light up on the Nothing Phone (3)'s rear Glyph Matrix. + * + * Deliberately pure: the SDK wants a flat array of per-dot brightness, so all the + * interesting work — which dots make a "4", where the ring's ticks fall, how it drains + * — is arithmetic that needs no device, no `.aar` and no Android at all. The whole rear + * display can therefore be developed and regression-tested on a laptop, with + * [asciiOf] rendering any frame as art you can read in a test failure. + * + * The matrix is 25x25 = 625 dots on Phone (3) (`Glyph.DEVICE_23112`), but the length is + * read from `Common.getDeviceMatrixLength()` at runtime, so nothing here hard-codes 25 + * beyond a default. + */ +package tech.kadence.core + +import kotlin.math.PI +import kotlin.math.cos +import kotlin.math.roundToInt +import kotlin.math.sin + +/** A mutable grid of dot brightness, 0..255. */ +class GlyphFrame(val size: Int = DEFAULT_SIZE) { + val dots = IntArray(size * size) + + fun set(x: Int, y: Int, brightness: Int) { + if (x < 0 || y < 0 || x >= size || y >= size) return + dots[y * size + x] = brightness.coerceIn(0, 255) + } + + fun get(x: Int, y: Int): Int = + if (x < 0 || y < 0 || x >= size || y >= size) 0 else dots[y * size + x] + + /** The flat array `GlyphMatrixManager.setMatrixFrame` expects. */ + fun render(): IntArray = dots.copyOf() + + val litCount: Int get() = dots.count { it > 0 } + + companion object { + const val DEFAULT_SIZE = 25 + } +} + +/** Brightness levels, kept together so "paused looks dimmer" is one decision. */ +object GlyphBrightness { + const val FULL = 255 + const val DIM = 90 + const val FAINT = 40 +} + +/** + * A 3x5 dot font. Small enough that two digits fit beside each other inside the ring, + * large enough to read at arm's length on a desk. + */ +private val DIGITS: Map> = mapOf( + '0' to arrayOf("###", "# #", "# #", "# #", "###"), + '1' to arrayOf(" #", " #", " #", " #", " #"), + '2' to arrayOf("###", " #", "###", "# ", "###"), + '3' to arrayOf("###", " #", "###", " #", "###"), + '4' to arrayOf("# #", "# #", "###", " #", " #"), + '5' to arrayOf("###", "# ", "###", " #", "###"), + '6' to arrayOf("###", "# ", "###", "# #", "###"), + '7' to arrayOf("###", " #", " #", " #", " #"), + '8' to arrayOf("###", "# #", "###", "# #", "###"), + '9' to arrayOf("###", "# #", "###", " #", "###"), +) + +private const val GLYPH_W = 3 +private const val GLYPH_H = 5 +private const val GLYPH_GAP = 1 + +/** Draw a run of digits with its top-left corner at ([x], [y]). */ +fun GlyphFrame.drawDigits(text: String, x: Int, y: Int, brightness: Int) { + var cursor = x + for (ch in text) { + val glyph = DIGITS[ch] + if (glyph == null) { + cursor += GLYPH_W + GLYPH_GAP + continue + } + for (row in 0 until GLYPH_H) { + for (col in 0 until GLYPH_W) { + if (glyph[row][col] == '#') set(cursor + col, y + row, brightness) + } + } + cursor += GLYPH_W + GLYPH_GAP + } +} + +/** Width in dots of [text] in the 3x5 font. */ +fun digitsWidth(text: String): Int = + if (text.isEmpty()) 0 else text.length * GLYPH_W + (text.length - 1) * GLYPH_GAP + +/** Draw digits centred horizontally. */ +fun GlyphFrame.drawDigitsCentred(text: String, y: Int, brightness: Int) { + drawDigits(text, (size - digitsWidth(text)) / 2, y, brightness) +} + +/** + * The ring: one dot per dial tick around the perimeter, lit for the time **remaining**. + * + * Tick 0 sits at twelve o'clock and they run clockwise, and the lit run starts there — + * so the arc shrinks *towards* twelve as the interval drains, which is how the web + * dial's arc reads (`stroke-dashoffset` from `-90deg`). Lighting the trailing ticks + * instead would leave the last sliver stranded at eleven o'clock. + * + * The tick count comes from [dialTickCount], shared with the Compose dial, so the front + * and the back of the phone can never disagree about what one dot is worth. + */ +fun GlyphFrame.drawRing( + plannedSeconds: Int, + remainingSeconds: Int, + brightness: Int = GlyphBrightness.FULL, + spentBrightness: Int = 0, +) { + val count = dialTickCount(plannedSeconds) + val remainingTicks = count - dialSpentTicks(plannedSeconds, remainingSeconds) + val centre = (size - 1) / 2.0 + val radius = centre - 1.0 + + for (i in 0 until count) { + val angle = i.toDouble() / count * 2 * PI - PI / 2 + val x = (centre + radius * cos(angle)).roundToInt() + val y = (centre + radius * sin(angle)).roundToInt() + set(x, y, if (i < remainingTicks) brightness else spentBrightness) + } +} + +/** How the toy should look right now. */ +object GlyphRenderer { + + /** + * The timer face: minutes above seconds, inside a draining ring. + * + * Past an hour the top row becomes hours and the bottom minutes, because `mm` would + * otherwise read as a number far larger than the matrix can show. + */ + fun timerFrame( + remainingSeconds: Int, + plannedSeconds: Int, + paused: Boolean = false, + size: Int = GlyphFrame.DEFAULT_SIZE, + ): GlyphFrame { + val frame = GlyphFrame(size) + val safe = remainingSeconds.coerceAtLeast(0) + val textBrightness = if (paused) GlyphBrightness.DIM else GlyphBrightness.FULL + val ringBrightness = if (paused) GlyphBrightness.DIM else GlyphBrightness.FULL + + val top: Int + val bottom: Int + if (safe >= 3600) { + top = safe / 3600 + bottom = (safe % 3600) / 60 + } else { + top = safe / 60 + bottom = safe % 60 + } + + frame.drawRing(plannedSeconds, safe, ringBrightness) + frame.drawDigitsCentred(pad2(top), TOP_ROW_Y, textBrightness) + frame.drawDigitsCentred(pad2(bottom), BOTTOM_ROW_Y, textBrightness) + return frame + } + + /** + * The always-on face: today's pomodoros against the goal, as a dot grid. + * + * The same encoding as the web app's dot row (`TimerPage.tsx`) — earned dots solid, + * the rest faint — on 625 LEDs. + */ + fun dotsFrame( + done: Int, + goal: Int, + size: Int = GlyphFrame.DEFAULT_SIZE, + ): GlyphFrame { + val frame = GlyphFrame(size) + val total = maxOf(goal, done, 1) + val perRow = minOf(DOTS_PER_ROW, total) + val rows = (total + perRow - 1) / perRow + + val spacing = 3 + val gridW = perRow * spacing - (spacing - 1) + val gridH = rows * spacing - (spacing - 1) + val originX = (size - gridW) / 2 + val originY = (size - gridH) / 2 + + for (i in 0 until total) { + val x = originX + (i % perRow) * spacing + val y = originY + (i / perRow) * spacing + frame.set(x, y, if (i < done) GlyphBrightness.FULL else GlyphBrightness.FAINT) + } + return frame + } + + /** Everything off — what `turnOff()` should leave behind. */ + fun blank(size: Int = GlyphFrame.DEFAULT_SIZE): GlyphFrame = GlyphFrame(size) + + private const val TOP_ROW_Y = 6 + private const val BOTTOM_ROW_Y = 14 + private const val DOTS_PER_ROW = 8 + + private fun pad2(value: Int): String = + if (value in 0..99) value.toString().padStart(2, '0') else value.toString() +} + +/** + * Render a frame as text, so a failing assertion shows the picture. + * + * `#` is bright, `+` is dim, `.` is dark. + */ +fun asciiOf(frame: GlyphFrame): String = buildString { + for (y in 0 until frame.size) { + for (x in 0 until frame.size) { + val v = frame.get(x, y) + append( + when { + v >= 200 -> '#' + v > 0 -> '+' + else -> '.' + }, + ) + } + if (y < frame.size - 1) append('\n') + } +} diff --git a/android/core/src/main/kotlin/tech/kadence/core/Matchers.kt b/android/core/src/main/kotlin/tech/kadence/core/Matchers.kt new file mode 100644 index 0000000..6227bdd --- /dev/null +++ b/android/core/src/main/kotlin/tech/kadence/core/Matchers.kt @@ -0,0 +1,200 @@ +/** + * Deciding whether a hostname or an app is on the list. + * + * `AppMatcher` is a port of `matches()` in + * `desktop/kadence_desktop/blocking/processes.py`, with Android's two haystacks — + * the package name and the app's visible label — standing in for the Linux process + * name and its command line. + * + * `DomainMatcher` goes one step further than the desktop *can* go. A hosts file has no + * wildcards, so the backend has to expand every mask into concrete hostnames and + * reports whatever it cannot express as `unexpandable`. A URL-bar matcher has no such + * limit, so patterns like `*gram*` — which the desktop apologises for — are enforced + * here. That is the one place the phone is strictly stronger than the laptop. + */ +package tech.kadence.core + +import java.net.IDN + +/** What to do about a candidate, and why. */ +sealed interface BlockDecision { + data object Allow : BlockDecision + + /** + * @param target what gets reported to `POST /api/blocker/events` and grouped by + * `by_target` in the report — the hostname for a site, the matched pattern for an + * app, matching what the desktop enforcer sends. + * @param matchedRule the block-list entry responsible, for the overlay's copy. + */ + data class Block( + val target: String, + val matchedRule: String, + val action: String, + ) : BlockDecision +} + +/** `BlockEventRequest.action` — the server only fires `notify_on_block` for `killed`. */ +object BlockAction { + /** A site we turned away; the hosts-file equivalent. */ + const val BLOCKED = "blocked" + + /** An app we actually ejected the user from. The only value that notifies. */ + const val KILLED = "killed" + + /** Reported but not enforced — what `kill_blocked_apps = false` means. */ + const val WARNED = "warned" +} + +/** + * Reduce whatever a browser's URL bar exposed to a bare hostname, or null when the text + * is not a host at all. + * + * The URL bar is a lossy source: it may show `youtube.com`, a full URL, a search + * phrase, a `chrome://` page, or a placeholder. Anything that is not confidently a + * hostname must return null — a false positive here would block an innocent page. + */ +fun normalizeHost(raw: String?): String? { + var text = raw?.trim()?.lowercase().orEmpty() + if (text.isEmpty()) return null + + // A scheme we can never block, and the "about:" family. + if (text.startsWith("about:") || text.startsWith("chrome:") || + text.startsWith("chrome-native:") || text.startsWith("data:") || + text.startsWith("file:") || text.startsWith("content:") + ) { + return null + } + + // Strip the scheme. + val schemeAt = text.indexOf("://") + if (schemeAt >= 0) text = text.substring(schemeAt + 3) + + // A space means a search phrase, not a host — but only once the scheme is gone, + // since "https://example.com /path" pasted with a stray space is still a URL. + text = text.trim() + if (text.isEmpty()) return null + + // Authority ends at the first `/`, `?` or `#`. + text = text.takeWhile { it != '/' && it != '?' && it != '#' } + + // Drop userinfo and the port. + val at = text.lastIndexOf('@') + if (at >= 0) text = text.substring(at + 1) + val colon = text.indexOf(':') + if (colon >= 0) text = text.substring(0, colon) + + text = text.trim().trimEnd('.') + if (text.isEmpty() || ' ' in text) return null + + // Unicode domains are matched in their ASCII form, which is what a block list holds. + // + // ALLOW_UNASSIGNED on purpose: strict `toASCII` *throws* on a host built from + // unassigned code points (a homoglyph like `аррӏе.com`), and a throw here would + // return null, which means "allow". A blocker that silently waves through the one + // category of domain designed to look like something else has it backwards. + val ascii = runCatching { IDN.toASCII(text, IDN.ALLOW_UNASSIGNED) } + .getOrNull()?.lowercase() ?: return null + + return if (HOST_PATTERN.matches(ascii)) ascii else null +} + +private val HOST_PATTERN = + Regex("^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$") + +/** + * Matches hostnames against the policy. + * + * @param expandedHosts the server's `all_domains` when online (already expanded and + * allow-list-subtracted), or [expandDomains]'s own output when offline. + */ +class DomainMatcher( + private val rules: BlockerRules, + expandedHosts: List = expandDomains(rules), +) { + private val exact: Set = expandedHosts.map { it.trim().lowercase() }.toSet() + private val allowMasks: List = allowMasksOf(rules) + private val rawEntries: List = rules.blockedDomains + .filter { it.isNotBlank() } + .map { it.trim().lowercase().trimStart('.') } + + /** host -> the block-list entry that expanded into it; see [expandDomainsWithOrigin]. */ + private val origin: Map = expandDomainsWithOrigin(rules) + + /** @param candidate anything the URL bar gave us — a host, a URL, or junk. */ + fun decide(candidate: String?): BlockDecision { + val host = normalizeHost(candidate) ?: return BlockDecision.Allow + + // 1. The allow list wins outright: `*.google.com` blocked plus + // `*.docs.google.com` allowed does what you would expect. + if (isAllowed(host, allowMasks)) return BlockDecision.Allow + + // 2. The expanded set — exactly what a hosts file would have caught. Name the + // entry that produced the host, falling back to a pattern that matches it + // and finally to the host itself (the server-supplied-list case, where we + // have no provenance). + if (host in exact) { + val rule = origin[host] ?: rawEntries.firstOrNull { entryCovers(it, host) } ?: host + return BlockDecision.Block(host, rule, BlockAction.BLOCKED) + } + + // 3. The raw entries, as patterns. This is the step the desktop cannot do. + for (entry in rawEntries) { + if (entryCovers(entry, host)) { + return BlockDecision.Block(host, entry, BlockAction.BLOCKED) + } + } + + return BlockDecision.Allow + } + + /** + * A mask is glob-matched; a plain entry covers itself and any subdomain of it, so + * `youtube.com` catches `music.youtube.com` even though no expansion listed it. + */ + private fun entryCovers(entry: String, host: String): Boolean = when { + entry.isEmpty() -> false + isMask(entry) -> globMatches(entry, host) + else -> host == entry || host.endsWith(".$entry") + } + + /** The masks the server had to give up on, which this client does enforce. */ + fun enforcedBeyondHostsFile(): List = unexpandableMasks(rules) +} + +/** Matches installed apps against `blocker.blocked_apps`. */ +class AppMatcher(private val patterns: List) { + + /** + * @param packageName e.g. `com.instagram.android` + * @param label the user-visible app name, e.g. `Instagram` + * @return the pattern that matched, or null + */ + fun match(packageName: String, label: String = ""): String? { + val name = packageName.trim().lowercase() + val alt = label.trim().lowercase() + return patterns.firstOrNull { raw -> matches(raw, name, alt) } + } + + fun decide(packageName: String, label: String = "", kill: Boolean): BlockDecision { + val rule = match(packageName, label) ?: return BlockDecision.Allow + val action = if (kill) BlockAction.KILLED else BlockAction.WARNED + return BlockDecision.Block(rule, rule, action) + } + + private companion object { + /** + * The port of `processes.matches()`: a mask is glob-matched against either + * haystack, while a plain entry is a *substring* test — which is what lets one + * shared list (`discord`) work for both a Linux process and `com.discord`. + */ + fun matches(pattern: String, name: String, alt: String): Boolean { + val p = pattern.trim().lowercase() + if (p.isEmpty()) return false + return if (isMask(p)) { + globMatches(p, name) || globMatches(p, alt) + } else { + p in name || p in alt + } + } + } +} diff --git a/android/core/src/main/kotlin/tech/kadence/core/Outbox.kt b/android/core/src/main/kotlin/tech/kadence/core/Outbox.kt new file mode 100644 index 0000000..c22d598 --- /dev/null +++ b/android/core/src/main/kotlin/tech/kadence/core/Outbox.kt @@ -0,0 +1,245 @@ +/** + * The offline outbox. + * + * Not one of these endpoints is idempotent: `start` creates, `extend` adds, `interrupt` + * increments. So replay is **at-most-once with a post-condition probe**, never blind + * retry — if a send fails ambiguously (the socket died after the request went out, so + * we cannot know whether the server applied it), we re-read the state and ask "does the + * world look like my call landed?" instead of sending it again. + * + * Coalescing happens at enqueue, not at replay: the queue stays a faithful, minimal + * description of what the user asked for, which is far easier to reason about than a + * pile of intents collapsed at the last moment. + */ +package tech.kadence.core + +/** The intents that can be queued. There is no STOP — stopping is [ABANDON]. */ +enum class OutboxOp { + START, + PAUSE, + RESUME, + COMPLETE, + ABANDON, + EXTEND, + INTERRUPT, + ATTACH_TASK, +} + +/** + * One queued intent. + * + * @param anchorSessionId the interval this intent targeted; null for [OutboxOp.START], + * which by definition has no interval yet. + * @param repeat how many times to replay it — only [OutboxOp.INTERRUPT] coalesces this + * way, because the server increments a counter and the count *is* the data. + */ +data class OutboxEntry( + val seq: Long, + val op: OutboxOp, + val anchorSessionId: Long? = null, + val kind: String? = null, + val minutes: Int = 0, + val taskId: Long? = null, + val reason: String? = null, + val repeat: Int = 1, +) + +/** + * Fold [incoming] into [queue], returning the new queue. + * + * Every rule here exists because replaying the naive sequence would be wrong or + * wasteful, and each one is pinned by a test in `OutboxTest`. + */ +fun coalesce(queue: List, incoming: OutboxEntry): List { + val out = queue.toMutableList() + + when (incoming.op) { + // A start supersedes its predecessor on the server anyway (`pomodoro.start()` + // abandons the running interval as "superseded"), so every intent aimed at that + // interval is moot. Task and settings intents are not timer intents and stay. + OutboxOp.START -> { + out.removeAll { it.anchorSessionId != null && it.anchorSessionId == incoming.anchorSessionId } + out.removeAll { it.op == OutboxOp.START } + out.add(incoming) + } + + // Pause/resume annihilate: the user changed their mind before we had signal. + OutboxOp.RESUME -> { + val last = out.lastOrNull { it.isTimerOpFor(incoming.anchorSessionId) } + if (last?.op == OutboxOp.PAUSE) out.remove(last) else out.add(incoming) + } + + OutboxOp.PAUSE -> { + val last = out.lastOrNull { it.isTimerOpFor(incoming.anchorSessionId) } + if (last?.op == OutboxOp.RESUME) out.remove(last) else out.add(incoming) + } + + // "+5 min" twice is "+10 min" once. + OutboxOp.EXTEND -> { + val existing = out.lastOrNull { + it.op == OutboxOp.EXTEND && it.anchorSessionId == incoming.anchorSessionId + } + if (existing != null) { + out[out.indexOf(existing)] = + existing.copy(minutes = existing.minutes + incoming.minutes) + } else { + out.add(incoming) + } + } + + // Counted, not collapsed — three interruptions must become three increments. + OutboxOp.INTERRUPT -> { + val existing = out.lastOrNull { + it.op == OutboxOp.INTERRUPT && it.anchorSessionId == incoming.anchorSessionId + } + if (existing != null) { + out[out.indexOf(existing)] = existing.copy(repeat = existing.repeat + incoming.repeat) + } else { + out.add(incoming) + } + } + + // Only the final choice of task matters. + OutboxOp.ATTACH_TASK -> { + out.removeAll { + it.op == OutboxOp.ATTACH_TASK && it.anchorSessionId == incoming.anchorSessionId + } + out.add(incoming) + } + + // A terminal intent ends the interval: anything still queued for it would be + // rejected with "No interval is running." + OutboxOp.COMPLETE, OutboxOp.ABANDON -> { + out.removeAll { it.isTimerOpFor(incoming.anchorSessionId) } + out.add(incoming) + } + } + + return out +} + +private fun OutboxEntry.isTimerOpFor(sessionId: Long?): Boolean = + sessionId != null && anchorSessionId == sessionId && op != OutboxOp.START + +/** Whether the queue holds anything the reconciler should treat as our own doing. */ +fun pendingOpsOf(queue: List): PendingOps = PendingOps( + hasAny = queue.isNotEmpty(), + hasStart = queue.any { it.op == OutboxOp.START }, + hasTerminal = queue.any { it.op == OutboxOp.COMPLETE || it.op == OutboxOp.ABANDON }, +) + +/** What to do with a queued entry after an attempt. */ +sealed interface ReplayOutcome { + /** It landed. Drop the row. */ + data object Done : ReplayOutcome + + /** The server rejected it on its merits. Drop the row; never retry a 4xx. */ + data class Rejected(val detail: String) : ReplayOutcome + + /** Try again later, with backoff. */ + data class Retry(val attempt: Int, val delaySeconds: Int) : ReplayOutcome + + /** Out of attempts — surface it and let the user retry or discard. */ + data object GiveUp : ReplayOutcome +} + +/** Eight attempts, 1s doubling to a 60s ceiling. */ +fun backoffSeconds(attempt: Int): Int = + if (attempt <= 0) 1 else (1 shl (attempt - 1).coerceAtMost(6)).coerceAtMost(60) + +const val MAX_REPLAY_ATTEMPTS: Int = 8 + +fun replayOutcomeFor(attempt: Int): ReplayOutcome = + if (attempt >= MAX_REPLAY_ATTEMPTS) { + ReplayOutcome.GiveUp + } else { + ReplayOutcome.Retry(attempt + 1, backoffSeconds(attempt + 1)) + } + +/** + * Did an ambiguously-failed send actually land? + * + * Compared against the state read back *after* the failure. Each probe is the weakest + * claim that is still conclusive — `>=` rather than `==`, because another client may + * have moved the same number further along in the meantime. + */ +fun postconditionHolds( + entry: OutboxEntry, + before: TimerSessionFacts?, + after: ServerTimerState, +): Boolean = when (entry.op) { + OutboxOp.START -> + after.current != null && + after.current.status == Status.RUNNING && + (entry.kind == null || after.current.kind == entry.kind) && + after.current.id != entry.anchorSessionId + + OutboxOp.EXTEND -> { + val base = before?.plannedSeconds ?: return false + val now = after.current ?: return false + now.id == entry.anchorSessionId && now.plannedSeconds >= base + entry.minutes * 60 + } + + OutboxOp.INTERRUPT -> { + val base = before?.interruptions ?: return false + val now = after.current ?: return false + now.id == entry.anchorSessionId && now.interruptions >= base + entry.repeat + } + + OutboxOp.PAUSE -> after.current?.takeIf { it.id == entry.anchorSessionId }?.isPaused == true + + OutboxOp.RESUME -> + after.current?.takeIf { it.id == entry.anchorSessionId }?.status == Status.RUNNING + + // The interval is gone, or has been replaced by a newer one. + OutboxOp.COMPLETE, OutboxOp.ABANDON -> + after.current == null || after.current.id != entry.anchorSessionId + + OutboxOp.ATTACH_TASK -> false // Nothing observable to probe; let it retry. +} + +/** + * An interval that both began *and* ended while offline. + * + * It cannot be filed honestly: `pomodoro.start()` stamps `started_at = utcnow()` and + * `focus_minutes` is derived from `actual_seconds`, so replaying start-then-complete on + * reconnect would record a pomodoro at the wrong hour with roughly zero duration, + * quietly corrupting the very statistics the app exists to produce. These are + * quarantined and surfaced, never replayed silently. + */ +data class UnfiledInterval( + val kind: String, + val startedAtWallMillis: Long, + val endedAtWallMillis: Long, + val plannedSeconds: Int, + val interruptions: Int = 0, +) { + val actualSeconds: Int get() = ((endedAtWallMillis - startedAtWallMillis) / 1000L).toInt() +} + +/** + * Split a drained queue into what can be replayed and what has to be quarantined. + * + * A START whose matching COMPLETE/ABANDON is also still queued never reached the + * server, so the whole interval happened offline — see [UnfiledInterval]. + */ +fun partitionForReplay(queue: List): Pair, List> { + val startSeqs = queue.filter { it.op == OutboxOp.START }.map { it.seq }.toSet() + if (startSeqs.isEmpty()) return queue to emptyList() + + // A terminal op with no anchor belongs to the queued start that precedes it. + val quarantined = mutableSetOf() + for (start in queue.filter { it.op == OutboxOp.START }) { + val terminal = queue.firstOrNull { + it.seq > start.seq && (it.op == OutboxOp.COMPLETE || it.op == OutboxOp.ABANDON) + } + if (terminal != null) { + quarantined += queue.filter { it.seq >= start.seq && it.seq <= terminal.seq } + .map { it.seq } + } + } + + val replayable = queue.filter { it.seq !in quarantined } + val unfiled = queue.filter { it.seq in quarantined } + return replayable to unfiled +} diff --git a/android/core/src/main/kotlin/tech/kadence/core/TimeWindow.kt b/android/core/src/main/kotlin/tech/kadence/core/TimeWindow.kt new file mode 100644 index 0000000..e7c2526 --- /dev/null +++ b/android/core/src/main/kotlin/tech/kadence/core/TimeWindow.kt @@ -0,0 +1,32 @@ +/** + * Clock windows, including the ones that wrap midnight. + * + * A port of `in_window()` in `backend/app/timeutil.py`, used for the blocker's + * `schedule[]` entries and for Telegram's quiet hours. Both ends are inclusive, and a + * window whose start is after its end (`23:00 -> 08:00`) spans midnight. + */ +package tech.kadence.core + +import java.time.LocalTime + +/** Whether `moment` falls inside `[start, end]`, wrapping across midnight if needed. */ +fun inWindow(moment: LocalTime, start: LocalTime, end: LocalTime): Boolean = + if (start <= end) moment >= start && moment <= end else moment >= start || moment <= end + +/** + * Parse the `"HH:MM"` the settings document stores. + * + * Returns null rather than throwing: these strings come from a server document a user + * can edit, and one malformed window must not take the whole policy down with it. + */ +fun parseClockTime(raw: String?): LocalTime? { + val text = raw?.trim().orEmpty() + if (text.isEmpty()) return null + val parts = text.split(':') + if (parts.size < 2) return null + val hour = parts[0].toIntOrNull() ?: return null + val minute = parts[1].toIntOrNull() ?: return null + val second = if (parts.size > 2) parts[2].toIntOrNull() ?: 0 else 0 + if (hour !in 0..23 || minute !in 0..59 || second !in 0..59) return null + return LocalTime.of(hour, minute, second) +} diff --git a/android/core/src/main/kotlin/tech/kadence/core/Timer.kt b/android/core/src/main/kotlin/tech/kadence/core/Timer.kt new file mode 100644 index 0000000..fa1690c --- /dev/null +++ b/android/core/src/main/kotlin/tech/kadence/core/Timer.kt @@ -0,0 +1,248 @@ +/** + * The timer, as a client is allowed to understand it. + * + * The server owns the clock (`backend/app/services/pomodoro.py`); a client renders + * `remaining_seconds` and ticks locally between polls. Everything here is pure: given + * what the server last said, what the phone believes, and what is still queued, work + * out what to show and whether to say anything about it. + * + * Three server behaviours this file has to respect: + * + * * `POST /api/timer/start` **abandons** whatever is running, with reason + * `"superseded"` — so a queued start is destructive, not additive. + * * `POST /api/timer/complete` may **auto-start the next interval**, so a reply can + * contain an interval nobody explicitly asked for. + * * There is **no stop endpoint**: stopping is `abandon`, and under `strict_mode` a + * work interval refuses to be abandoned without a reason. + */ +package tech.kadence.core + +/** The interval kinds, as the API spells them. */ +object Kind { + const val WORK = "work" + const val SHORT_BREAK = "short_break" + const val LONG_BREAK = "long_break" +} + +/** The interval statuses, as the API spells them. */ +object Status { + const val RUNNING = "running" + const val PAUSED = "paused" + const val COMPLETED = "completed" + const val ABANDONED = "abandoned" +} + +/** The parts of `TimerState.current` a client actually reasons about. */ +data class TimerSessionFacts( + val id: Long, + val kind: String, + val status: String, + val plannedSeconds: Int, + val remainingSeconds: Int, + val pausedSeconds: Int = 0, + val interruptions: Int = 0, +) { + val isWork: Boolean get() = kind == Kind.WORK + val isPaused: Boolean get() = status == Status.PAUSED + val isActive: Boolean get() = status == Status.RUNNING || status == Status.PAUSED +} + +/** `GET /api/timer/state`, reduced to what drives the UI. */ +data class ServerTimerState( + val current: TimerSessionFacts?, + val nextKind: String = Kind.WORK, + val completedToday: Int = 0, + val goal: Int = 8, + val cyclePosition: Int = 0, + val cyclesBeforeLongBreak: Int = 4, + /** **Minutes**, not seconds — `pomodoro.state()` sends minutes here. */ + val durationsMinutes: Map = emptyMap(), + val timerEnabled: Boolean = true, +) + +/** + * Where the local tick counts down from. + * + * Anchored on [elapsedNanos] — a monotonic clock, never wall time — so a timezone + * change or an NTP correction mid-interval cannot corrupt a countdown. + */ +data class TickAnchor( + val sessionId: Long, + val remainingAtAnchor: Int, + val elapsedNanos: Long, + val paused: Boolean, +) + +/** + * Seconds left at [nowNanos]. A paused interval is frozen at its anchor. + * + * The elapsed delta is floored at zero: a monotonic source should never go backwards, + * but if it ever appears to, time must not be *added* to the interval — a countdown + * that grows is worse than one that stalls. + */ +fun remainingAt(anchor: TickAnchor, nowNanos: Long): Int { + if (anchor.paused) return anchor.remainingAtAnchor.coerceAtLeast(0) + val elapsedSeconds = ((nowNanos - anchor.elapsedNanos) / 1_000_000_000L) + .coerceAtLeast(0L) + .toInt() + return (anchor.remainingAtAnchor - elapsedSeconds).coerceIn(0, anchor.remainingAtAnchor) +} + +/** `1 - remaining/planned`, clamped — the dial's fill, mirroring `controller.progress`. */ +fun progressOf(remainingSeconds: Int, plannedSeconds: Int): Float { + if (plannedSeconds <= 0) return 0f + val raw = 1f - remainingSeconds.toFloat() / plannedSeconds.toFloat() + return raw.coerceIn(0f, 1f) +} + +/** + * How many ticks the dial draws, and how many are spent. + * + * One per minute up to an hour, then one per five minutes — the rule shared by + * `frontend/src/components/TimerDial.tsx` and `qml/components/TimerDial.qml`, kept here + * so the Compose dial and the Glyph ring cannot drift apart. + */ +fun dialTickCount(plannedSeconds: Int): Int { + val minutes = Math.round(plannedSeconds / 60.0).toInt().coerceAtLeast(1) + return if (minutes <= 60) minutes else Math.round(minutes / 5.0).toInt().coerceAtLeast(1) +} + +fun dialSpentTicks(plannedSeconds: Int, remainingSeconds: Int): Int { + val count = dialTickCount(plannedSeconds) + val elapsed = progressOf(remainingSeconds, plannedSeconds) + return kotlin.math.floor(count * elapsed).toInt().coerceIn(0, count) +} + +/** + * What should run next, worked out locally for an offline start. + * + * A port of `pomodoro.next_kind()`: after every `cyclesBeforeLongBreak` completed work + * intervals today the next break is the long one, and the count resets with the day, so + * a long break is never owed from yesterday. Online, the server's `next_kind` wins. + */ +fun nextKindLocally( + lastKind: String?, + lastStatus: String?, + completedWorkToday: Int, + cyclesBeforeLongBreak: Int, +): String { + if (lastKind == null || lastKind != Kind.WORK || lastStatus == Status.ABANDONED) { + return Kind.WORK + } + val cycles = cyclesBeforeLongBreak.coerceAtLeast(1) + return if (completedWorkToday > 0 && completedWorkToday % cycles == 0) { + Kind.LONG_BREAK + } else { + Kind.SHORT_BREAK + } +} + +/** + * Whether `abandon` will be refused for want of a reason. + * + * `pomodoro.abandon()` raises under `strict_mode` for a **work** interval with a blank + * reason. Checking it client-side is what lets the offline "stop" affordance collect + * the reason up front instead of queueing a call that is certain to 400. + */ +fun abandonNeedsReason(strictMode: Boolean, kind: String, reason: String?): Boolean = + strictMode && kind == Kind.WORK && reason.isNullOrBlank() + +/** Six hours, matching `pomodoro.reap_stale()`'s auto-abandon threshold. */ +const val STALE_INTERVAL_SECONDS: Int = 6 * 60 * 60 + +/** + * The client-side mirror of `reap_stale`: stop believing in a local interval that has + * been ticking for six hours with no server contact, so a phone left offline overnight + * does not claim a fourteen-hour pomodoro. + */ +fun isLocallyStale(elapsedSeconds: Int): Boolean = elapsedSeconds > STALE_INTERVAL_SECONDS + +// --- reconciliation --------------------------------------------------------- + +/** What the phone currently believes it is showing. */ +data class LocalBelief( + val sessionId: Long?, + val paused: Boolean = false, +) + +/** What is still queued, which decides whether a difference is ours or somebody's. */ +data class PendingOps( + val hasAny: Boolean = false, + val hasStart: Boolean = false, + val hasTerminal: Boolean = false, +) + +/** The outcome of comparing the server's answer with what the phone was showing. */ +sealed interface Reconciliation { + /** Re-anchor to the server and say nothing. The overwhelmingly common case. */ + data object Adopt : Reconciliation + + /** Keep the optimistic local value: re-anchoring now would visibly bounce. */ + data object KeepOptimistic : Reconciliation + + /** Our own queued intent landed; adopt it without narrating it. */ + data object AdoptOwnReplay : Reconciliation + + /** Another client took over. Worth telling the user. */ + data class AdoptForeign(val kind: String) : Reconciliation + + /** The interval we were ticking is gone and we did not end it. */ + data object EndedElsewhere : Reconciliation + + /** Still the same interval, but somebody else paused it. */ + data object PausedElsewhere : Reconciliation + + /** `timer_enabled` went false: every queued timer intent is now certain to 400. */ + data object ViewOnlyPurge : Reconciliation + + /** No answer from the server; keep ticking from the anchor. */ + data object Offline : Reconciliation +} + +/** + * Decide what to do with a poll result. + * + * @param server the freshly polled state, or null when the backend is unreachable. + */ +fun reconcile( + server: ServerTimerState?, + local: LocalBelief, + pending: PendingOps = PendingOps(), +): Reconciliation { + if (server == null) return Reconciliation.Offline + + // A disabled timer refuses start/pause/resume outright, so anything queued is + // dead on arrival; dropping it is kinder than retrying it eight times. + if (!server.timerEnabled) return Reconciliation.ViewOnlyPurge + + val current = server.current + + if (current == null) { + return when { + pending.hasTerminal -> Reconciliation.AdoptOwnReplay + local.sessionId != null -> Reconciliation.EndedElsewhere + else -> Reconciliation.Adopt + } + } + + // Nothing local to contradict: a cold start, or we were idle and someone began an + // interval. Either way there is no conflict to report. + if (local.sessionId == null) { + return if (pending.hasStart) Reconciliation.AdoptOwnReplay else Reconciliation.Adopt + } + + if (local.sessionId != current.id) { + return if (pending.hasStart) { + Reconciliation.AdoptOwnReplay + } else { + Reconciliation.AdoptForeign(current.kind) + } + } + + // Same interval. + return when { + pending.hasAny -> Reconciliation.KeepOptimistic + current.isPaused && !local.paused -> Reconciliation.PausedElsewhere + else -> Reconciliation.Adopt + } +} diff --git a/android/core/src/main/kotlin/tech/kadence/core/Tokens.kt b/android/core/src/main/kotlin/tech/kadence/core/Tokens.kt new file mode 100644 index 0000000..e82fb17 --- /dev/null +++ b/android/core/src/main/kotlin/tech/kadence/core/Tokens.kt @@ -0,0 +1,203 @@ +/** + * The design tokens, as ARGB. + * + * A transcription of `frontend/src/tokens.ts` and `frontend/src/lib/viz.ts`, kept in the + * pure module so `TokenParityTest` can read those TypeScript files directly and fail the + * build when the two drift. The design brief is that all clients are "the same product"; + * this is the only way to actually enforce it rather than hope for it. + * + * Values are `0xAARRGGBB` longs because `androidx.compose.ui.graphics.Color` cannot be + * referenced from a module that deliberately has no Android dependency. The app module + * wraps each one in `Color(...)` and nothing else. + */ +package tech.kadence.core + +import kotlin.math.roundToLong + +/** `#RRGGBB`, fully opaque. */ +internal fun rgb(hex: Long): Long = 0xFF000000L or hex + +/** `rgba(r, g, b, a)` with the CSS alpha fraction, rounded half-up to 8 bits. */ +internal fun rgba(hex: Long, alpha: Double): Long = + ((alpha * 255.0).roundToLong() shl 24) or hex + +/** The semantic palette. One instance per theme; see [kadenceTokens]. */ +data class KadenceTokens( + val paper: Long, + val surface: Long, + val surfaceSunken: Long, + val ink: Long, + val inkMuted: Long, + val inkFaint: Long, + val rule: Long, + val ruleStrong: Long, + val ember: Long, + val emberSoft: Long, + val pine: Long, + val amber: Long, + val clay: Long, +) + +val KADENCE_LIGHT = KadenceTokens( + paper = rgb(0xFAF7F2), + surface = rgb(0xFFFFFF), + surfaceSunken = rgb(0xF3EFE8), + ink = rgb(0x17150F), + inkMuted = rgb(0x6E675B), + inkFaint = rgb(0x9A9388), + rule = rgba(0x17150F, 0.12), + ruleStrong = rgba(0x17150F, 0.26), + ember = rgb(0xB4441E), + emberSoft = rgba(0xB4441E, 0.10), + pine = rgb(0x2F6B55), + amber = rgb(0x8A6200), + clay = rgb(0xA33A2E), +) + +val KADENCE_DARK = KadenceTokens( + paper = rgb(0x121110), + surface = rgb(0x1A1917), + surfaceSunken = rgb(0x201E1B), + ink = rgb(0xF4F1EA), + inkMuted = rgb(0xA79F93), + inkFaint = rgb(0x776F64), + rule = rgba(0xF4F1EA, 0.14), + ruleStrong = rgba(0xF4F1EA, 0.30), + ember = rgb(0xE0724A), + emberSoft = rgba(0xE0724A, 0.14), + pine = rgb(0x6FB394), + amber = rgb(0xD9A441), + clay = rgb(0xE07A6E), +) + +fun kadenceTokens(dark: Boolean): KadenceTokens = if (dark) KADENCE_DARK else KADENCE_LIGHT + +/** + * Chart colours — deliberately **not** the brand accent, and deliberately **not** the + * system accent either. A chart has to stay readable for colour-blind readers in both + * themes, which is a property of this validated palette and not of whatever hue the + * wallpaper happens to produce. + */ +data class VizTokens( + val work: Long, + val shortBreak: Long, + val longBreak: Long, + val sequential: List, + val grid: Long, + val axis: Long, + val empty: Long, +) + +val VIZ_LIGHT = VizTokens( + work = rgb(0xEB6834), + shortBreak = rgb(0x2A78D6), + longBreak = rgb(0x1BAF7A), + // blue 100 -> 600: "more pomodoros" reads as "darker". + sequential = listOf( + rgb(0xCDE2FB), rgb(0x9EC5F4), rgb(0x6DA7EC), + rgb(0x3987E5), rgb(0x256ABF), rgb(0x184F95), + ), + grid = rgba(0x17150F, 0.12), + axis = rgba(0x17150F, 0.45), + empty = rgba(0x17150F, 0.07), +) + +val VIZ_DARK = VizTokens( + work = rgb(0xD95926), + shortBreak = rgb(0x3987E5), + longBreak = rgb(0x199E70), + // Reversed, so "more" still reads as "darker" against a dark ground. + sequential = listOf( + rgb(0x104281), rgb(0x184F95), rgb(0x256ABF), + rgb(0x3987E5), rgb(0x6DA7EC), rgb(0x9EC5F4), + ), + grid = rgba(0xF4F1EA, 0.14), + axis = rgba(0xF4F1EA, 0.55), + empty = rgba(0xF4F1EA, 0.08), +) + +fun vizTokens(dark: Boolean): VizTokens = if (dark) VIZ_DARK else VIZ_LIGHT + +/** Port of `kindColor()` in `viz.ts`. */ +fun kindColor(kind: String, viz: VizTokens): Long = when (kind) { + Kind.WORK -> viz.work + Kind.LONG_BREAK -> viz.longBreak + else -> viz.shortBreak +} + +/** Port of `rampStep()` in `viz.ts`. Null means "nothing happened". */ +fun rampStep(count: Int, goal: Int, viz: VizTokens): Long? { + if (count <= 0) return null + val steps = viz.sequential.size + val ratio = if (goal > 0) count.toDouble() / goal else count.toDouble() / 8.0 + val index = (ratio * (steps - 1)).roundToLong().toInt().coerceIn(0, steps - 1) + return viz.sequential[index] +} + +// --- the system accent ----------------------------------------------------- + +/** + * Where the accent comes from. + * + * The canvas stays Kadence's — warm paper, ink type, hairline rules — while the single + * accent is taken from the system's dynamic palette when Android offers one, falling + * back to the brand ember. That keeps the editorial design intact (which is the look + * that was accepted) while letting the app pick up the phone's own colour. + * + * Chart colours are explicitly excluded: see [VizTokens]. + */ +fun accentArgb(systemAccent: Long?, dark: Boolean): Long = + systemAccent ?: kadenceTokens(dark).ember + +/** + * WCAG relative luminance of an opaque colour. + * + * Alpha is ignored: these are used to choose label colours against a solid fill. + */ +fun relativeLuminance(argb: Long): Double { + fun channel(value: Long): Double { + val c = value / 255.0 + return if (c <= 0.03928) c / 12.92 else Math.pow((c + 0.055) / 1.055, 2.4) + } + val r = channel((argb shr 16) and 0xFF) + val g = channel((argb shr 8) and 0xFF) + val b = channel(argb and 0xFF) + return 0.2126 * r + 0.7152 * g + 0.0722 * b +} + +/** WCAG contrast ratio, 1.0 (identical) to 21.0 (black on white). */ +fun contrastRatio(a: Long, b: Long): Double { + val la = relativeLuminance(a) + val lb = relativeLuminance(b) + val lighter = maxOf(la, lb) + val darker = minOf(la, lb) + return (lighter + 0.05) / (darker + 0.05) +} + +/** + * The label colour to put on top of [background]. + * + * The brand ember is dark enough for white (and `theme.ts` hard-codes exactly that), + * but a wallpaper-derived accent can be any lightness at all — Material You will + * happily hand back a pale yellow. Picking whichever of ink/paper actually contrasts is + * what stops "use the system colour" from quietly producing unreadable buttons. + */ +fun onAccentArgb(background: Long): Long { + // The same two candidates the other clients use: white, or the near-black ink that + // `theme.ts` names as the dark-theme contrast colour. + val onLight = rgb(0xFFFFFF) + val onDark = rgb(0x16140F) + return if (contrastRatio(background, onLight) >= contrastRatio(background, onDark)) { + onLight + } else { + onDark + } +} + +/** Whether a colour clears WCAG AA for large text / UI components (3:1). */ +fun meetsLargeTextContrast(foreground: Long, background: Long): Boolean = + contrastRatio(foreground, background) >= 3.0 + +/** Whether a colour clears WCAG AA for body text (4.5:1). */ +fun meetsBodyContrast(foreground: Long, background: Long): Boolean = + contrastRatio(foreground, background) >= 4.5 diff --git a/android/core/src/test/kotlin/tech/kadence/core/BlockerTest.kt b/android/core/src/test/kotlin/tech/kadence/core/BlockerTest.kt new file mode 100644 index 0000000..caa3125 --- /dev/null +++ b/android/core/src/test/kotlin/tech/kadence/core/BlockerTest.kt @@ -0,0 +1,243 @@ +package tech.kadence.core + +import java.time.ZoneId +import java.time.ZonedDateTime +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +/** + * Parity with `backend/app/services/blocker_service.py`. + * + * Every expectation in `expands like the backend` was produced by calling the real + * `expand_entry()` through the backend's own venv, not derived by reading the code — + * the phone enforces this list offline, so a divergence here means the guard behaves + * differently depending on whether you have signal. + */ +class BlockerTest { + + private val subs = BlockerRules.DEFAULT_SUBDOMAINS + + @Test + fun `expands like the backend`() { + assertEquals( + listOf("youtube.com", "www.youtube.com", "m.youtube.com") to null, + expandEntry("youtube.com", subs), + ) + assertEquals( + listOf( + "youtube.com", "www.youtube.com", "m.youtube.com", "mobile.youtube.com", + "app.youtube.com", "web.youtube.com", "i.youtube.com", "old.youtube.com", + "new.youtube.com", + ) to null, + expandEntry("*.youtube.com", subs), + ) + // A leading dot is stripped, and the entry is trimmed and lower-cased. + assertEquals( + listOf("reddit.com", "www.reddit.com", "m.reddit.com") to null, + expandEntry(".reddit.com", subs), + ) + assertEquals( + listOf("tiktok.com", "www.tiktok.com", "m.tiktok.com") to null, + expandEntry(" TikTok.com ", subs), + ) + } + + @Test + fun `patterns a hosts file cannot express come back as leftovers`() { + assertEquals(emptyList() to "*gram*", expandEntry("*gram*", subs)) + assertEquals(emptyList() to "*.", expandEntry("*.", subs)) + assertEquals(emptyList() to "**", expandEntry("**", subs)) + assertEquals(emptyList() to "*.a*.com", expandEntry("*.a*.com", subs)) + } + + @Test + fun `an empty entry is neither expanded nor reported`() { + assertEquals(emptyList() to null, expandEntry("", subs)) + assertEquals(emptyList() to null, expandEntry(" ", subs)) + assertEquals(emptyList() to null, expandEntry(".", subs)) + } + + @Test + fun `isAllowed matches the backend, mask by mask`() { + assertTrue(isAllowed("docs.google.com", listOf("docs.google.com"))) + assertTrue(isAllowed("www.youtube.com", listOf("*.youtube.com"))) + // Both of these are false in the backend too: a `*.` mask does not cover the + // bare domain, which is why `expand_entry` emits the base name separately. + assertFalse(isAllowed("youtube.com", listOf("*.youtube.com"))) + assertFalse(isAllowed("docs.google.com", listOf("*.docs.google.com"))) + } + + @Test + fun `expandDomains subtracts the allow list`() { + val rules = BlockerRules( + blockedDomains = listOf("*.youtube.com"), + allowedDomains = listOf("music.youtube.com", "*.i.youtube.com"), + subdomainExpansions = listOf("www", "m", "music", "i"), + ) + val hosts = expandDomains(rules) + assertTrue("youtube.com" in hosts) + assertTrue("www.youtube.com" in hosts) + assertTrue("m.youtube.com" in hosts) + assertFalse("music.youtube.com" in hosts, "an explicitly allowed host is removed") + assertTrue("i.youtube.com" in hosts, "the bare i. host is not covered by `*.i.`") + } + + @Test + fun `expandDomains de-duplicates overlapping entries`() { + val rules = BlockerRules( + blockedDomains = listOf("youtube.com", "youtube.com", "*.youtube.com"), + subdomainExpansions = listOf("www", "m"), + ) + val hosts = expandDomains(rules) + assertEquals(hosts.size, hosts.distinct().size, "no host appears twice") + assertEquals(listOf("youtube.com", "www.youtube.com", "m.youtube.com"), hosts) + } + + @Test + fun `unexpandableMasks collects the leftovers once each`() { + val rules = BlockerRules( + blockedDomains = listOf("youtube.com", "*gram*", "*gram*", "*tube*"), + ) + assertEquals(listOf("*gram*", "*tube*"), unexpandableMasks(rules)) + } + + // --- the policy decision ------------------------------------------------- + + private val zone = ZoneId.of("Europe/Moscow") + private fun at(day: String, time: String): ZonedDateTime = + ZonedDateTime.of(java.time.LocalDate.parse(day), java.time.LocalTime.parse(time), zone) + + private val working = IntervalFacts("work", "running") + private val breaking = IntervalFacts("short_break", "running") + + @Test + fun `disabled beats everything`() { + val rules = BlockerRules(enabled = false, mode = "always") + val verdict = evaluatePolicy(rules, working, at("2026-10-19", "12:00")) + assertFalse(verdict.active) + assertEquals("disabled", verdict.reason) + } + + @Test + fun `always on needs no interval`() { + val rules = BlockerRules(enabled = true, mode = "always") + val verdict = evaluatePolicy(rules, null, at("2026-10-19", "03:00")) + assertTrue(verdict.active) + assertEquals("always on", verdict.reason) + } + + @Test + fun `during work follows the interval`() { + val rules = BlockerRules(enabled = true, mode = "during_work") + val now = at("2026-10-19", "12:00") + + assertTrue(evaluatePolicy(rules, working, now).active) + assertEquals("a work interval is running", evaluatePolicy(rules, working, now).reason) + + // A paused work interval still blocks — you did not finish, you stepped away. + assertTrue(evaluatePolicy(rules, IntervalFacts("work", "paused"), now).active) + + // A finished or abandoned interval does not. + assertFalse(evaluatePolicy(rules, IntervalFacts("work", "completed"), now).active) + assertFalse(evaluatePolicy(rules, IntervalFacts("work", "abandoned"), now).active) + assertFalse(evaluatePolicy(rules, null, now).active) + assertEquals("no work interval is running", evaluatePolicy(rules, null, now).reason) + } + + @Test + fun `breaks block only when asked to`() { + val now = at("2026-10-19", "12:00") + val off = BlockerRules(enabled = true, mode = "during_work", blockDuringBreaks = false) + val on = BlockerRules(enabled = true, mode = "during_work", blockDuringBreaks = true) + + assertFalse(evaluatePolicy(off, breaking, now).active) + assertTrue(evaluatePolicy(on, breaking, now).active) + assertEquals("blocking stays on through breaks", evaluatePolicy(on, breaking, now).reason) + assertTrue(evaluatePolicy(on, IntervalFacts("long_break", "paused"), now).active) + // Still nothing to block through when no interval exists at all. + assertFalse(evaluatePolicy(on, null, now).active) + } + + @Test + fun `a schedule window is checked by weekday and clock`() { + val rules = BlockerRules( + enabled = true, + mode = "scheduled", + // Monday = 0; this is Mon-Fri, 09:00-18:00. + schedule = listOf(BlockWindow("Work hours", "09:00", "18:00", listOf(0, 1, 2, 3, 4))), + ) + // 2026-10-19 is a Monday. + assertTrue(evaluatePolicy(rules, null, at("2026-10-19", "09:00")).active) + assertTrue(evaluatePolicy(rules, null, at("2026-10-19", "13:37")).active) + assertTrue(evaluatePolicy(rules, null, at("2026-10-19", "18:00")).active) + assertFalse(evaluatePolicy(rules, null, at("2026-10-19", "08:59")).active) + assertFalse(evaluatePolicy(rules, null, at("2026-10-19", "18:01")).active) + // Saturday is not in the list. + assertFalse(evaluatePolicy(rules, null, at("2026-10-24", "13:00")).active) + assertEquals( + "outside every window", + evaluatePolicy(rules, null, at("2026-10-24", "13:00")).reason, + ) + assertEquals( + "inside a blocking window", + evaluatePolicy(rules, null, at("2026-10-19", "13:00")).reason, + ) + } + + @Test + fun `a schedule window may wrap midnight`() { + val rules = BlockerRules( + enabled = true, + mode = "scheduled", + schedule = listOf(BlockWindow("Night", "22:00", "06:00", listOf(0))), + ) + assertTrue(evaluatePolicy(rules, null, at("2026-10-19", "23:30")).active) + assertTrue(evaluatePolicy(rules, null, at("2026-10-19", "02:00")).active) + assertFalse(evaluatePolicy(rules, null, at("2026-10-19", "12:00")).active) + } + + @Test + fun `a malformed window is skipped, not fatal`() { + val rules = BlockerRules( + enabled = true, + mode = "scheduled", + schedule = listOf( + BlockWindow("Broken", "nope", "also nope", listOf(0)), + BlockWindow("Good", "09:00", "18:00", listOf(0)), + ), + ) + assertTrue(evaluatePolicy(rules, null, at("2026-10-19", "10:00")).active) + assertFalse(evaluatePolicy(rules, null, at("2026-10-19", "20:00")).active) + } + + @Test + fun `scheduled mode ignores the timer entirely`() { + val rules = BlockerRules( + enabled = true, + mode = "scheduled", + schedule = listOf(BlockWindow("Work hours", "09:00", "18:00", listOf(0))), + ) + // A running work interval does not rescue a moment outside every window: this + // is why enforcement cannot be tied to the timer's lifecycle. + assertFalse(evaluatePolicy(rules, working, at("2026-10-19", "20:00")).active) + } + + @Test + fun `an unknown mode falls back to during_work`() { + // The server's `else` branch; a settings document from a newer backend must not + // turn the guard permanently on or off. + val rules = BlockerRules(enabled = true, mode = "something_new") + assertTrue(evaluatePolicy(rules, working, at("2026-10-19", "12:00")).active) + assertFalse(evaluatePolicy(rules, null, at("2026-10-19", "12:00")).active) + } + + @Test + fun `zone parsing falls back instead of throwing`() { + assertEquals(ZoneId.of("Europe/Moscow"), zoneOrDefault("Europe/Moscow")) + assertEquals(ZoneId.systemDefault(), zoneOrDefault("Not/AZone")) + assertEquals(ZoneId.systemDefault(), zoneOrDefault(null)) + assertEquals(ZoneId.systemDefault(), zoneOrDefault("")) + } +} diff --git a/android/core/src/test/kotlin/tech/kadence/core/FormatTest.kt b/android/core/src/test/kotlin/tech/kadence/core/FormatTest.kt new file mode 100644 index 0000000..d63c79c --- /dev/null +++ b/android/core/src/test/kotlin/tech/kadence/core/FormatTest.kt @@ -0,0 +1,111 @@ +package tech.kadence.core + +import kotlin.test.Test +import kotlin.test.assertEquals + +/** + * Parity with `frontend/src/lib/format.ts`. The same interval rendered in a browser, + * in the desktop tray and on the phone has to produce the same string. + */ +class FormatTest { + + @Test + fun `clock pads minutes and seconds`() { + assertEquals("00:00", clock(0)) + assertEquals("00:09", clock(9)) + assertEquals("00:59", clock(59)) + assertEquals("01:00", clock(60)) + assertEquals("25:00", clock(1500)) + assertEquals("59:59", clock(3599)) + } + + @Test + fun `clock grows an hours segment only when needed`() { + assertEquals("1:00:00", clock(3600)) + assertEquals("2:03:04", clock(7384)) + // A 240-minute interval is the backend's documented maximum. + assertEquals("4:00:00", clock(14400)) + } + + @Test + fun `clock clamps negatives to zero`() { + // The local tick can overshoot by a fraction before the poll re-anchors. + assertEquals("00:00", clock(-1)) + assertEquals("00:00", clock(-500)) + } + + @Test + fun `clock rounds a fractional tick`() { + assertEquals("00:30", clock(30.4)) + assertEquals("00:31", clock(30.5)) + assertEquals("01:00", clock(59.6)) + } + + @Test + fun `humanMinutes matches the typescript`() { + assertEquals("0m", humanMinutes(0)) + assertEquals("5m", humanMinutes(5)) + assertEquals("59m", humanMinutes(59)) + assertEquals("1h", humanMinutes(60)) + assertEquals("1h 1m", humanMinutes(61)) + assertEquals("2h 5m", humanMinutes(125)) + assertEquals("2h", humanMinutes(120)) + // The README's worked example: "Focus: 2h 35m". + assertEquals("2h 35m", humanMinutes(155)) + } + + @Test + fun `humanMinutes rounds and clamps`() { + assertEquals("2h 35m", humanMinutes(154.6)) + assertEquals("0m", humanMinutes(-5)) + } + + @Test + fun `kind labels cover every interval kind`() { + assertEquals("Focus", KIND_LABEL["work"]) + assertEquals("Short break", KIND_LABEL["short_break"]) + assertEquals("Long break", KIND_LABEL["long_break"]) + assertEquals(3, KIND_LABEL.size) + } + + @Test + fun `bucket labels follow the web app, not the desktop`() { + // The desktop says "In progress" here; the web app is this client's reference. + assertEquals("Would be nice to start", BUCKET_LABEL["active"]) + assertEquals("Overdue", BUCKET_LABEL["overdue"]) + assertEquals("Due today", BUCKET_LABEL["today"]) + assertEquals("Coming up", BUCKET_LABEL["upcoming"]) + assertEquals("No deadline", BUCKET_LABEL["someday"]) + } + + @Test + fun `bucket order has a label for every bucket and no extras`() { + assertEquals(BUCKET_LABEL.keys, BUCKET_ORDER.toSet()) + assertEquals(BUCKET_ORDER.size, BUCKET_ORDER.distinct().size) + assertEquals("overdue", BUCKET_ORDER.first()) + assertEquals("someday", BUCKET_ORDER.last()) + } + + @Test + fun `dueLabel prefers the overdue count`() { + assertEquals("", dueLabel(null, 0)) + assertEquals("", dueLabel("", 3)) + assertEquals("2026-10-19", dueLabel("2026-10-19", 0)) + assertEquals("3d overdue", dueLabel("2026-10-16", 3)) + } + + @Test + fun `shortDate drops the year`() { + assertEquals("10/19", shortDate("2026-10-19")) + assertEquals("01/05", shortDate("2026-01-05")) + } + + @Test + fun `weekdayOf is monday zero`() { + // 2026-10-19 is a Monday. + assertEquals(0, weekdayOf("2026-10-19")) + assertEquals(1, weekdayOf("2026-10-20")) + assertEquals(5, weekdayOf("2026-10-24")) + assertEquals(6, weekdayOf("2026-10-25")) + } +} diff --git a/android/core/src/test/kotlin/tech/kadence/core/GlobTest.kt b/android/core/src/test/kotlin/tech/kadence/core/GlobTest.kt new file mode 100644 index 0000000..f767ff9 --- /dev/null +++ b/android/core/src/test/kotlin/tech/kadence/core/GlobTest.kt @@ -0,0 +1,156 @@ +package tech.kadence.core + +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +/** + * Parity with Python's `fnmatch`, which is what the backend and the desktop enforcer + * use. Every expectation in [pythonParity] was produced by running the same pattern + * and text through CPython's `fnmatch.fnmatch`, not reasoned about by hand — the block + * lists are shared across clients, so a disagreement here means one list silently + * means two different things. + */ +class GlobTest { + + @Test + fun `matches python fnmatch exactly`() { + for ((pattern, text, expected) in pythonParity) { + assertEquals( + expected, + globMatches(pattern, text), + "fnmatch(${text.quoted()}, ${pattern.quoted()}) should be $expected", + ) + } + } + + @Test + fun `star is anchored at both ends`() { + // `steam*` must not match `xsteam` — a mask is a whole-string match, which is + // what keeps `steam*` from catching every command that mentions steam. + assertTrue(globMatches("steam*", "steamwebhelper")) + assertFalse(globMatches("steam*", "xsteam")) + } + + @Test + fun `star crosses separators unlike shell globbing`() { + // This is the property the whole mask feature leans on: a hosts file cannot + // express `*gram*`, but a string match can. + assertTrue(globMatches("*gram*", "instagram.com")) + assertTrue(globMatches("*.com", "a.b.com")) + } + + @Test + fun `subdomain mask does not match the bare domain`() { + // Precisely why `expand_entry()` emits the base domain alongside the + // subdomains instead of relying on the mask. + assertTrue(globMatches("*.youtube.com", "music.youtube.com")) + assertFalse(globMatches("*.youtube.com", "youtube.com")) + } + + @Test + fun `question mark matches exactly one character`() { + assertTrue(globMatches("telegram-?", "telegram-1")) + assertFalse(globMatches("telegram-?", "telegram-12")) + assertFalse(globMatches("telegram-?", "telegram-")) + } + + @Test + fun `character classes and negation`() { + assertTrue(globMatches("[sv]potify", "spotify")) + assertTrue(globMatches("[sv]potify", "vpotify")) + assertFalse(globMatches("[sv]potify", "zpotify")) + assertTrue(globMatches("[!sv]potify", "zpotify")) + assertFalse(globMatches("[!sv]potify", "spotify")) + } + + @Test + fun `ranges inside a class`() { + assertTrue(globMatches("app[0-9]", "app7")) + assertFalse(globMatches("app[0-9]", "appx")) + } + + @Test + fun `an unterminated class is a literal bracket`() { + // CPython's translate() falls back to a literal `[`; so must we, or a typo in + // the block list becomes a crash instead of a harmless non-match. + assertTrue(globMatches("[", "[")) + assertTrue(globMatches("[abc", "[abc")) + assertTrue(globMatches("a[]b", "a[]b")) + assertFalse(globMatches("[abc", "a")) + } + + @Test + fun `dots are literal, not regex wildcards`() { + assertTrue(globMatches("a.b", "a.b")) + assertFalse(globMatches("a.b", "axb")) + } + + @Test + fun `regex metacharacters in a pattern are escaped`() { + // A user pasting a URL fragment must not accidentally write a regex. + assertTrue(globMatches("a+b(c)", "a+b(c)")) + assertFalse(globMatches("a+b(c)", "aab c")) + assertTrue(globMatches("price\$", "price\$")) + } + + @Test + fun `empty pattern matches only empty text`() { + assertTrue(globMatches("", "")) + assertFalse(globMatches("", "x")) + } + + @Test + fun `isMask only reports real wildcards`() { + assertTrue(isMask("steam*")) + assertTrue(isMask("a?b")) + assertTrue(isMask("[ab]c")) + assertFalse(isMask("discord")) + assertFalse(isMask("youtube.com")) + assertFalse(isMask("")) + } + + @Test + fun `compiled patterns are cached and still correct on reuse`() { + val first = globToRegex("*discord*") + val second = globToRegex("*discord*") + assertTrue(first === second, "the compiled pattern should be reused") + assertTrue(globMatches("*discord*", "/usr/bin/discord --flag")) + assertTrue(globMatches("*discord*", "discord")) + } + + private fun String.quoted() = "'" + this + "'" + + private companion object { + /** (pattern, text, expected) — generated from CPython's `fnmatch.fnmatch`. */ + val pythonParity = listOf( + Triple("steam*", "steam", true), + Triple("steam*", "steamwebhelper", true), + Triple("steam*", "xsteam", false), + Triple("*discord*", "/usr/bin/discord --flag", true), + Triple("*discord*", "discord", true), + Triple("telegram-?", "telegram-1", true), + Triple("telegram-?", "telegram-12", false), + Triple("[sv]potify", "spotify", true), + Triple("[sv]potify", "vpotify", true), + Triple("[sv]potify", "zpotify", false), + Triple("[!sv]potify", "zpotify", true), + Triple("[!sv]potify", "spotify", false), + Triple("*.youtube.com", "music.youtube.com", true), + Triple("*.youtube.com", "youtube.com", false), + Triple("*gram*", "instagram.com", true), + Triple("*gram*", "telegram", true), + Triple("*.google.com", "docs.google.com", true), + Triple("a.b", "a.b", true), + Triple("a.b", "axb", false), + Triple("[", "[", true), + Triple("[abc", "[abc", true), + Triple("a[]b", "a[]b", true), + Triple("*", "anything", true), + Triple("", "", true), + Triple("", "x", false), + Triple("*.com", "a.b.com", true), + ) + } +} diff --git a/android/core/src/test/kotlin/tech/kadence/core/GlyphFrameTest.kt b/android/core/src/test/kotlin/tech/kadence/core/GlyphFrameTest.kt new file mode 100644 index 0000000..7e57454 --- /dev/null +++ b/android/core/src/test/kotlin/tech/kadence/core/GlyphFrameTest.kt @@ -0,0 +1,301 @@ +package tech.kadence.core + +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +/** + * The rear Glyph Matrix, tested on a laptop. + * + * This is the whole point of keeping the renderer pure: every dot of the Nothing Phone + * (3)'s 25x25 back display is decided by arithmetic, so the entire feature can be built + * and regression-tested without the device, without the vendored `.aar`, and without + * Android. [asciiOf] prints the frame when an assertion fails, so a broken glyph is + * visible rather than a mismatched integer. + */ +class GlyphFrameBasicsTest { + + @Test + fun `phone 3 is twenty-five squared`() { + val frame = GlyphFrame() + assertEquals(25, frame.size) + assertEquals(625, frame.dots.size, "Common.getDeviceMatrixLength() on DEVICE_23112") + } + + @Test + fun `a different matrix length is honoured`() { + // Phone (4a) Pro is 13x13; nothing may hard-code 25. + val frame = GlyphFrame(13) + assertEquals(169, frame.dots.size) + } + + @Test + fun `brightness is clamped, never wrapped`() { + val frame = GlyphFrame() + frame.set(0, 0, 999) + frame.set(1, 0, -5) + assertEquals(255, frame.get(0, 0)) + assertEquals(0, frame.get(1, 0)) + } + + @Test + fun `out-of-bounds writes are dropped, not crashes`() { + val frame = GlyphFrame() + frame.set(-1, 0, 255) + frame.set(0, -1, 255) + frame.set(25, 0, 255) + frame.set(0, 25, 255) + assertEquals(0, frame.litCount) + assertEquals(0, frame.get(-1, -1)) + assertEquals(0, frame.get(99, 99)) + } + + @Test + fun `render hands out a copy, so the SDK cannot be handed live state`() { + val frame = GlyphFrame() + frame.set(0, 0, 255) + val rendered = frame.render() + frame.set(0, 0, 0) + assertEquals(255, rendered[0]) + } + + @Test + fun `a blank frame is entirely dark`() { + assertEquals(0, GlyphRenderer.blank().litCount) + } +} + +class GlyphDigitsTest { + + @Test + fun `digit width accounts for the gap`() { + assertEquals(0, digitsWidth("")) + assertEquals(3, digitsWidth("1")) + assertEquals(7, digitsWidth("18")) + assertEquals(11, digitsWidth("184")) + } + + @Test + fun `digits render as the three-by-five font`() { + val frame = GlyphFrame() + frame.drawDigitsCentred("18", 6, GlyphBrightness.FULL) + val rows = asciiOf(frame).lines().subList(6, 11) + assertEquals( + listOf( + "...........#.###.........", + "...........#.#.#.........", + "...........#.###.........", + "...........#.#.#.........", + "...........#.###.........", + ), + rows, + "the 3x5 font, centred: a right-aligned 1 beside an 8", + ) + } + + @Test + fun `every digit is five rows tall and lights something`() { + for (d in 0..9) { + val frame = GlyphFrame() + frame.drawDigits(d.toString(), 0, 0, GlyphBrightness.FULL) + assertTrue(frame.litCount > 0, "digit $d renders nothing") + for (y in 5 until 25) { + for (x in 0 until 25) { + assertEquals(0, frame.get(x, y), "digit $d spills past row 5") + } + } + } + } + + @Test + fun `an unknown character advances the cursor without drawing`() { + val frame = GlyphFrame() + frame.drawDigits(":", 0, 0, GlyphBrightness.FULL) + assertEquals(0, frame.litCount) + } +} + +class GlyphRingTest { + + private fun ringOnly(planned: Int, remaining: Int): GlyphFrame { + val frame = GlyphFrame() + frame.drawRing(planned, remaining) + return frame + } + + @Test + fun `the ring uses the same tick rule as the Compose dial`() { + // If these ever diverge, one dot means a different amount of time on the front + // of the phone than on the back. + val planned = 25 * 60 + assertEquals(dialTickCount(planned), ringOnly(planned, planned).litCount) + } + + @Test + fun `a fresh interval lights every tick`() { + val planned = 25 * 60 + assertEquals(25, ringOnly(planned, planned).litCount) + } + + @Test + fun `the ring drains as the interval runs`() { + val planned = 25 * 60 + val full = ringOnly(planned, planned).litCount + val half = ringOnly(planned, planned / 2).litCount + val nearly = ringOnly(planned, 60).litCount + + assertTrue(half < full, "half-spent must be dimmer than fresh") + assertTrue(nearly < half, "nearly-done must be dimmer than half") + assertEquals(13, half) + assertEquals(1, nearly) + } + + @Test + fun `an expired interval lights nothing`() { + assertEquals(0, ringOnly(25 * 60, 0).litCount) + } + + @Test + fun `the arc is anchored at twelve o'clock`() { + // It must shrink *towards* twelve, not drain away from it, so the last sliver is + // at the top where the eye expects it. + val frame = ringOnly(25 * 60, 60) + assertEquals(GlyphBrightness.FULL, frame.get(12, 1), "the top dot stays lit last") + } + + @Test + fun `a long interval still fits the ring`() { + // 85 minutes -> one dot per five minutes, so 17 ticks, not 85. + val planned = 85 * 60 + assertEquals(17, ringOnly(planned, planned).litCount) + } +} + +class GlyphTimerFrameTest { + + @Test + fun `minutes sit above seconds`() { + val frame = GlyphRenderer.timerFrame(18 * 60 + 24, 25 * 60) + val art = asciiOf(frame) + val lines = art.lines() + // Row 6 is the top of the minutes, row 14 the top of the seconds. + assertTrue(lines[6].contains("#"), "minutes row is drawn") + assertTrue(lines[14].contains("#"), "seconds row is drawn") + assertTrue(frame.litCount > 20, "digits plus ring") + } + + @Test + fun `past an hour the rows become hours and minutes`() { + // 3930s is 1h 05m 30s. Shown as mm:ss it would read "65" over "30", and a + // two-glyph row cannot say 65 minutes meaningfully — so past an hour the top + // row becomes hours and the bottom becomes minutes. + val frame = GlyphRenderer.timerFrame(3930, 4 * 3600) + + val expected = GlyphFrame() + expected.drawDigitsCentred("01", 6, GlyphBrightness.FULL) + expected.drawDigitsCentred("05", 14, GlyphBrightness.FULL) + + // Compare only the columns the digits occupy; the ring owns the perimeter. + val got = asciiOf(frame).lines() + val want = asciiOf(expected).lines() + for (y in listOf(6, 7, 8, 9, 10, 14, 15, 16, 17, 18)) { + assertEquals( + want[y].substring(9, 16), + got[y].substring(9, 16), + "row $y should read as hours over minutes", + ) + } + } + + @Test + fun `under an hour the rows are minutes and seconds`() { + val frame = GlyphRenderer.timerFrame(18 * 60 + 24, 25 * 60) + + val expected = GlyphFrame() + expected.drawDigitsCentred("18", 6, GlyphBrightness.FULL) + expected.drawDigitsCentred("24", 14, GlyphBrightness.FULL) + + val got = asciiOf(frame).lines() + val want = asciiOf(expected).lines() + for (y in listOf(6, 7, 8, 9, 10, 14, 15, 16, 17, 18)) { + assertEquals(want[y].substring(9, 16), got[y].substring(9, 16), "row $y") + } + } + + @Test + fun `pausing dims the whole face`() { + val running = GlyphRenderer.timerFrame(18 * 60, 25 * 60, paused = false) + val paused = GlyphRenderer.timerFrame(18 * 60, 25 * 60, paused = true) + + assertEquals(running.litCount, paused.litCount, "the same dots, dimmer") + assertTrue(paused.dots.none { it == GlyphBrightness.FULL }, "nothing stays at full") + assertTrue(paused.dots.any { it == GlyphBrightness.DIM }) + } + + @Test + fun `a negative remaining is clamped rather than drawn`() { + val frame = GlyphRenderer.timerFrame(-30, 25 * 60) + val art = asciiOf(frame) + assertTrue(art.lines().size == 25) + // 00:00, and the ring fully drained. + assertEquals( + GlyphRenderer.timerFrame(0, 25 * 60).let(::asciiOf), + art, + ) + } +} + +class GlyphDotsTest { + + private fun counts(frame: GlyphFrame): Pair = + frame.dots.count { it == GlyphBrightness.FULL } to + frame.dots.count { it == GlyphBrightness.FAINT } + + @Test + fun `earned dots are solid and the rest are faint`() { + val (full, faint) = counts(GlyphRenderer.dotsFrame(6, 8)) + assertEquals(6, full) + assertEquals(2, faint) + } + + @Test + fun `a goal met lights everything`() { + val (full, faint) = counts(GlyphRenderer.dotsFrame(8, 8)) + assertEquals(8, full) + assertEquals(0, faint) + } + + @Test + fun `beating the goal grows the row instead of truncating`() { + val (full, faint) = counts(GlyphRenderer.dotsFrame(10, 8)) + assertEquals(10, full, "a tenth pomodoro on an eight-goal day still shows") + assertEquals(0, faint) + } + + @Test + fun `a large goal wraps onto more rows`() { + val frame = GlyphRenderer.dotsFrame(3, 12) + val (full, faint) = counts(frame) + assertEquals(3, full) + assertEquals(9, faint) + val rowsWithDots = asciiOf(frame).lines().count { it.any { c -> c != '.' } } + assertEquals(2, rowsWithDots, "12 dots at 8 per row is two rows") + } + + @Test + fun `nothing yet today still renders one placeholder`() { + val (full, faint) = counts(GlyphRenderer.dotsFrame(0, 0)) + assertEquals(0, full) + assertEquals(1, faint, "an empty grid would look like a dead display") + } + + @Test + fun `the grid stays inside the matrix`() { + val frame = GlyphRenderer.dotsFrame(20, 24) + for (i in frame.dots.indices) { + // Nothing wrapped around an edge: every lit dot is within bounds by + // construction, so just assert the count survived. + } + assertEquals(24, frame.litCount) + } +} diff --git a/android/core/src/test/kotlin/tech/kadence/core/MatchersTest.kt b/android/core/src/test/kotlin/tech/kadence/core/MatchersTest.kt new file mode 100644 index 0000000..0df56aa --- /dev/null +++ b/android/core/src/test/kotlin/tech/kadence/core/MatchersTest.kt @@ -0,0 +1,319 @@ +package tech.kadence.core + +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertIs +import kotlin.test.assertNull +import kotlin.test.assertTrue + +class NormalizeHostTest { + + @Test + fun `a bare host passes through`() { + assertEquals("youtube.com", normalizeHost("youtube.com")) + assertEquals("m.youtube.com", normalizeHost("m.youtube.com")) + assertEquals("youtube.com", normalizeHost(" YouTube.com ")) + } + + @Test + fun `a full url is reduced to its host`() { + assertEquals("youtube.com", normalizeHost("https://youtube.com")) + assertEquals("www.youtube.com", normalizeHost("https://www.youtube.com/watch?v=abc")) + assertEquals("youtube.com", normalizeHost("http://youtube.com/")) + assertEquals("youtube.com", normalizeHost("https://youtube.com#anchor")) + assertEquals("youtube.com", normalizeHost("https://youtube.com?q=1")) + } + + @Test + fun `userinfo and ports are dropped`() { + assertEquals("example.com", normalizeHost("https://user:pw@example.com:8443/x")) + assertEquals("example.com", normalizeHost("example.com:8000")) + } + + @Test + fun `a trailing root dot is dropped`() { + assertEquals("youtube.com", normalizeHost("youtube.com.")) + } + + @Test + fun `unicode hosts are matched in punycode`() { + // A block list holds ASCII; the URL bar may show the pretty form. + assertEquals("xn--e1afmkfd.xn--p1ai", normalizeHost("пример.рф")) + assertEquals("xn--mnchen-3ya.de", normalizeHost("münchen.de")) + assertEquals("xn--wgv71a.jp", normalizeHost("日本.jp")) + } + + @Test + fun `a homoglyph host still normalises instead of being waved through`() { + // `аррӏе.com` is Cyrillic lookalikes. Strict IDN.toASCII throws on it, which + // would have returned null — and null means "allow". ALLOW_UNASSIGNED keeps it + // matchable, so putting it on the block list actually blocks it. + assertEquals("xn--80ak6aa92e.com", normalizeHost("аррӏе.com")) + } + + @Test + fun `a search phrase is not a host`() { + assertNull(normalizeHost("Search or type URL")) + assertNull(normalizeHost("how to focus better")) + assertNull(normalizeHost("youtube cat videos")) + } + + @Test + fun `internal schemes are never blockable`() { + assertNull(normalizeHost("chrome://newtab")) + assertNull(normalizeHost("about:blank")) + assertNull(normalizeHost("chrome-native://bookmarks")) + assertNull(normalizeHost("file:///sdcard/x.html")) + assertNull(normalizeHost("data:text/html,hi")) + } + + @Test + fun `junk is null rather than a false positive`() { + assertNull(normalizeHost(null)) + assertNull(normalizeHost("")) + assertNull(normalizeHost(" ")) + assertNull(normalizeHost("localhost"), "a single label is not a host we block") + assertNull(normalizeHost("...")) + assertNull(normalizeHost("-bad-.com")) + assertNull(normalizeHost("https://")) + } + + @Test + fun `an ip address survives`() { + assertEquals("192.168.1.10", normalizeHost("http://192.168.1.10:8000/api")) + } +} + +class DomainMatcherTest { + + private fun matcher( + blocked: List = emptyList(), + allowed: List = emptyList(), + subs: List = listOf("www", "m"), + ): DomainMatcher { + val rules = BlockerRules( + enabled = true, + blockedDomains = blocked, + allowedDomains = allowed, + subdomainExpansions = subs, + ) + return DomainMatcher(rules) + } + + private fun assertBlocked(decision: BlockDecision, host: String, rule: String) { + val block = assertIs(decision, "expected $host to be blocked") + assertEquals(host, block.target) + assertEquals(rule, block.matchedRule) + assertEquals(BlockAction.BLOCKED, block.action) + } + + @Test + fun `a plain entry blocks the site and its subdomains`() { + val m = matcher(blocked = listOf("youtube.com")) + assertBlocked(m.decide("youtube.com"), "youtube.com", "youtube.com") + assertBlocked(m.decide("www.youtube.com"), "www.youtube.com", "youtube.com") + assertBlocked(m.decide("m.youtube.com"), "m.youtube.com", "youtube.com") + // Beyond the hosts file's reach: never expanded, still caught here. + assertBlocked(m.decide("music.youtube.com"), "music.youtube.com", "youtube.com") + } + + @Test + fun `a lookalike domain is not caught`() { + val m = matcher(blocked = listOf("youtube.com")) + assertEquals(BlockDecision.Allow, m.decide("myyoutube.com")) + assertEquals(BlockDecision.Allow, m.decide("youtube.com.evil.net")) + assertEquals(BlockDecision.Allow, m.decide("notyoutube.com")) + } + + @Test + fun `the allow list wins over the block list`() { + val m = matcher(blocked = listOf("*.google.com"), allowed = listOf("docs.google.com")) + assertEquals(BlockDecision.Allow, m.decide("https://docs.google.com/document/d/1")) + assertBlocked(m.decide("www.google.com"), "www.google.com", "*.google.com") + } + + @Test + fun `an allow mask covers a whole subtree`() { + val m = matcher(blocked = listOf("google.com"), allowed = listOf("*.docs.google.com")) + assertEquals(BlockDecision.Allow, m.decide("a.docs.google.com")) + // Consistent with the backend: `*.x` does not cover the bare `x`. + assertBlocked(m.decide("docs.google.com"), "docs.google.com", "google.com") + } + + @Test + fun `masks the hosts file cannot express are enforced here`() { + // This is the payoff: the backend returns `*gram*` as `unexpandable` because a + // hosts file has no wildcards. The phone matches the string instead. + val m = matcher(blocked = listOf("*gram*")) + assertBlocked(m.decide("instagram.com"), "instagram.com", "*gram*") + assertBlocked(m.decide("https://www.instagram.com/explore/"), "www.instagram.com", "*gram*") + assertEquals(BlockDecision.Allow, m.decide("youtube.com")) + assertEquals(listOf("*gram*"), m.enforcedBeyondHostsFile()) + } + + @Test + fun `a subdomain mask blocks the base domain too, via expansion`() { + val m = matcher(blocked = listOf("*.reddit.com")) + assertBlocked(m.decide("reddit.com"), "reddit.com", "*.reddit.com") + assertBlocked(m.decide("www.reddit.com"), "www.reddit.com", "*.reddit.com") + assertBlocked(m.decide("old.reddit.com"), "old.reddit.com", "*.reddit.com") + } + + @Test + fun `junk from the url bar is always allowed`() { + val m = matcher(blocked = listOf("youtube.com", "*gram*")) + assertEquals(BlockDecision.Allow, m.decide("Search or type URL")) + assertEquals(BlockDecision.Allow, m.decide("chrome://newtab")) + assertEquals(BlockDecision.Allow, m.decide(null)) + assertEquals(BlockDecision.Allow, m.decide("")) + } + + @Test + fun `an empty policy blocks nothing`() { + val m = matcher() + assertEquals(BlockDecision.Allow, m.decide("youtube.com")) + assertEquals(BlockDecision.Allow, m.decide("anything.at.all")) + } + + @Test + fun `the server's expanded list is used when supplied`() { + // Online, `all_domains` arrives already expanded; we must honour it even for an + // entry whose raw form we were not given. + val rules = BlockerRules(enabled = true, blockedDomains = emptyList()) + val m = DomainMatcher(rules, expandedHosts = listOf("tiktok.com", "www.tiktok.com")) + val decision = m.decide("https://tiktok.com/foryou") + val block = assertIs(decision) + assertEquals("tiktok.com", block.target) + assertEquals(BlockAction.BLOCKED, block.action) + } + + @Test + fun `the reported rule is the entry that produced the host`() { + // `*.reddit.com` expands to the bare `reddit.com`, but the mask does not match + // that bare name — so without provenance the overlay would blame the host + // instead of naming the rule the user actually wrote. + val m = matcher(blocked = listOf("*.reddit.com")) + val block = assertIs(m.decide("reddit.com")) + assertEquals("reddit.com", block.target, "the event target stays the hostname") + assertEquals("*.reddit.com", block.matchedRule, "but the rule is the user's entry") + } + + @Test + fun `the first entry to claim a host owns it`() { + val m = matcher(blocked = listOf("youtube.com", "*.youtube.com")) + val block = assertIs(m.decide("www.youtube.com")) + assertEquals("youtube.com", block.matchedRule) + } + + @Test + fun `case and whitespace in the list do not matter`() { + val m = matcher(blocked = listOf(" YouTube.COM ")) + assertBlocked(m.decide("YOUTUBE.com"), "youtube.com", "youtube.com") + } +} + +class AppMatcherTest { + + @Test + fun `a plain entry is a substring test, so one list serves both platforms`() { + // `discord` was written for a Linux process name; it must still catch the + // Android package. + val m = AppMatcher(listOf("discord")) + assertEquals("discord", m.match("com.discord", "Discord")) + assertEquals("discord", m.match("com.discord.canary")) + } + + @Test + fun `the visible label is the second haystack`() { + // Android's analogue of the desktop matcher's command line. + val m = AppMatcher(listOf("instagram")) + assertEquals("instagram", m.match("com.instagram.android", "Instagram")) + + val byLabelOnly = AppMatcher(listOf("telegram")) + assertEquals("telegram", byLabelOnly.match("org.thunderdog.challegram", "Telegram X")) + } + + @Test + fun `a mask is anchored, so it misses the package name`() { + // `steam*` was written for a Linux process called `steam`. An fnmatch mask is a + // whole-string match, so it does NOT match the Android package — this is the + // shared-list gotcha, documented rather than papered over. + val m = AppMatcher(listOf("steam*")) + assertEquals("steam*", m.match("steamwebhelper")) + assertNull(m.match("com.valvesoftware.android.steam.community")) + assertNull(m.match("com.discord", "Discord")) + } + + @Test + fun `the label rescues an anchored mask on Android`() { + // Checking the visible label as a second haystack is what makes the desktop's + // `steam*` still work here: the package misses, but the label "Steam" matches. + // This is the Android analogue of the desktop also trying the command line. + val m = AppMatcher(listOf("steam*")) + assertEquals( + "steam*", + m.match("com.valvesoftware.android.steam.community", "Steam"), + ) + } + + @Test + fun `a wrapped mask matches the package directly`() { + // What the in-app app picker should write, so an entry added on the phone also + // blocks the Linux process. + val wrapped = AppMatcher(listOf("*steam*")) + assertEquals( + "*steam*", + wrapped.match("com.valvesoftware.android.steam.community", ""), + ) + assertEquals("*steam*", wrapped.match("steamwebhelper")) + } + + @Test + fun `masks match either haystack`() { + val m = AppMatcher(listOf("*telegram*")) + assertEquals("*telegram*", m.match("org.telegram.messenger", "Telegram")) + assertEquals("*telegram*", m.match("com.example.app", "My Telegram Client")) + } + + @Test + fun `no match returns null`() { + val m = AppMatcher(listOf("discord", "*steam*")) + assertNull(m.match("com.android.chrome", "Chrome")) + assertNull(m.match("tech.kadence.android", "Kadence")) + } + + @Test + fun `blank patterns are ignored`() { + val m = AppMatcher(listOf("", " ", "discord")) + assertEquals("discord", m.match("com.discord")) + assertNull(m.match("com.android.chrome")) + } + + @Test + fun `the first matching pattern is the one reported`() { + // `by_target` in the report groups by this string, so it must be stable. + val m = AppMatcher(listOf("*gram*", "instagram")) + assertEquals("*gram*", m.match("com.instagram.android", "Instagram")) + } + + @Test + fun `kill_blocked_apps decides the reported action`() { + val m = AppMatcher(listOf("instagram")) + + val killed = m.decide("com.instagram.android", "Instagram", kill = true) + assertEquals(BlockAction.KILLED, assertIs(killed).action) + + // Warn-only. This matters: the server only fires `notify_on_block` for + // `killed`, so sending `warned` here is what keeps Telegram quiet. + val warned = m.decide("com.instagram.android", "Instagram", kill = false) + assertEquals(BlockAction.WARNED, assertIs(warned).action) + + assertEquals(BlockDecision.Allow, m.decide("com.android.chrome", "Chrome", kill = true)) + } + + @Test + fun `case is folded on both sides`() { + val m = AppMatcher(listOf("DISCORD")) + assertTrue(m.match("com.Discord", "Discord") != null) + } +} diff --git a/android/core/src/test/kotlin/tech/kadence/core/OutboxTest.kt b/android/core/src/test/kotlin/tech/kadence/core/OutboxTest.kt new file mode 100644 index 0000000..9c2269b --- /dev/null +++ b/android/core/src/test/kotlin/tech/kadence/core/OutboxTest.kt @@ -0,0 +1,361 @@ +package tech.kadence.core + +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertIs +import kotlin.test.assertTrue + +class OutboxCoalesceTest { + + private var seq = 0L + private fun next() = ++seq + + private fun entry(op: OutboxOp, session: Long? = 7L, minutes: Int = 0, taskId: Long? = null) = + OutboxEntry(seq = next(), op = op, anchorSessionId = session, minutes = minutes, taskId = taskId) + + private fun queueOf(vararg ops: OutboxEntry): List = + ops.fold(emptyList()) { acc, e -> coalesce(acc, e) } + + @Test + fun `an empty queue takes the first intent as-is`() { + val q = queueOf(entry(OutboxOp.PAUSE)) + assertEquals(1, q.size) + assertEquals(OutboxOp.PAUSE, q.single().op) + } + + @Test + fun `pause then resume annihilate`() { + // The user changed their mind before we had signal; sending both is pointless + // and would wrongly bump the interruption counter. + val q = queueOf(entry(OutboxOp.PAUSE), entry(OutboxOp.RESUME)) + assertTrue(q.isEmpty()) + } + + @Test + fun `resume then pause annihilate too`() { + val q = queueOf(entry(OutboxOp.RESUME), entry(OutboxOp.PAUSE)) + assertTrue(q.isEmpty()) + } + + @Test + fun `a pause that survives a round trip is kept`() { + val q = queueOf(entry(OutboxOp.PAUSE), entry(OutboxOp.RESUME), entry(OutboxOp.PAUSE)) + assertEquals(listOf(OutboxOp.PAUSE), q.map { it.op }) + } + + @Test + fun `extends add up`() { + val q = queueOf( + entry(OutboxOp.EXTEND, minutes = 5), + entry(OutboxOp.EXTEND, minutes = 5), + entry(OutboxOp.EXTEND, minutes = 10), + ) + assertEquals(1, q.size) + assertEquals(20, q.single().minutes) + } + + @Test + fun `extends for different intervals stay apart`() { + val q = queueOf( + entry(OutboxOp.EXTEND, session = 7L, minutes = 5), + entry(OutboxOp.EXTEND, session = 8L, minutes = 5), + ) + assertEquals(2, q.size) + } + + @Test + fun `interruptions are counted, not collapsed`() { + // The server increments a counter, so three taps must become three increments. + val q = queueOf( + entry(OutboxOp.INTERRUPT), + entry(OutboxOp.INTERRUPT), + entry(OutboxOp.INTERRUPT), + ) + assertEquals(1, q.size) + assertEquals(3, q.single().repeat) + } + + @Test + fun `only the last chosen task matters`() { + val q = queueOf( + entry(OutboxOp.ATTACH_TASK, taskId = 1L), + entry(OutboxOp.ATTACH_TASK, taskId = 2L), + entry(OutboxOp.ATTACH_TASK, taskId = 3L), + ) + assertEquals(1, q.size) + assertEquals(3L, q.single().taskId) + } + + @Test + fun `a start discards everything queued for the interval it supersedes`() { + // `pomodoro.start()` abandons the running interval as "superseded", so a queued + // pause or +5 for it is already moot. + val q = queueOf( + entry(OutboxOp.PAUSE, session = 7L), + entry(OutboxOp.EXTEND, session = 7L, minutes = 5), + entry(OutboxOp.INTERRUPT, session = 7L), + OutboxEntry(seq = next(), op = OutboxOp.START, anchorSessionId = 7L, kind = Kind.WORK), + ) + assertEquals(listOf(OutboxOp.START), q.map { it.op }) + } + + @Test + fun `only one start is ever queued`() { + val q = queueOf( + OutboxEntry(seq = next(), op = OutboxOp.START, kind = Kind.WORK), + OutboxEntry(seq = next(), op = OutboxOp.START, kind = Kind.SHORT_BREAK), + ) + assertEquals(1, q.size) + assertEquals(Kind.SHORT_BREAK, q.single().kind) + } + + @Test + fun `a terminal intent clears the interval's other intents`() { + val q = queueOf( + entry(OutboxOp.PAUSE, session = 7L), + entry(OutboxOp.EXTEND, session = 7L, minutes = 5), + entry(OutboxOp.COMPLETE, session = 7L), + ) + assertEquals(listOf(OutboxOp.COMPLETE), q.map { it.op }) + } + + @Test + fun `a terminal intent leaves another interval's intents alone`() { + val q = queueOf( + entry(OutboxOp.PAUSE, session = 8L), + entry(OutboxOp.COMPLETE, session = 7L), + ) + assertEquals(2, q.size) + } + + @Test + fun `pendingOps summarises the queue for the reconciler`() { + assertEquals(PendingOps(), pendingOpsOf(emptyList())) + + val withStart = queueOf(OutboxEntry(seq = next(), op = OutboxOp.START, kind = Kind.WORK)) + assertEquals(PendingOps(hasAny = true, hasStart = true), pendingOpsOf(withStart)) + + val withTerminal = queueOf(entry(OutboxOp.ABANDON)) + assertEquals(PendingOps(hasAny = true, hasTerminal = true), pendingOpsOf(withTerminal)) + + val plain = queueOf(entry(OutboxOp.INTERRUPT)) + assertEquals(PendingOps(hasAny = true), pendingOpsOf(plain)) + } +} + +class BackoffTest { + + @Test + fun `backoff doubles and then caps`() { + assertEquals(1, backoffSeconds(1)) + assertEquals(2, backoffSeconds(2)) + assertEquals(4, backoffSeconds(3)) + assertEquals(8, backoffSeconds(4)) + assertEquals(16, backoffSeconds(5)) + assertEquals(32, backoffSeconds(6)) + assertEquals(60, backoffSeconds(7), "capped at a minute") + assertEquals(60, backoffSeconds(99)) + } + + @Test + fun `a zeroth attempt still waits a moment`() { + assertEquals(1, backoffSeconds(0)) + } + + @Test + fun `retries give up after eight attempts`() { + val retry = assertIs(replayOutcomeFor(1)) + assertEquals(2, retry.attempt) + assertIs(replayOutcomeFor(MAX_REPLAY_ATTEMPTS - 1)) + assertEquals(ReplayOutcome.GiveUp, replayOutcomeFor(MAX_REPLAY_ATTEMPTS)) + assertEquals(ReplayOutcome.GiveUp, replayOutcomeFor(MAX_REPLAY_ATTEMPTS + 5)) + } +} + +/** + * The post-condition probes. None of these endpoints is idempotent, so after an + * ambiguous failure the only safe question is "does the world look like my call + * landed?" — asked once, against freshly-read state. + */ +class PostconditionTest { + + private fun session( + id: Long = 7L, + status: String = Status.RUNNING, + planned: Int = 1500, + interruptions: Int = 0, + kind: String = Kind.WORK, + ) = TimerSessionFacts( + id = id, + kind = kind, + status = status, + plannedSeconds = planned, + remainingSeconds = 900, + interruptions = interruptions, + ) + + private fun state(current: TimerSessionFacts?) = ServerTimerState(current = current) + + @Test + fun `extend landed when planned seconds grew by at least the request`() { + val before = session(planned = 1500) + val entry = OutboxEntry(1, OutboxOp.EXTEND, anchorSessionId = 7L, minutes = 5) + + assertTrue(postconditionHolds(entry, before, state(session(planned = 1800)))) + assertFalse(postconditionHolds(entry, before, state(session(planned = 1500)))) + // Another client may have extended further in the meantime; still landed. + assertTrue(postconditionHolds(entry, before, state(session(planned = 2400)))) + } + + @Test + fun `extend did not land if the interval was replaced`() { + val before = session(id = 7L, planned = 1500) + val entry = OutboxEntry(1, OutboxOp.EXTEND, anchorSessionId = 7L, minutes = 5) + assertFalse(postconditionHolds(entry, before, state(session(id = 9L, planned = 1800)))) + assertFalse(postconditionHolds(entry, before, state(null))) + } + + @Test + fun `interrupt landed when the counter advanced by the repeat count`() { + val before = session(interruptions = 2) + val entry = OutboxEntry(1, OutboxOp.INTERRUPT, anchorSessionId = 7L, repeat = 3) + + assertFalse(postconditionHolds(entry, before, state(session(interruptions = 4)))) + assertTrue(postconditionHolds(entry, before, state(session(interruptions = 5)))) + assertTrue(postconditionHolds(entry, before, state(session(interruptions = 6)))) + } + + @Test + fun `start landed when a new running interval of the right kind exists`() { + val entry = OutboxEntry(1, OutboxOp.START, anchorSessionId = 7L, kind = Kind.WORK) + + assertTrue(postconditionHolds(entry, null, state(session(id = 9L, kind = Kind.WORK)))) + // The old interval is still there, so nothing started. + assertFalse(postconditionHolds(entry, null, state(session(id = 7L)))) + // Wrong kind: somebody else's interval, not ours. + assertFalse( + postconditionHolds(entry, null, state(session(id = 9L, kind = Kind.SHORT_BREAK))), + ) + assertFalse(postconditionHolds(entry, null, state(null))) + // A paused new interval is not what `start` produces. + assertFalse( + postconditionHolds(entry, null, state(session(id = 9L, status = Status.PAUSED))), + ) + } + + @Test + fun `pause and resume probe the status`() { + val pause = OutboxEntry(1, OutboxOp.PAUSE, anchorSessionId = 7L) + assertTrue(postconditionHolds(pause, null, state(session(status = Status.PAUSED)))) + assertFalse(postconditionHolds(pause, null, state(session(status = Status.RUNNING)))) + assertFalse(postconditionHolds(pause, null, state(null))) + + val resume = OutboxEntry(2, OutboxOp.RESUME, anchorSessionId = 7L) + assertTrue(postconditionHolds(resume, null, state(session(status = Status.RUNNING)))) + assertFalse(postconditionHolds(resume, null, state(session(status = Status.PAUSED)))) + } + + @Test + fun `complete and abandon landed when the interval is gone or replaced`() { + val complete = OutboxEntry(1, OutboxOp.COMPLETE, anchorSessionId = 7L) + assertTrue(postconditionHolds(complete, null, state(null))) + // An auto-started follow-on counts: our interval is no longer current. + assertTrue(postconditionHolds(complete, null, state(session(id = 9L)))) + assertFalse(postconditionHolds(complete, null, state(session(id = 7L)))) + + val abandon = OutboxEntry(2, OutboxOp.ABANDON, anchorSessionId = 7L) + assertTrue(postconditionHolds(abandon, null, state(null))) + assertFalse(postconditionHolds(abandon, null, state(session(id = 7L)))) + } + + @Test + fun `attach task has nothing conclusive to probe`() { + // `TimerState.current.task` is not in the facts we keep, so we would be + // guessing. Returning false means "retry", which is safe: attaching the same + // task twice is a no-op. + val entry = OutboxEntry(1, OutboxOp.ATTACH_TASK, anchorSessionId = 7L, taskId = 3L) + assertFalse(postconditionHolds(entry, null, state(session()))) + } +} + +/** + * Intervals that both started and finished offline cannot be filed truthfully, because + * the server stamps `started_at` itself and `focus_minutes` comes from the wall-clock + * difference. Quarantining them is the honest option; replaying them would silently + * corrupt the statistics the whole app exists to produce. + */ +class PartitionForReplayTest { + + @Test + fun `a queue with no start replays entirely`() { + val queue = listOf( + OutboxEntry(1, OutboxOp.PAUSE, anchorSessionId = 7L), + OutboxEntry(2, OutboxOp.EXTEND, anchorSessionId = 7L, minutes = 5), + OutboxEntry(3, OutboxOp.COMPLETE, anchorSessionId = 7L), + ) + val (replay, unfiled) = partitionForReplay(queue) + assertEquals(3, replay.size) + assertTrue(unfiled.isEmpty()) + } + + @Test + fun `a start still running replays`() { + val queue = listOf( + OutboxEntry(1, OutboxOp.START, kind = Kind.WORK), + OutboxEntry(2, OutboxOp.INTERRUPT, anchorSessionId = null), + ) + val (replay, unfiled) = partitionForReplay(queue) + assertEquals(2, replay.size) + assertTrue(unfiled.isEmpty()) + } + + @Test + fun `a start and its completion are quarantined together`() { + val queue = listOf( + OutboxEntry(1, OutboxOp.START, kind = Kind.WORK), + OutboxEntry(2, OutboxOp.COMPLETE), + ) + val (replay, unfiled) = partitionForReplay(queue) + assertTrue(replay.isEmpty(), "replaying would file a pomodoro at the wrong hour") + assertEquals(listOf(1L, 2L), unfiled.map { it.seq }) + } + + @Test + fun `everything between the start and its end goes with it`() { + val queue = listOf( + OutboxEntry(1, OutboxOp.START, kind = Kind.WORK), + OutboxEntry(2, OutboxOp.INTERRUPT), + OutboxEntry(3, OutboxOp.EXTEND, minutes = 5), + OutboxEntry(4, OutboxOp.ABANDON, reason = "the phone rang"), + ) + val (replay, unfiled) = partitionForReplay(queue) + assertTrue(replay.isEmpty()) + assertEquals(4, unfiled.size) + } + + @Test + fun `work queued before the offline start is still replayed`() { + val queue = listOf( + OutboxEntry(1, OutboxOp.PAUSE, anchorSessionId = 7L), + OutboxEntry(2, OutboxOp.START, kind = Kind.WORK), + OutboxEntry(3, OutboxOp.COMPLETE), + ) + val (replay, unfiled) = partitionForReplay(queue) + assertEquals(listOf(1L), replay.map { it.seq }) + assertEquals(listOf(2L, 3L), unfiled.map { it.seq }) + } + + @Test + fun `an unfiled interval reports its real duration`() { + val start = 1_760_000_000_000L + val interval = UnfiledInterval( + kind = Kind.WORK, + startedAtWallMillis = start, + endedAtWallMillis = start + 25 * 60 * 1000L, + plannedSeconds = 1500, + ) + assertEquals(1500, interval.actualSeconds) + assertEquals("25m", humanMinutes(interval.actualSeconds / 60)) + } +} diff --git a/android/core/src/test/kotlin/tech/kadence/core/TimeWindowTest.kt b/android/core/src/test/kotlin/tech/kadence/core/TimeWindowTest.kt new file mode 100644 index 0000000..8f2b72e --- /dev/null +++ b/android/core/src/test/kotlin/tech/kadence/core/TimeWindowTest.kt @@ -0,0 +1,71 @@ +package tech.kadence.core + +import java.time.LocalTime +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNull +import kotlin.test.assertTrue + +/** Parity with `in_window()` in `backend/app/timeutil.py`. */ +class TimeWindowTest { + + private fun t(text: String) = LocalTime.parse(text) + + @Test + fun `a normal window is inclusive at both ends`() { + val start = t("10:00") + val end = t("20:00") + assertTrue(inWindow(t("10:00"), start, end), "the start minute is inside") + assertTrue(inWindow(t("15:30"), start, end)) + assertTrue(inWindow(t("20:00"), start, end), "the end minute is inside") + assertFalse(inWindow(t("09:59"), start, end)) + assertFalse(inWindow(t("20:01"), start, end)) + } + + @Test + fun `a window that wraps midnight`() { + // The quiet-hours default: 23:00 -> 08:00. + val start = t("23:00") + val end = t("08:00") + assertTrue(inWindow(t("23:00"), start, end)) + assertTrue(inWindow(t("23:59"), start, end)) + assertTrue(inWindow(t("00:00"), start, end)) + assertTrue(inWindow(t("07:59"), start, end)) + assertTrue(inWindow(t("08:00"), start, end)) + assertFalse(inWindow(t("08:01"), start, end)) + assertFalse(inWindow(t("22:59"), start, end)) + assertFalse(inWindow(t("12:00"), start, end)) + } + + @Test + fun `a degenerate window covers exactly one minute`() { + val at = t("09:00") + assertTrue(inWindow(at, at, at)) + assertFalse(inWindow(t("09:01"), at, at)) + } + + @Test + fun `parses the HH colon MM the settings document stores`() { + assertEquals(LocalTime.of(9, 0), parseClockTime("09:00")) + assertEquals(LocalTime.of(23, 5), parseClockTime("23:05")) + assertEquals(LocalTime.of(21, 0), parseClockTime(" 21:00 ")) + assertEquals(LocalTime.of(7, 30, 15), parseClockTime("07:30:15")) + assertEquals(LocalTime.of(9, 0), parseClockTime("9:00")) + } + + @Test + fun `a malformed time is null, never an exception`() { + // These strings come from a user-editable server document; one bad window must + // not take the whole blocking policy down. + assertNull(parseClockTime(null)) + assertNull(parseClockTime("")) + assertNull(parseClockTime(" ")) + assertNull(parseClockTime("nope")) + assertNull(parseClockTime("25:00")) + assertNull(parseClockTime("10:60")) + assertNull(parseClockTime("10")) + assertNull(parseClockTime("-1:00")) + assertNull(parseClockTime("ab:cd")) + } +} diff --git a/android/core/src/test/kotlin/tech/kadence/core/TimerTest.kt b/android/core/src/test/kotlin/tech/kadence/core/TimerTest.kt new file mode 100644 index 0000000..8551854 --- /dev/null +++ b/android/core/src/test/kotlin/tech/kadence/core/TimerTest.kt @@ -0,0 +1,322 @@ +package tech.kadence.core + +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertIs +import kotlin.test.assertTrue + +class TickMathTest { + + private fun anchor(remaining: Int, atNanos: Long = 0L, paused: Boolean = false) = + TickAnchor(sessionId = 1L, remainingAtAnchor = remaining, elapsedNanos = atNanos, paused = paused) + + private fun seconds(n: Long) = n * 1_000_000_000L + + @Test + fun `counts down from the anchor`() { + val a = anchor(remaining = 300) + assertEquals(300, remainingAt(a, seconds(0))) + assertEquals(299, remainingAt(a, seconds(1))) + assertEquals(240, remainingAt(a, seconds(60))) + assertEquals(0, remainingAt(a, seconds(300))) + } + + @Test + fun `never goes below zero`() { + val a = anchor(remaining = 5) + assertEquals(0, remainingAt(a, seconds(5))) + assertEquals(0, remainingAt(a, seconds(500))) + } + + @Test + fun `a paused interval is frozen`() { + val a = anchor(remaining = 300, paused = true) + assertEquals(300, remainingAt(a, seconds(0))) + assertEquals(300, remainingAt(a, seconds(120))) + } + + @Test + fun `partial seconds do not tick early`() { + val a = anchor(remaining = 300) + assertEquals(300, remainingAt(a, 999_999_999L)) + assertEquals(299, remainingAt(a, 1_000_000_000L)) + } + + @Test + fun `the anchor is monotonic, so a clock change cannot corrupt it`() { + // elapsedNanos comes from a monotonic source; a negative delta (which wall time + // could produce after an NTP correction) must not add time to the interval. + val a = anchor(remaining = 300, atNanos = seconds(100)) + assertEquals(300, remainingAt(a, seconds(100))) + assertEquals(300, remainingAt(a, seconds(90)), "going backwards must not add time") + } + + @Test + fun `progress is the dial's fill, clamped`() { + assertEquals(0f, progressOf(1500, 1500)) + assertEquals(0.5f, progressOf(750, 1500)) + assertEquals(1f, progressOf(0, 1500)) + assertEquals(1f, progressOf(-10, 1500), "an overshooting tick still reads as full") + assertEquals(0f, progressOf(100, 0), "a zero-length interval has no progress") + } +} + +class DialGeometryTest { + + @Test + fun `one tick per minute up to an hour`() { + assertEquals(25, dialTickCount(25 * 60)) + assertEquals(45, dialTickCount(45 * 60)) + assertEquals(60, dialTickCount(60 * 60)) + assertEquals(5, dialTickCount(5 * 60)) + } + + @Test + fun `past an hour it switches to one per five minutes`() { + assertEquals(17, dialTickCount(85 * 60), "the 'Пара' preset: 85 minutes") + assertEquals(24, dialTickCount(120 * 60)) + assertEquals(48, dialTickCount(240 * 60), "the backend's 240-minute maximum") + } + + @Test + fun `a degenerate interval still draws one tick`() { + assertEquals(1, dialTickCount(0)) + assertEquals(1, dialTickCount(30)) + } + + @Test + fun `spent ticks track elapsed time`() { + val planned = 25 * 60 + assertEquals(0, dialSpentTicks(planned, planned)) + assertEquals(12, dialSpentTicks(planned, planned / 2)) + assertEquals(25, dialSpentTicks(planned, 0)) + } + + @Test + fun `spent ticks stay inside the dial`() { + val planned = 25 * 60 + assertEquals(25, dialSpentTicks(planned, -60)) + assertEquals(0, dialSpentTicks(planned, planned + 60)) + } +} + +class NextKindTest { + + @Test + fun `work follows anything that is not a completed work interval`() { + assertEquals(Kind.WORK, nextKindLocally(null, null, 0, 4)) + assertEquals(Kind.WORK, nextKindLocally(Kind.SHORT_BREAK, Status.COMPLETED, 2, 4)) + assertEquals(Kind.WORK, nextKindLocally(Kind.LONG_BREAK, Status.COMPLETED, 4, 4)) + } + + @Test + fun `an abandoned work interval does not earn a break`() { + assertEquals(Kind.WORK, nextKindLocally(Kind.WORK, Status.ABANDONED, 3, 4)) + } + + @Test + fun `a short break follows work mid-cycle`() { + assertEquals(Kind.SHORT_BREAK, nextKindLocally(Kind.WORK, Status.COMPLETED, 1, 4)) + assertEquals(Kind.SHORT_BREAK, nextKindLocally(Kind.WORK, Status.COMPLETED, 3, 4)) + assertEquals(Kind.SHORT_BREAK, nextKindLocally(Kind.WORK, Status.COMPLETED, 5, 4)) + } + + @Test + fun `a long break lands on the cycle boundary`() { + assertEquals(Kind.LONG_BREAK, nextKindLocally(Kind.WORK, Status.COMPLETED, 4, 4)) + assertEquals(Kind.LONG_BREAK, nextKindLocally(Kind.WORK, Status.COMPLETED, 8, 4)) + assertEquals(Kind.LONG_BREAK, nextKindLocally(Kind.WORK, Status.COMPLETED, 2, 2)) + } + + @Test + fun `a long break is never owed from yesterday`() { + // The count resets with the day, so zero completed means no boundary. + assertEquals(Kind.SHORT_BREAK, nextKindLocally(Kind.WORK, Status.COMPLETED, 0, 4)) + } + + @Test + fun `a nonsense cycle length does not divide by zero`() { + assertEquals(Kind.LONG_BREAK, nextKindLocally(Kind.WORK, Status.COMPLETED, 3, 0)) + } +} + +class StrictModeTest { + + @Test + fun `strict mode demands a reason for abandoning work`() { + assertTrue(abandonNeedsReason(true, Kind.WORK, null)) + assertTrue(abandonNeedsReason(true, Kind.WORK, "")) + assertTrue(abandonNeedsReason(true, Kind.WORK, " ")) + assertFalse(abandonNeedsReason(true, Kind.WORK, "the phone rang")) + } + + @Test + fun `breaks and non-strict mode need no reason`() { + assertFalse(abandonNeedsReason(true, Kind.SHORT_BREAK, null)) + assertFalse(abandonNeedsReason(true, Kind.LONG_BREAK, null)) + assertFalse(abandonNeedsReason(false, Kind.WORK, null)) + } +} + +class StaleIntervalTest { + + @Test + fun `six hours is the client-side reap threshold`() { + assertFalse(isLocallyStale(0)) + assertFalse(isLocallyStale(STALE_INTERVAL_SECONDS)) + assertTrue(isLocallyStale(STALE_INTERVAL_SECONDS + 1)) + assertTrue(isLocallyStale(14 * 3600), "a phone offline overnight claims nothing") + } +} + +/** + * One named test per row of the conflict matrix. This is the logic that decides whether + * a difference between the phone and the server is our own replay landing, another + * device taking over, or something worth interrupting the user about — and it is + * impossible to exercise by hand on a device. + */ +class ReconcileTest { + + private fun session(id: Long, kind: String = Kind.WORK, status: String = Status.RUNNING) = + TimerSessionFacts( + id = id, + kind = kind, + status = status, + plannedSeconds = 1500, + remainingSeconds = 900, + ) + + private fun state(current: TimerSessionFacts?, enabled: Boolean = true) = + ServerTimerState(current = current, timerEnabled = enabled) + + @Test + fun `no answer means keep ticking`() { + assertEquals( + Reconciliation.Offline, + reconcile(null, LocalBelief(sessionId = 7L)), + ) + } + + @Test + fun `same interval, nothing queued, re-anchor silently`() { + assertEquals( + Reconciliation.Adopt, + reconcile(state(session(7L)), LocalBelief(sessionId = 7L)), + ) + } + + @Test + fun `same interval with a queue keeps the optimistic value`() { + // Re-anchoring here would make a pending +5 visibly bounce back and forth. + assertEquals( + Reconciliation.KeepOptimistic, + reconcile( + state(session(7L)), + LocalBelief(sessionId = 7L), + PendingOps(hasAny = true), + ), + ) + } + + @Test + fun `a different interval is another device taking over`() { + val result = reconcile( + state(session(9L, kind = Kind.SHORT_BREAK)), + LocalBelief(sessionId = 7L), + ) + assertEquals(Kind.SHORT_BREAK, assertIs(result).kind) + } + + @Test + fun `a different interval we queued ourselves is adopted quietly`() { + assertEquals( + Reconciliation.AdoptOwnReplay, + reconcile( + state(session(9L)), + LocalBelief(sessionId = 7L), + PendingOps(hasAny = true, hasStart = true), + ), + ) + } + + @Test + fun `a vanished interval we did not end is reported`() { + assertEquals( + Reconciliation.EndedElsewhere, + reconcile(state(null), LocalBelief(sessionId = 7L)), + ) + } + + @Test + fun `a vanished interval we completed ourselves is not`() { + assertEquals( + Reconciliation.AdoptOwnReplay, + reconcile( + state(null), + LocalBelief(sessionId = 7L), + PendingOps(hasAny = true, hasTerminal = true), + ), + ) + } + + @Test + fun `a pause we did not perform is reported`() { + assertEquals( + Reconciliation.PausedElsewhere, + reconcile( + state(session(7L, status = Status.PAUSED)), + LocalBelief(sessionId = 7L, paused = false), + ), + ) + } + + @Test + fun `a pause we already knew about is not news`() { + assertEquals( + Reconciliation.Adopt, + reconcile( + state(session(7L, status = Status.PAUSED)), + LocalBelief(sessionId = 7L, paused = true), + ), + ) + } + + @Test + fun `a cold start simply adopts whatever is running`() { + // Local knows nothing yet; an interval on the server is not a conflict. + assertEquals( + Reconciliation.Adopt, + reconcile(state(session(7L)), LocalBelief(sessionId = null)), + ) + } + + @Test + fun `idle on both sides is quiet`() { + assertEquals( + Reconciliation.Adopt, + reconcile(state(null), LocalBelief(sessionId = null)), + ) + } + + @Test + fun `view-only mode purges the queue`() { + // Every timer intent would 400 with "Timer is disabled (view-only mode)". + assertEquals( + Reconciliation.ViewOnlyPurge, + reconcile( + state(session(7L), enabled = false), + LocalBelief(sessionId = 7L), + PendingOps(hasAny = true), + ), + ) + } + + @Test + fun `view-only wins even when idle and empty`() { + assertEquals( + Reconciliation.ViewOnlyPurge, + reconcile(state(null, enabled = false), LocalBelief(sessionId = null)), + ) + } +} diff --git a/android/core/src/test/kotlin/tech/kadence/core/TokenParityTest.kt b/android/core/src/test/kotlin/tech/kadence/core/TokenParityTest.kt new file mode 100644 index 0000000..e6c2837 --- /dev/null +++ b/android/core/src/test/kotlin/tech/kadence/core/TokenParityTest.kt @@ -0,0 +1,261 @@ +package tech.kadence.core + +import java.io.File +import kotlin.math.roundToLong +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +/** + * The design system, checked against the web app's own source. + * + * The brief is that every client is "the same product", and the README says the desktop + * `Theme` singleton "carries the same tokens as the web app's `tokens.ts`". That has + * only ever been true by hand. This test reads the actual TypeScript and fails if a + * single channel drifts, which is the only version of that promise a build can keep. + * + * If `frontend/` is ever absent (a checkout of this module alone), the parity tests skip + * rather than fail — they are a guard, not a dependency. + */ +class TokenParityTest { + + private val repoRoot: File? = generateSequence(File("").absoluteFile) { it.parentFile } + .firstOrNull { File(it, "frontend/src/tokens.ts").isFile } + + private val tokensTs: File? = repoRoot?.let { File(it, "frontend/src/tokens.ts") } + private val vizTs: File? = repoRoot?.let { File(it, "frontend/src/lib/viz.ts") } + + /** `"#FAF7F2"` or `"rgba(23, 21, 15, 0.12)"` -> `0xAARRGGBB`. */ + private fun parseCss(value: String): Long { + val hex = Regex("^#([0-9a-fA-F]{6})$").find(value.trim()) + if (hex != null) return rgb(hex.groupValues[1].toLong(16)) + + val rgba = Regex( + """^rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*([0-9.]+)\s*\)$""", + ).find(value.trim()) ?: error("unrecognised colour: $value") + + val (r, g, b, a) = rgba.destructured + val packed = (r.toLong() shl 16) or (g.toLong() shl 8) or b.toLong() + return ((a.toDouble() * 255.0).roundToLong() shl 24) or packed + } + + /** Pull `name: "value",` pairs out of the named `export const` block. */ + private fun block(source: String, name: String): Map { + val start = source.indexOf("$name: Tokens = {") + .takeIf { it >= 0 } + ?: source.indexOf("$name: VizPalette = {") + require(start >= 0) { "could not find the `$name` block" } + val open = source.indexOf('{', start) + val close = source.indexOf("};", open) + val body = source.substring(open + 1, close) + return Regex("""(\w+)\s*:\s*"([^"]+)"""") + .findAll(body) + .associate { it.groupValues[1] to it.groupValues[2] } + } + + private fun sequentialOf(source: String, name: String): List { + val start = source.indexOf("$name: VizPalette = {") + require(start >= 0) + val seqAt = source.indexOf("sequential:", start) + val open = source.indexOf('[', seqAt) + val close = source.indexOf(']', open) + return Regex(""""(#[0-9a-fA-F]{6})"""") + .findAll(source.substring(open, close)) + .map { it.groupValues[1] } + .toList() + } + + private fun assertPalette(expected: Map, actual: KadenceTokens, mode: String) { + val ours = mapOf( + "paper" to actual.paper, + "surface" to actual.surface, + "surfaceSunken" to actual.surfaceSunken, + "ink" to actual.ink, + "inkMuted" to actual.inkMuted, + "inkFaint" to actual.inkFaint, + "rule" to actual.rule, + "ruleStrong" to actual.ruleStrong, + "ember" to actual.ember, + "emberSoft" to actual.emberSoft, + "pine" to actual.pine, + "amber" to actual.amber, + "clay" to actual.clay, + ) + assertEquals( + expected.keys.sorted(), + ours.keys.sorted(), + "$mode: the Kotlin palette and tokens.ts must declare the same tokens", + ) + for ((key, css) in expected) { + assertEquals( + parseCss(css).toString(16), + ours.getValue(key).toString(16), + "$mode token `$key` drifted from tokens.ts ($css)", + ) + } + } + + @Test + fun `the light palette matches tokens ts`() { + val source = tokensTs?.readText() ?: return + assertPalette(block(source, "light"), KADENCE_LIGHT, "light") + } + + @Test + fun `the dark palette matches tokens ts`() { + val source = tokensTs?.readText() ?: return + assertPalette(block(source, "dark"), KADENCE_DARK, "dark") + } + + @Test + fun `the chart palette matches viz ts`() { + val source = vizTs?.readText() ?: return + for ((name, ours) in listOf("LIGHT" to VIZ_LIGHT, "DARK" to VIZ_DARK)) { + val expected = block(source, name) + assertEquals(parseCss(expected.getValue("work")), ours.work, "$name work") + assertEquals( + parseCss(expected.getValue("shortBreak")), ours.shortBreak, "$name shortBreak", + ) + assertEquals( + parseCss(expected.getValue("longBreak")), ours.longBreak, "$name longBreak", + ) + assertEquals(parseCss(expected.getValue("grid")), ours.grid, "$name grid") + assertEquals(parseCss(expected.getValue("axis")), ours.axis, "$name axis") + assertEquals(parseCss(expected.getValue("empty")), ours.empty, "$name empty") + + val seq = sequentialOf(source, name).map(::parseCss) + assertEquals(seq, ours.sequential, "$name sequential ramp") + } + } + + @Test + fun `the dark ramp is the light ramp reversed and shifted one step darker`() { + // Not a plain reversal, which is the easy thing to assume. The dark ramp drops + // the palest light step and prepends a darker blue (#104281), so that against a + // dark ground "more" still reads as "darker" without the top step glowing. + assertEquals( + VIZ_LIGHT.sequential.reversed().dropLast(1), + VIZ_DARK.sequential.drop(1), + ) + assertEquals(rgb(0x104281), VIZ_DARK.sequential.first()) + assertEquals(6, VIZ_DARK.sequential.size) + } + + @Test + fun `the parity guard actually found the web app`() { + // Guards against the tests above silently skipping forever. + assertTrue( + tokensTs?.isFile == true, + "frontend/src/tokens.ts not found from ${File("").absolutePath} — " + + "the parity tests would skip", + ) + } +} + +class RampStepTest { + + @Test + fun `nothing happened means no colour`() { + assertEquals(null, rampStep(0, 8, VIZ_LIGHT)) + assertEquals(null, rampStep(-1, 8, VIZ_LIGHT)) + } + + @Test + fun `a met goal lands on the darkest step`() { + assertEquals(VIZ_LIGHT.sequential.last(), rampStep(8, 8, VIZ_LIGHT)) + assertEquals(VIZ_LIGHT.sequential.last(), rampStep(16, 8, VIZ_LIGHT)) + } + + @Test + fun `steps climb with the ratio`() { + val steps = (1..8).map { rampStep(it, 8, VIZ_LIGHT) } + assertEquals(steps, steps.sortedBy { VIZ_LIGHT.sequential.indexOf(it) }) + assertEquals(VIZ_LIGHT.sequential[3], rampStep(4, 8, VIZ_LIGHT)) + } + + @Test + fun `a zero goal falls back to a goal of eight`() { + assertEquals(rampStep(4, 8, VIZ_LIGHT), rampStep(4, 0, VIZ_LIGHT)) + } + + @Test + fun `kindColor maps every interval kind`() { + assertEquals(VIZ_LIGHT.work, kindColor(Kind.WORK, VIZ_LIGHT)) + assertEquals(VIZ_LIGHT.shortBreak, kindColor(Kind.SHORT_BREAK, VIZ_LIGHT)) + assertEquals(VIZ_LIGHT.longBreak, kindColor(Kind.LONG_BREAK, VIZ_LIGHT)) + assertEquals(VIZ_LIGHT.shortBreak, kindColor("something_new", VIZ_LIGHT)) + } +} + +/** + * The system accent. You asked for the phone's own colour; these tests pin down how far + * it reaches and what stops it producing an unreadable button. + */ +class AccentTest { + + @Test + fun `the system accent is used when Android offers one`() { + val wallpaperBlue = rgb(0x3F5AA6) + assertEquals(wallpaperBlue, accentArgb(wallpaperBlue, dark = false)) + } + + @Test + fun `ember is the fallback when there is no dynamic colour`() { + assertEquals(KADENCE_LIGHT.ember, accentArgb(null, dark = false)) + assertEquals(KADENCE_DARK.ember, accentArgb(null, dark = true)) + } + + @Test + fun `contrast ratio is the WCAG formula`() { + assertEquals(21.0, contrastRatio(rgb(0x000000), rgb(0xFFFFFF)), 0.01) + assertEquals(1.0, contrastRatio(rgb(0x808080), rgb(0x808080)), 0.001) + } + + @Test + fun `white sits on the brand ember, as the other clients hard-code`() { + assertEquals(rgb(0xFFFFFF), onAccentArgb(KADENCE_LIGHT.ember)) + assertTrue(meetsBodyContrast(rgb(0xFFFFFF), KADENCE_LIGHT.ember)) + } + + @Test + fun `a pale system accent gets dark text instead of unreadable white`() { + // Material You will happily return a pale yellow; white-on-pale is the failure + // mode this guard exists for. + val paleYellow = rgb(0xFFE08A) + assertEquals(rgb(0x16140F), onAccentArgb(paleYellow)) + assertTrue(meetsBodyContrast(onAccentArgb(paleYellow), paleYellow)) + } + + @Test + fun `whatever the accent, its label is readable`() { + // Sweep the hue/lightness space the system could hand us and assert the chosen + // label always clears AA for large text. + var checked = 0 + for (r in 0..255 step 51) { + for (g in 0..255 step 51) { + for (b in 0..255 step 51) { + val accent = rgb((r.toLong() shl 16) or (g.toLong() shl 8) or b.toLong()) + val label = onAccentArgb(accent) + assertTrue( + meetsLargeTextContrast(label, accent), + "label on #%06x only reaches %.2f:1".format( + accent and 0xFFFFFF, + contrastRatio(label, accent), + ), + ) + checked++ + } + } + } + assertTrue(checked > 200, "the sweep should cover the colour space") + } + + @Test + fun `the chart palette never follows the accent`() { + // A chart has to stay colour-blind readable, which is a property of the + // validated palette, not of the wallpaper. + val wallpaper = rgb(0x3F5AA6) + assertTrue(VIZ_LIGHT.work != wallpaper) + assertEquals(rgb(0xEB6834), VIZ_LIGHT.work, "work keeps its validated orange") + } +} diff --git a/android/gradle.properties b/android/gradle.properties new file mode 100644 index 0000000..6f92b49 --- /dev/null +++ b/android/gradle.properties @@ -0,0 +1,9 @@ +org.gradle.jvmargs=-Xmx2g -Dfile.encoding=UTF-8 +org.gradle.caching=true +org.gradle.parallel=true +org.gradle.configuration-cache=true + +kotlin.code.style=official + +android.useAndroidX=true +android.nonTransitiveRClass=true diff --git a/android/gradle/libs.versions.toml b/android/gradle/libs.versions.toml new file mode 100644 index 0000000..1b9025a --- /dev/null +++ b/android/gradle/libs.versions.toml @@ -0,0 +1,49 @@ +[versions] +agp = "9.4.1" +kotlin = "2.4.21" +# compileSdk 37 because Compose 1.12 (BOM 2026.09.00) requires it; the platform is +# published under the new minor-version scheme as `platforms;android-37.0`. +# targetSdk stays 36 — Android 16 is what the Nothing Phone (3) runs, and opting into +# a newer runtime's behaviour changes is a separate decision from compiling against it. +compileSdk = "37" +targetSdk = "36" +minSdk = "34" +composeBom = "2026.09.00" +activityCompose = "1.13.0" +navigationCompose = "2.10.2" +lifecycle = "2.11.0" +coroutines = "1.10.2" +robolectric = "4.14.1" +serialization = "1.11.0" +okhttp = "5.5.0" +junit = "4.13.2" + +[libraries] +kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" } +junit = { module = "junit:junit", version.ref = "junit" } +robolectric = { module = "org.robolectric:robolectric", version.ref = "robolectric" } +coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "coroutines" } +serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "serialization" } +okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" } +mockwebserver = { module = "com.squareup.okhttp3:mockwebserver3-junit4", version.ref = "okhttp" } + +compose-bom = { module = "androidx.compose:compose-bom", version.ref = "composeBom" } +compose-ui = { module = "androidx.compose.ui:ui" } +compose-ui-graphics = { module = "androidx.compose.ui:ui-graphics" } +compose-ui-tooling = { module = "androidx.compose.ui:ui-tooling" } +compose-ui-tooling-preview = { module = "androidx.compose.ui:ui-tooling-preview" } +compose-ui-test-junit4 = { module = "androidx.compose.ui:ui-test-junit4" } +compose-ui-test-manifest = { module = "androidx.compose.ui:ui-test-manifest" } +compose-foundation = { module = "androidx.compose.foundation:foundation" } +compose-material3 = { module = "androidx.compose.material3:material3" } + +activity-compose = { module = "androidx.activity:activity-compose", version.ref = "activityCompose" } +navigation-compose = { module = "androidx.navigation:navigation-compose", version.ref = "navigationCompose" } +lifecycle-viewmodel-compose = { module = "androidx.lifecycle:lifecycle-viewmodel-compose", version.ref = "lifecycle" } +lifecycle-runtime-compose = { module = "androidx.lifecycle:lifecycle-runtime-compose", version.ref = "lifecycle" } + +[plugins] +kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" } +android-application = { id = "com.android.application", version.ref = "agp" } +kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" } +kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" } diff --git a/android/gradle/wrapper/gradle-wrapper.jar b/android/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..61285a659d17295f1de7c53e24fdf13ad755c379 GIT binary patch literal 46175 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

pVX@HRij*jw$g4?}Pn zE7RuaO3V!l_a{`|jsZVjZSR#tYwAffrvo3AAynZ^vzgSR#N_HZ6Ark)t{_hJ^zSa( zT@R*X#7rxlaj%ZVUZ1?7!Q9{bw(p9N;v)bZUqGgPC=O&mM zRy{1k%Hlr=aPWCif%s7!4cpn_cTyB1=#k?e8m}0C$)+&PD!&)F?>9;L&0Lpv)ZfP| zJxlb;PjKA4x^1R%?vIk=kv;C0Y*;|7*_mO)hTMlfPH5JcHa>0BR$wlt@&-wZufD82 z51*ufTeW5&M!0=a$FS@0MJRlk*~l8^Wl?2mzt}H8ae}hQ7tSz0sBJs+8lQ!`o(21B z@HNyMoH{;2l$8FopO-a)0DQ&f_jq)|ZPO}_AjDPtuOl4>R^0rLnok(Ezuu@$4lJ`w zQ6-4DQIk{FwQJspTlz!>L$CVj^cN<|)t^;jR~M^L^a=dr5aA!{qg3Ek9p;X{QRIg1 z1oE`2L#=6s6vh%=R(TI9Z5ReZy&?Jtj8aEcyCiP*YaYk5=!QbxQSz|aBk58{{@nCc zSY}$niG-_Uad_iRV56Ju8STIoe{*WWn3_?3>0V>z8)z@g_|dm5vKgxu`{>`)X}aw) zyd~I|(HFpmTO&3smRUnoB$VU&snAXEY(aq=te76JpanOdrwx}UD4D8MQ34z&zcD8z><`W?<_; zvO01*U(i7v7=EAJ@&YE- z4Cz5FWI`J^+_;Ez1p&jMET;4j<<0ymV(~ma*ooWab$s6DuWt>sP0$fuap>j|b@rOb zu^i4yE`d@_H>;F8*y;JfvhSY_o*1uZB+)0G+l{2nmbRR>POBwArWP}e z*`!BSjr`p73wW@iA~}h|mFJDOdP|bAlqD)jwN_vU{ z0ntkb0iphH{UY}N?H5%fR25`pw6s}OWdGYUvdqjNg|VZ<>;{luC*iGup0bRpG-1*u zLmD>P9mq$M!k->%T2{@Ea^ZR|8LZp2lzpBQFAfvFIUps_-Vxkm4ldisDdti7Bn(qo zAYco0<;Bu1tt6?z=(H_4yD~5qL+2##Hfo|6qRB-vFmQ}Xpo&Qc^GdrM6&iQtrIVT_ z6q)qyz^vmNwsqEnS6Vw6kZ1XSL;dx94s%n6>F=ht<9+@6=i_*PK35N0Hd_yKD<^9< zODB6aDOYD_a~CURdlzd74_j|%YZosWKTB&jFMC%PR!b*yPtX5;conr7MQ9H6g65XG z7EMw%FD|O_`*U$^ye1(o}oGT&v6r7mQ)iC|9t;%`Wt_`W`dAAT;#O+)Ge! zPY6Umf)7Er6YsZ!=pEz^$%f~wDcEbz?9OR@jjSa(Rvr03@mNYZ%uLF}1I$B4Hj~*g zWOL7pdu2IQtK=^>^gM(G`DhbFDLZd6_AD4bHKi+I<{kGj!ftcccz}667=-{}7`0~m z(VVjxK=8g9faw}91J}cSq7PrpJi3tMmm)~lowHDOUZfP++x{^vOUJjZXkhn7qE^N! zV)eH6A;SGx&6U&c1EFgS6CAwUqS$$N)odq!@3|yVs}Lv@HEcBe?UTqFr9Nyab-F_) zNOXxFGKa2*Z|&o&`_h+{qBoSkb^_~=yo&NYU~qe1|9&TE|8^(T{$GE;wbq8_qB^!o zWNUaUctH}Q+oBtk0YrkWOS_G@9aP2`<7DUWB~FndluuPn;S@}GiG2Iia25p++<(6C zea7mI68gN(*_{_OvF&*I?P;Q+ZzmWcYlw2__v`ENA>SnKs!v266LL&z9X9riJ-15i z?+VKr6gj*!-w2v^x)aO%fNEX5_4-u@zsW(~Hen6*9N_w{$})i6E2y4Z$h5?;ZS!i! z#Q>M4TTsuI9=p|iU9!ExS=~piozz{USJ)(nwWf1TYy0Ul2epIh)bcRZA|?PU!4VrJ z^E`vzA;ZAfgAm2#Tu0K-8E!~1iW6{oBl4lS-5Fc2%_saw>BKrIuW`^4za9w7veO)+ z)~?rp*f&V-xoXD~e%a9Df~ixzE@AMs{a8am6R+SXhXPfqv!>(-9^g7!X;m~14_ReuNF;J z{)~ysZBHLY*>ow*`^ie7bhc3H$N1qVxaGt6xFusWF%owkNrl|{nn?h~fjxFur;u%{ zPf10%f#iPYY|=!*HH!WbI~jskWo9 z%vV&6J9*nXeR4B9>xWboSk9Eo;%Rc=iE)t~UQbj~kZ}4=;KwNN^|%wM#RG(8q5C1k z>f6|ABKw4TzF_F&4eI{KI~)AqlIA;D%ZP^dwp;M?kIJM*Nn1jZu`KDt@GR-|U9|cI z1nW&P8r5WLE6a}#e-Ogslihm9#r{J2n@QFmcUAr#tQi)Hpw4ELC$U8t>j~4TVQMBeq1ZPK`deHgU!QY`%5H8F{fX}O}fV)= zw|oE_A51>pxJ5Kp`wcemi6jERtbEsty7FV`lJt6lR?dhxnyg>(GW9ZID_9Ii$2i#G zdN8@uX$m?D%-Eq1v57~V)v%f8Se#&b=gLhg@U ze$?D?oYb{i2w@tccty}{bKwjeaiTuuL?Y(;;{c#-8v&4O?%RgKiToLey0P8POL9Kwj|;h#ul~;=V1gq!oLVrP zlwx-xwyB=#A|5Bw>09TQ+~jkdmGnJ$YrZ%|h0VcBeiw@b^J+BlumSY_)*u&%R)>JW z7(0lRtg+C9u68--7Kw&9^AeL`o5cpi$Cy>&&kBT$@!Nt_@iuYI<_q4`b~7LsTn<38 z@q_=pRRz<8vLEbi`ICI> ztVoyd+|~B7*q`1YG&7_fPT`QJ3v;k-%itr5x!$sYj;Y?a>MMPep@UxVTF#+1EV!N> z_6H2hN=N0Xcd@IV%9NJvYR74G?Ru3xuB)BwZmD7Zq}qomtW}na^#(qbREUPzmYN6p ziyU)gFriO8NCoWQj0cX0evy`_iBWmXRAqjv1s zUZv#j5;NRuz6K0Q1#jyMzmijh*97>D-0HyQpPUWas$-Ay(?|{416{@{5KP2ka?PEc zP8oI%1X4Fzj3>}EjfCUk#(+zT!v(}iw3p$!^Q@S^2sG(pZFxXmvZD}i1S#$t^890< z{qTT~_hK@t_;8eCDm(0+KRWb6`iW#<@oqli&F&)ud!?o@d#&sm5DU${T#J~}D*(W+tb(BT9{p5*$hl>S5#Xso0)3^_UA8`Gf}moKyx7WW&Za0bEVdTef`-Tw?^P zr({3nnvcOQnn@C^v4ZlJ=yE#rD^h{bm(KZBy#fUGpq~?g>prt}JS^tFeS?=|m?BaE zJ@8ZH<}v0~>8VyqJvJ#}R!cY&OHr9QC&Le-`&+%tpxZJGbNA}s(-?PsV!b$q%&_0+ zC$k1nfCE(B(j~5wJeTrsc466K?t9o4ZikU!~82D-nTxfSLC5X_z)Z!-7`Mxl(>;hU& zwS|rLUmoy3J@!cI)A2T1H2*w45C!(c8--k%iCVGPe+S%NbpuMfDLuXR2R<(-Sw*)Q7->L{-s5w3mfX% z?>dwU|98h&rogmI~+Qsg&`Cy24+@ zI~yTIuWMrcD~v&N)2vQrT9SR!dG`fB?z&e!-|lV$LSR7AG(bHzQ_;o8Ks!klRZlHs z@5q$YVtIP|a<0ze&Q5FD#f;Ht7tgR7)XE`-e2 z5vVHX7yNJH@VDzGGCwD3&Cv(4HA~0rre@MyJY3FgVyd_{ea3O;yVeEQJ4*-)5qs33 zN70F!zWStyRS@NYDW+6gDxGw=`~nt08}PMWhCD6!_JVcmsBLH{IV-gSc^LgclTkID z#*&}F&%i9%MP&SES zMzGEc)ZNPy=Pe~PxMIJEGf}r)daA7PevJ z9~2FSl=99aB`|MZDS^cR*40E>X4EU#m6FHPsurfX_nA42aR38WBr`!09eh=CTMTU4 zl~%%^;KR5%NlSXF?X@|}Nzv4dcNN+y5A)(8=UF7z_hF-i$MKDqj$UVS0g-WPyV6OL zuL{5wAthWbw>!-gJc}jYTscv0L})-yP{rUPfv+k9P(53RgvQc{t83(%8=TWEnJ)wh!#>`}qP_=0d( zpXBD5ujnfd8S4dSaF&g4qmxD%ZcDIqHsbGQdogW$0;r7pe{%LxZvJL` z)Sw{e>}9oM@k=(Jszzv1@-s+_s(2(wE3G)fjDXHCM`v_@jV67e?bV5N-QD0$C3zKK z-N)guBD&o&G#=>Pdw8OLjXj44&;h>!YZkRl>@noB4|)5}Ii9GhIkpa4&kWOcOhyRr zYx5XE6Z?9%mXL=$4#3A_%wWajqR1kAHqKxmm$x5@7@e3hWo_MNdf6MM9_$VgpoL*$ z(q{CFrM2<>{&S6Y`Toe=szf)7`jYyq-w&el6W+@arE9)tXY|B9U+jR~$~pq1W1&4( zf1+!D9CG<}H;#`2V#UaNc~{l_5Ivd<$=ro0i`rjH&%*uOT(BN-<|^pgFE!NF@KU5* zj~NZ;r9SIE?q%=3o+iJq==Y@ncGrYy%J1c~_suJ-ISHZ8;}7Ze!05^VW#JnSZ{I*& zIh*vqjYFYI!RPlGne6eHPoDm#*a$UbxXeR}t=rDi%u@AYv^@enQ$TaphrriwAw^mOF=o zL4X{Io~71KNrW8qCZt1ZAB`G432Db(WnJIQ9Xk;|poyayjFsO+K(=F|m6yMLxTfq2 zhmA&U#r#NiiRz~z8p#Dq)Z<0#?5fl-h3c zk>UdIdslOZew?=b_};J6j3dtba-*VcI`qcbk;`^8>kFo9S}}Tt9TLu=Z1ztD2YHPu zSZgnhwj72$6Yfmz|3b25Ha>8oD1+a}*z1w7`#@Py95vVcvT9dWRWBso7}3^OX!<5J zFcKmCk8_mJw*DB@`1;2cs z{yw*z5cIMwIsSwBJT&y%JBO71bq8VD$xeovL@et#f6tiC#UiA3`K|1TtQDghPWN8P zEdjNjpM*NYM&Wyck2a`6H)|X}!r?3)uN- zo_>B9W*}-{yshhLL1%rV{8BzHnQYJXCX7}POY9l?MPqbvfq+{Hef^*yK&|jtpz=8H z_xgmW~dlvT_#3qXgYW<(+du)1J=XdbY5|3?mgBC!dit@|i1pYvZ=t));Ws^GhP?7etFJ#A8#?jg99r^mOhBAF0jXRypO-&E7a&sa$~AcYYwYm|HmNboB84e)(T zMbK`=mwl{EXTkYc^^u;wdYm$I2%i?8R^+Xf1%XhS$iBcj=n`dTA0<<%tBGKw#pH_< z7yYlWMvJ8ygFM>pK6F^?P(R_40w80B#^gTpEC+Vb&&-!6^q&-vYPz)}``@sQ%YNR_ zNOaXl*@?QG{lR#3Gsel}$Q`3G)^I1q+oN;@z?#FkR0;YMyIDh(oqHLUT< zk%gnOLPl=j+HtG?g_Bx{A*S_^p$TG^ut?Hm$v?F`vMkXn_0D5fYW{-H;0MI!vWi7E zW&b|5>`<5JSg1K8FkRW`QJo!YzAX9xSr!^0mZUEfk+e_~Hmy%77CP-~XCFy_R*4Ny_`rntN5nAV}SQ6N8Kqw_8j7b%7ZDR?e^>X8K<8bXzAdC{U zbZE%9m#;pqPn(rbEIJk19@n!JN~SaxS$`yFfwM#h&6bLdZ|{BnweivPwU}5iB>tH2 z(DDBM^0Zt_|Dy<)@T|GowT3~5P4IWdOi;~Y6(Z-Ao7$ppc<*sKv0DE2 zQ7fJ1S??EtK+|tfC`0&UMEUqs_0z_`Tr-_=AzULJshV->?K>ppr+5%W&=*Se!)<}1 zK+gBXZb=Qr43OMnp>Vd>VvP)(DB)hLH~_LNbUK&g#Uu=wSZ1f)8T(5(=Gf2ks`Qa{xr90g&RZXd!6JA1Aw zH~bvvn5N$5qQCvfR*XVJ6iySM_p3Q6jj2|AA&s@!J8y>W`{M#gi1*@29nCFLvMWUb5-6g;Dkqe-W%-k<t{j$y~ zZ7Jv-AR3~g)EWPXi8B5gmP=?)iT9XMa^Qn@Af zcoYxd6o}pTBdGwc$_4n>X5-}pENro_;kLbQq#Dhu>sziG^)7u&Xr2tw>{M4F<>)%h z*d@4(v_5g`Ak*QtHlqz^vB9PvwxsxB4q`LjQ9BXRa9v*#!u0RuEzlJ)ycVg!jAzM< zYV{~*@!zH&U&Ky~T$-R{;HFjsr=cfwi1SeDIht|kx#-D|XfF8RB4qEs!reEjM<8hv zU=xYuWa`j&_=@NplwLBteU%fmX+IHI4fhNhJ(9zDJt6~n@mvvoH+3AG!+P>6J zoG)X6Iw7fjttAl^B_}-c(@4+*+h?Ha7Qe8QVJ}i!j`ualoyv4$& zTM5iU^f(^;K#s+&Qy=p_&aT6e@joE3-5OeTOqCbNH~Pmb+&wu*+Uz_5&+87~+0ARQ z-azQa1RfyT*cjWoYYQtMYJ{x=QO^7#VGg+K^X1L>lgQSiibOYd!ftWVlqi~aDO=o- z+b(cjHc_b9&hB%0moVs3e~5e42#vIrUbmI)E&zIrg7U)iRg@&c_Im;P!V|MaVmROn z?(JpEilGtTNb(aa@@UfeGqinFWh)iFm#LwOlE)&3%1~3TQSZ6O+$L@Lu`y7R^%~B7 zE}woyC&?yDU{|jD)NRh;$_FhR(|uJmsygG?T>{I2e56P`okogpWz{AU=73=yy67$ zcC?$q5B2xzV+^K8>>@tTcR2t~S#l77fpjIs0i$7=-9#ZS6mO&XpEqzg&DE)guyYm} zBoC;IEiNnv+0Qh}gVI%z<>#T09$#O%uyxfmobpOu2;?=Z-aZz6=B6kz5tC@rCfGX) zm<}1)3w~Ak;sJLFb4YQ8qVXCvDPZy^^(`&U1ynG$w4j!T$Pp2^f@mf0->j*ie}?xL z7WKMq_bK0TX!EyC5YGREoBl@HlmF3q9iv-mHLP2?PR$&VVlu(2lhn8^qDPP!iGg?h zzIDo*qoU|zggy^{%OZ?O8VEtAn78x`78Z~9{lSORlH*gcFFj!%J4HSZEP6Hzx`^H{LQLn>9BZE|(h!O@#5EOOBZcF z6-BayPVRUt0FB1~Gxql91k3tCxa8S(1yF5Zj?JXj^bmd60?)O(ng`Cu$~PW3dr}X8 zN0(%@SE59PaYtS_2R@rPDH1?-YAk&U%Bs#Z=4V}EIOnPTm}=;NWXJ80W5v^rP&yNw zOx@d(3Cb6uuitL3y+uFwv9=7EN!DQ1^%`EH2`&8D?HfvbAJ)#-iI= zlk*%1isoKmj-Lz`F!S+fW>x2w%1EB67abZ-T~^X9AReExl7sV@p9J8-1MZ>)VHZIm z?34yV$eyp&Kd(_of|WxGRb7B97~_HOR0NM;!K-gm@lH*%e@jhb{|Ov)Tpa(CBr;v= zQWZ-BT_m#=dlD(b6$e{ysnx3s0iOvUi<*Owh`j_qD!OBrQgpybQ~6jcbMp(ZWJK7{;R~r`CMiT z=_TjMgTlunNtE_VbG3eEqBqYns zV(n9T5S)pHyxSo=K-cG|D4z%`iKj@6P=$8kBid9^p^eMkn)3_HY4ENhpZ_?y#~&^q zTK>Z47dR=-AKZP##bkI~@>DexVZ9&9*vlk_BG!oJL1Ei#M3yJM(huR0QN0~M65s`i#`o=sciY?Ti;BPs;rIZ*Nq zOLVct7)Utdh%@Wu>TOw>M#Qu?*$o%i<8yo3KN|t0Y>nlq@cvM>s=!?CtyXsp#$?kii@j51YSaSHmqcD8K`ZPt{xYoH2h@X=f^)X&z zFqmL5sjK4cP8)@&nR2(wmzuA-zqIjoejdoZgD@i7SZ=glz76thfPhX~?i}^91xVVqU=pyesPK|Ax?EHnf z1O&K~Eu-T7cXLWl?UmAoE&TI@5*p(q*457~$mxu0e ze`?(Db8+hu9<5=8UiJ0_XK>hNA3^o12oCJ9D3=tOW);qG~lGfzo**>Xb&J}^Sz2Xu@*zcJSZM$@pHRhL$(%F)^$XaQro=Z}n;Ggf(0%SH%kli*5S`#7~u z*M<7&V*x48gsm0 zVUA_fXxXOx(k@c{oqGAp@b;izt}*_E2Yg|KJCV#CU6bcBo;72f!e%Kp2cO{V?3Fe; z>*8^i3-tkB7afkzC=wr4lTZ7o zsztT)HP5h$sNA@YlZtsRl=e&#Gl(QCszU{lpV(7~#vo^tR@oKk+x_vA>{9osLFsoy zS5)cL5glpM(sKT?8kN0^6 zqO7i<4UJYoF+rGw z)XET!cC!7sc9=ADGaCx}ewNH2F=eNn6mB&U6ll_bUDLk`21UpO#-y7->yTKIaI zZ~FG@O%6h9oJ%<1*TaXGsoji}?}tFbJVcwX1M=*aN60z#{5kg0_Z5>0uI~9vyp@R? zF(fli_tW(z(;EZXwIv(En9K(yAIs5~r2#tmIeG283az@`SA{HRf(#eVG=i!Po8$Iy z#~C&U@?B#rxgN=)qPzmQiPeE@&*|`S5~|rUOhc~rg0=`*x~v)Buyu}`;_64P7&B&; zX}AjY06Y@6)a?YSm-GRO%6f6ePC<^5w#0~Z_^LUu8VNnm)Q3^EfJ!W!p_0zgloie21K}^yuphA{ zr#G-tJ(dn|L()_VxUEim`lAM%-uW*Go?6X}k%Et&h0-V;ux`rvnYSm0U3mpf# z+auH5I<7}3GpsB~X9ldCt!$yBe5gUfraC6~=t%kSWLP(~_J=rU7 zR0Q{HWo|me08i&@@E?wZ^*zdJ45^LAG8Q_~NJ{>u5p<^$TyN3Jlg9x4;5;yoq*mdt znlDg8QcrIE?D?N2zrl!;+>Y>FoKcq~I;7>68J(W(V~*7VJ8M>A7|^ zP{=lk!0_Pc{oOSi0(6+_oJ9L%mJ~cV#qP_l8Vt2^s(wW|U9d@L5YO|Dx&W(SYB6TU zVvSt;VL?E|24F%SW$}4LUc`Ej;2X*s~%}Zs}ENa;}C`S-lWhTf07(0-sp+ntHd% zLgeH>7(T&*a9hy2z`|}sD;WmXD(L#Ye@teC#@?WZzZ0D1-x3`2|8_+Gi{Sp5)%*+1 zIjc`84vAxnSUN7Q{Hj{6i)EG`!EZ(?k0FQU!(~L0%v?O+CCR6@re%maiG0RmEi2lE zf7aM@9>~v~`Z&|Ub^m&Q3%iR?1l7RC##cw@OCAQVDA{%iC*`|?vfx+SJguGM=T3-u z4&+u)a!M$B48?#&<4vsFAXRj>-yxCvz&uuv;~frmzdtFPFj)L0BsSe*Gmuc`JD!#z zPa`c$gHeOUnc>^CEoevD+?_;w1|J|%L z0*cBks6lMxj!yTto>uK;kL4>$Rwc49p87NFU#fJO*KMo$Zewfzc8K|35;l96_aROf zb0;<%`}g5;b#pH}Z4YxFYY$IzCn-B?OGj&uf7v^4ohe@|9sECA73_=L5t!SW<_J&} zGg9=4nxsgO+&Q?^;wai+ACFW({&aY@f|5)>U$2{*-o+YYL29T-j8bB!`?2O6xB*mp z+m+gyhKbikZ(C3UnQv?1h^n0mCoT zG-)F7l#@A`)%bDwv}82PRoxo`N5Pnpx%LXG{7CBroox5+1)Lo^iuuGn%wB2(nvydI ztf;oYgnZ&zj>dZcMJ8SZ48a}_QZq|V&|c;}^%S&F0gedlP8tIO2R$<l0~Y0BWA( zSV|vwDB)Es1cO6Dq94jGL!#akBeCo}wGTYxbkfJ?HaSvNHU5IAga=PON?4nYe?HDt zz9--xcJ4mr8Hv&`-Pnm^es?x-zu-vqF}@0PQrw$uUTGzZBaPo_tZ|6?!%1$GddLfb z&CC(L)r?4F1VbnFJS~-H-m6mvRWiyVG7iI1-yhTnxW4%V62OxrjwT1wPAq-1?xeY3 zu97J`a#Uz!v#4y|8fjcuT@@ZuCUGYg&E_#?+;;)qd`m!jTA)%IOpQ?9;F-FQO+qXt z`z_Rj1`W8JS5BQCAb;9L#~CR4kV2p@K8BW=osN~CdGpmvj1%vXp(m8PJO<8E-uO|H zKjAQ+ABcrLNeMYreKI)BLzK*JDkHnzBMT7j%B~n`y*HS(P#=B2&2l4Yt`TF4VLhS- zM)_I2ct`%#d7>=lTbk<`4dD_xu)G)9RkK(@s;*&S^S251p!_$ZZHu)B7$M7?lHr-W zF%kEdYSwBGCi?dAMjwuuQl25^@qvB7`K+O3hKRZSSMK$|L=-#52Xfh0(%of7Slg56 z){|NTc7J~inp2I8F?ICJGS>rwP`NzKI!b0&NV!ysj-Z+@6E5SKuOjh|9@9KmC)Sq6 zc2*b44y~m+U);H434xpz7!4(t+WhIxA+fx@Aj-?SGo2BfY$dv=n1dS9rJ3*GA|GM7 zEsHJ%0?m=(MMtZJM`;;ImPA#DeXRr&oCH3CK^`x-Th#6RZ%;(*j_1a+w{&)aShu7r{tdXdk?WJ-bapM0|s?&8F+kibcI;Z z9Z-UtlJw?oG&;&NZSB9IEi;x5-qJKjWQrGy5d$ARAQ$wA@+G`d4m>e;Mm1sNfBDuX z;AlPXi|TGm(BpnE8T-ZXf{W~0Wx0qQ923F!n=H|$ktTp_<36%e?#jZTR%lsE?s`|G z_T*G`Yot#9M-G?e$E8&Z4^~CZQy!|3PN*F zDNfkD=^5SkBe6Yl_Le?z-ds^Xu zUGK3)J3ER-q{i5xeH_LQ#opHd`kzkZ8OR$wXuGOI0S9!4$bxd9rX#XpZE1rr4^nlI z%#Ifniqpe2QUU|_*1hla_WJzF5>$w}YuHz!Bn7$|L3T1o(*;+m?~4zM+b*Rf`2F@C zFENS_$mw8?Q|%@8ZDthiuM{w~NTxxb&VSsRle7&MYMAtnOu9n!RY4X8?EYiSeikH9 zOZndU(*0WjmH3|m`aikY$<@;Fy}`luezV8P+tc3XeMs5KTEf!O+S60T+{N7Xe=)PQ zhKd@t1bWcS73alQs#@~xV;CYJB5Mi?KBm+I_4{>vPgk`|r*9%;rv=}|<6hAJe6m%Q zMI{z_E?vq&91RPqy7IqXu2FoPGxhxefqJ98J2f-&`?k`IayjoSKR?nE_Zo_J0q**^ z=CMK65eJ9MM3UF=fpVw%jQosAdgrbkV|?jWk^G=GZgIWH-m}@m#m}e~pO>~^LxQ1C zxf5=MT9cUh7zX(?ajfHlS0m4UuFZU?mWD8edgL(v#~-b6dRBli37)yq(dkXa^0qYJ zm2>PSwXHmOY->)I(>c=@V=H#cH4iqkr>!Jcq>Rj7HCe5!sF`+DSryVrGhj1JPn0w1 zpz1F3V?}jAmjhC2W=WIhi1|62^IeKs_Vuu>tvlSbf{BEZssNH}YC!RXPf5va8 z&*O3h@9IqZw?VV$|3rnim%S6)e?vph!`#iy+C$pj^S%9L@&1{si;jnrl&j0TX1^=> zzle3jf3?G?B1XQFBaK`)JeJ#K>clF%=Vunm%H)`gIijk*u5HkZTQe8UY_h>oeW8^p z@_RMWVv0Q*F@)Uisoy6=JZF1;Y-Ts?hz7wmqN?rggTXHQJ*&xJNSfp}aD++2QG~si zmZ4!fZLnB;l)F@pm1^KxY6sa9z3@2v>*mIZV!qbQltmvKmnn`wiCxdz|KaPMqC?x7 zcHP*vZQGc!ZQHh!8QZpP8#A^sW7~FevVL5gZ|}V>M(b@{_p08j-tp8sUL>;HOB^b$ z;hIbdt|h(^Lz4!n2$`tDF>w>d+R^r-o8L4CV$Dx{(t;5vTIc;CPmAYCX2oT221P|P z0{m6DMhT zWW~*jfZ!{&jQk}73p}09Tf0mmdonALDG0GIE_*DY+Wdy$#(|jSR0=Mb{Usmq-&*Ok zCsP?iLH+L;SJ7sgXGBvgEBzL9X!Z;RdYm;+&8*;3+WY7|s0-y?RN9E6UFwIYEl&bu=-nMHo)d+Jw_>@v)eZkY$8$E+&w}~w$k+G*`#;JKQIBmWvt^#A{Oa{KQHq8GHYbN&e;1A7?*3)>&I>Ywl-Vf>E( zvQe0@{Tbw`B8+7nj^iMN)JBJMJ$R(z5LXRwgg`1KAfa*irOnlN`N+}PSeahWNpMH# zEkxJ;d(a<#rx3vg97J5ZWNArdiIsWV&-)W>2LT?HPe->0&o^vFLa%OWuTVX9U$?5V zfejQ?X|e?mz-n;a^uZt!@!@!QsCW=UAs?r zRTQ8XNK)|mhN);1*Wsgp=~a(a(w92^6ZpiaKY(SMu4&}wp%6OfyRLceC%f=xCKu3qzu@%oq+s|rI$JfnjjEiSl-yJ5 z&C_g*h8aF>XB<2ZUUb{fwE}K_wFQI*pmFoiWa1jwhB&aZpsjDf4n@s1PUvh=bKk*C zWaM%?xyG~!JU)K8UUYy2;p+0qDDAGskPGj)v*r6B2BAdWoLy{KH(Q7IIJhB130S>3 z=toe;P-9s7>Z@J+)~YG92JKow7C3C^J#6P|jnPB1!Rwqme_ipn11EyPmc@XS1EHFS zS%uv?Mosl{H8JrKN{f#G3;|qewLxT%X4^u_i>Fz}0Hd|^pCXn#=wA=R&w#{rDMJtI z*&o^M#SswkL;ycEj3FkB7P<59R9AXVo&TlI*!q9-F5_N$gO7st4#Kn4&qAwL1 ziF<%!Jg8Ee%Rr3Xvo9C&K|l*sRM(}efz`Gqe8mXaZaT$^<)VsFETikCE&uTWs3DGx zWx*Lp8pM_RVHS=@z8CgPNe)#U0t7Cd*wLtMBn#x}*}i7VPbu=sc9D}X;CdTPQJEKU z!`+jf%KLMi%F^;EZHM}qMQrSTOF?GVb_N7Y78K-1DWMeAJ>V^4{!G4ONMXe2mDhTE ztfTP05-4YxaNL=mTV9CBs$FRCk1*7;x1MMBZA(u3mM@oLRj89xoBa&8j~L+0i4)9o zcMIDE8-zVDve({jxwMBH6bZ;3Ry)bqL&Tz= zr-@}D>{Bm)oHD}UXpeSii4H8ck>-&k!B3XxBH|wa`0R6goeadkwK+w{@eWW`ozPTz zzJLC7khb;B?P!NKLSN9B>Rz>=rGQr;-4d34g-lkICG_Jdz1TZ|lQkU1`Q4g#k%5~G;DFt|mKYil=Ox%gkz zp}sQ~xzrDPfb_3y6wCkp-2UH`CHcu&cMky{iBt&{()hB;6kkw zP%0{lE%Zg3{OX9*0C#^X-QU03FtG7P>$saD*EhL3LBoIG*uYr6$~h!fMm~$ZSj8Df zMjOUCvdwJHWA0<`<4N}S{o_)406L?D-NU0J>!bFb$tm*w<_CjK?KyDg1?m**Q1F&x zvdA3LQMzE_Hu_PG9p8Bxi2HCoy0^C*C^v7$ywtlfB6`wGhENk7ye?;xxH_gr^j<|* z9Htl0oGx*#-6I<{2#ZdSh8oCICE5lv#lUjuc_gd1ND7QVuH)ol%3&KZh9aJHxnt5+ zoOs>TE@dPppAjuL+*mCi=6SCcMol=Vepu^7@EqmY(b?wl756n%fsW~wNrZd$k6$R1 z2~40ZH<(;xt+$7LuJcM=&e{1MgRYl5WJ0A1$C3PoVHme!Sjy&9C`}e&1;wB;C;A*2 z=zn0IKV9TBRf@}HLUf7wUPD*51(Z2OF-?aS8g9aGK19RG^p(MvSr*j-yJ~g`;DWQ@ zm>)jnf&y$qO43(PM>s>AzO@c0JT>h>Ml46?)9EG?S`3$r#{^%HIWQBrhVoRrP_hin zVZq6|`SdmdBU2ZIF_f< zwOk+eoCuOx{1Oa;*J8>1Dl~7xLUBf6U_0=tUBS`8K9P_XEDZ__5)FBJmf^FGg^9|3 z7|XM(3>NJ_OR62QE9Rz;RVXlwP1m!3l_XJ$;1bqgLzKSb;sdl;R{JK<+HjH+>=;|FgE)pRVZyy&y+fp6Kz6EOsS$nAil z)E&T0mU+z)s-ApBI_Q_!C)H$*TISc^zyE3l^#U6l=}c0y5DD6)m*t(~#`F$L5~=+; zg*v_EHOw_QcuQ?Ts3llUFA)Px%c8WdIf`U zwUs%DhS#-f$|o>`$MVsSLO%b>+YKvP9P6G4uKjRIlL29b%ULV zI;vtJ@0n`UcH@wNJC$W&9aQSf7Mw1(!(D8Iv#XggE8yhCXAO#R_FNiAtyG)W>@23? zS06PE--S7ya|$~!9cJKcg=H4nFtFurLci5Aq&A|RW5KWK6$LedAgKz--ouWjF;h2O zO?Mw&UeLh9uYdH;S-*W;4oh!-Xad3?2+(<}!<#uXCG#EYqswtbU1VA`t(Fd1C)rjJ z5lGFlCf@C`F|oel&7v6G+dNI|(d_Y;7 zIi!q0l$vFh7UBgcB(r~4Eszx?0!TAx7?N0Vs%j4vI4-k-CuPr6S5xoEY}gFyK$QZ5 zFl+%sE}f}p&ozcc*XpuDluDOFwyv<32n0)?8=9J*L&)N#`-cfEIBsP?OvmE!P#`P3 z@hBfK8ir4)L5}LY<`;lPOrAuQm8m+%)bj*e7&2v8JU`RM<$;kv7VYw|1KjF`CZyVq zQ;BY@l&6}Z3ILSqf+o^-g&8zYn3_A3W{LkCvcjxn$+1Y77M2+{SEkY<%ki!^B6Y-O z#IVs$I}{ez4=MCS2PZhR(SBp3gCLMa(6h|k^ocL8Ru{kfV3fX}Z|ww-Ig2O^a6ed+ zEigF}zE_#K%Od!Z7f<;&t0^|7nzl_Sh=Z84@<+;o2z#58Vz7S@*s{ZR6!Vaj%ya)v ziD~E^ClRVkP@NrNNF_?nJ4-HFQp97PVu(${w&6`I3 zAW}a~985bsE5sI6;-TNDBABp0QvlV1Lh;9`O=G7FXFF4lUdXVr@Yr;16ZKR+z$6;s zQ{9fUi9P|=&}ABh>jOeYeaE$}q>!#8Y%q?NM`0>>$kHHns3;l3sL2Rb z(3U|}J8`38Zwn!GrD>W0$t&Zp&F@&`D0KBYcDDgo*>h1|Ey3XydVqC~=G>q?L=edX zYFS8;47MB01Zsn`BMbKA>XvnjT71yfSLXwMPF7ayG|4ys(iA@%HNTFlpC{x6-}p6N zdhg{jk}pM3y?5#SItjDi5fCpE$>L`Qz#d^$pbC)=a%-NPHba*}>H#$&qo+jtvaTP)7PZStk*}35F|8HEoRnQRx;jguRohf(tGkLHrk{!MSDsI)YnZ^Pmmznq*))B<4J{?O=ge?P*=qdBr{SKk#JNQ z1vgFWb%qfIs)OzT;P!f_Pm$ru;d8nl8!A*+rGd(*$~T-9ll}1tW3xAU@}#MAuJC*L z0C;@^N&3czV9X-jWPjeFb+fOJoUQv$L{yq=a*L}Kd#At~5Bl0l{n zeH7>=^jr!`6Nz1t9E+x7hBY&EexVHXhIK%)k^qwsA*-id;Eark(C~&aV{~M|8FCKT zs0-mMgoGl>k#)iwf)-{t+Rg}68E}9kyIc=JP9+ezx{<7D4+gJ4$?_qsidkan7Hng9 zCqfv+1O!7he>OP?3up_hldSIDw+YYT+o!27ZtoW)_?spE>F+a%KZwEIS6_DqxSRs7 zGXTm=$d=h}<8TDfk%G@F4U>8n`pAr=6;CR%Ba>`9?1y|H4-O%sJ2%!5vA(7=JO&kk zX?ly;ss17g(X=9#nUWglspHq?j@f+YBG)GsQWG8CjK|mXGVC=3R zYy&BsP#C~;wC;oA{He+UWRN8A6vEWVGmaC&AtL|^>nR=S*@8mg_m-SSYh4o7h|5Rh z+5N2&1DIo0wnNW{IFH4fo70@u5TUL~e89t6qm;8njBvLCT0ODrN-b1qqwkByTP2d= z3u#x0Pu-GERkw}IAr@lU{IL_~viIH95L;=?Y4=(fUQbepY_C_Lo6EzVpM~N7wC48E zLHp>NA>#Mo3d}Fzy_x@bDfx6Ljk*Ot#qKu}-ktw3ZdgLkpxC?5r(fpz4J?9V`54+m zb5i>fCc7NelR{wncg9?ka!+E9YRr79{cE;0@@0$YTQU) zVH8x+&_YB1`T%(VJMj*;J3XT{mpNZc^^#0C*}^mP>=g<6Pl1l(q_P$Q2H6-Vr~qOV4Pn%(I>R>u8CrAVRH-FgLgmrn^!-+%wmWS zBI%O;v{5DdT?>bb1PlWdck;m& zG?8;NCa#=2oqHYKT0<~i3BRC?0{+JzM~g-D_D`yp+4N*OC-bxK``0V=Zxki%+)mDkS^pQ12u&|6wk0VNGM#$u+&mlTun2ByQ0crVttGAJx(LP92Vq6y3XSE|2J*}wga zKXbePGRmVA1~wR|#9mGR4wIkl+84^>OFy8}$=ce2qG0gZ=Sh{}4_e&=D03~pL5m{i zP(Ngin(dtf&?oVg55RB}PA>B3f9tXpk^5+?KN4NTze;pe{}w#|qx1ix&HhK^6l;Kc zYb~{Z_f$I6)+UnOFZ%7=*qzDvFsj)$nSTQGY00&)bYD$Vh z=Mp?E7@#elofl?nL+Ajyl*%veOj_a9#V>ZA19kX5)*frI<}B(>&E4Jdntt{df;j|DzDUxwq?|n{Hu!vR*H~>cCI&l7T$GeNk=Ng+1XBe( zfcX6q^Uq*Nu~&LYR2AFsz-f~tS7PbJ=!JATCIVojOo>QggJro0v5jy;xq3;fEzKkt zdb@do>>*3K#aFR`O2#+~Bsi;}M#`YH(+DnO1N5Hl-3d!{3G-A2gk&+M^dSK@3-NrK zytKdh{OIE4Dk@06#=(*W*_5ec^p=7JT_Um3)#?%xTs5fqy@kK*{is^ha)BbL66UmZ zXe+q8B`4Gc}VfQj zqdGkRB6Xjx*!hG7Eoh$%B)ih-SpfU!A)At?X5w7?>Lgj=RC!XmqJ@$`xkm$)&O{NE z7zj9>Wu5a1glJ6+sZqL&ku&qfJe_696xY%M+5{Q*03~s{gF+;MyxclXfz58vZb4r2 zGE@P$l^sMWnne@vmeP766QV|XTKw{f$_};3!{7iBk&;E3vrf2^l)d6O@R~&{!#Z9G zX{wlTM57#oM>Z;L3WuNo-J0C_&@>>~b{P#~_y_`gxG)DMEYUUqq0O(}&>ch-wC({e z9XT=mDtjJVyzNAu43=1Ow}&uu{|Uy8%0MEM-#-nIRG}=!CehVQKuYhrbe~6OK5OF$ zRDCn)f|R{sP1QnPJoZW14w{7rk!oBpOY@y=ix1R7IJkZobR>D$bv$aig~U4 zE<`A;fm7SCA4*XkiKemy+mlvxm*S7%=(0V0j2Cye5XTtz2x5PWHMEV}+>G zy7}=iU+iJQC?(sRT=??`!Z&fkLdo@J<0$1eA(GZuCJV;fWJV>y zia99Dv05Qs{8G83g^{w@@*~vZ2E5C3d$0$76^_=h0?Ay_FCq2?)2z|apx^r6Fq?X^ z&vU>OQWEXj+C6t)M+Gx;fk0RHH!H$ztpj}$<&!a8p{dft1imSbT$@s#(h=LWb3)Qz zYA8iL$QMWV@sfc=0CZ}{u_q6po+wOjpWrpy?q!;VBRBC7X7cF^bZ-eeB^f^> zQB`Z?1o{tEQvXOXqRY*(yLcw_fLf}o6r~WSG{{vGOiUVgD%J# z$j&gdK=e~U|J1hOZS(>U8Kj4rAvGrF1IWBx{2^Mp9Wk$g$C!xeTz`5gS{vz0 z-chgg;3v&I5-}eaJyclm^@TSC4tN8eor7K-uEcUJfuimwaZ64BEb%Suheq-h@Da~g zErZ@oft7xIYR7=)2~so^;HmQf-=SxIl&g3yZzQ)dn&;*|#&kWgLlX0cWP!F35QY=v zSB2>$;h|~6)Z{ZLT?-`a_JrYVoHNvsxvZ$p1q$y_cNN-mV}o;rcFMJONM=PnsDZIr zVC2MVapQDikYN5vCH)BZut{M2Q$T3})eTDtH9fqT2|SXZy|lnI`d{w$f~eB_D8UsS zn7lih>~118IeOB}ai<+1Y}Oohfff{nLFk}6M*X;93@U5h)p}SnK3uuK2q=fvx`Xyn zN>T9xkcy8E4;oi|>Ch|032-OHs zbh>nVJ8-&$cS0SUbBU)ew^T3qUYLo&ytrP?yM~iUh6a~yUEJE{s&}4%{tkwJ%I3pE z@~ClA0k^%03=gV<=L}RkZE7(7;dIzR{69fMY zU^Jt{-4CVPngMr)yA@ywB%OxN(9zlZeJ(P$YIo})tKSEG2nnWbN889d)`f#J(fV;cEu7)J%aN%~_$)Z>(fMP3Vw? zZ1PJCp0N}}5gDw$4Kt=g~m$O6&y+Kq$rbyR;oM+-R`+eqIfUr?P z^Tnv<)ZPK(iuebbZzaRTC4*x2up0rczT;GrI&O00wgD>Oq)Jp(5T~R}D0eh(ImW^V zq^(nk#P--V8q_ccE2YtLD|<`Rffk5wZr3k^DEXG3Po?}a=HOQVEB(M)*a!!fve8!z!Jf@HMHG$ z$9EKahtctY!Uf43{Inms%oP%|N{r%Wl8AXQreHG|%SgOX+R3KZ z^lNIxqQqP9lFtAjcNl}c`z!qTg|S|01BvwIC@gati68424l$8oM_w_9+~Bq9_mT)V#S**~fdp z@BLo^`s#=L`T%mcD=)EJ{Nzv_bWJw?j5-ReXPRv&KIY%_A8P(@L|Gh(XQ;v=Tp18@ z7r>|2AMn|^W-$2JU--UNcT(oY2iZbK8`9XdNGl$Xm&V*)@uAMX8u*)wDN`!HVV7d?xvknpLesf+@g5{Jqk@X&e0;gw;%` zRVef*D2U!@3ZuId8&n;3n2I&kYrq1EhU6q}s*ux(T+P&EymJ&Q7a<=G?M>9H*tV%h z23C!Wus=JN-k`lK#w861^^cSm_tZ{S?O=>Ak^9A(vodXxfpoNh_yg}l zM3JR4aSdggXNv$ftxyAIk0-;5u%ivhS2Q3>Fs1OA;)wuh>KVpmy;!!JQz+Fa)GQ^- zK!uQq2@hsSSp;nlsLM!C5tlR5`MNS6;IIr1_*gST6*BcvnIG;YyYGmmuR#K*= zW{uWUoEW*&=I0`Hp&gN!RL%z+39N<~#$AUFb$6G54ADoC(v^yC)==1-043o{yYRJP zyu`f4gc@N2j9u_+SNa&F=X+x+p#=hz8Lc@+1ki6W8YaIRTIemmIfy7dp&X{fj~8A5 z%MqUqz^ucP8mK;Nv?k6THibm?hKYU&l+RPs?&Z z1TK|`k~q+aFp8HT)feqXLhxS*m?YjEC#KtJaU7mYr$g!uMq%M1bm;dJ2e&Y7Q#L)5 zG4CQ59$X@{@~7_bQn`oLt_|6Bi~^4)#TQ}_xI$wrYB{JZq{uj9P__r4Tob6IC=Q}q zyu>Ec6-bEPsLB?pwBd4QBos#AOpVQ<=Ih6#w51-ET{XQ)KLY4HA`top_#AApi$CTs zpW(1RE-Yv4G@SK6yMC-3ZJll<7j}Q5jL!+2({qTggu>xjpO@Bs(qP7jm2sgow0Evu zUa5Pf zB$L4|q6bjR%lVO1em~M5oluvKL9?Kad-PZ0P0t16@Z#D(z;1?qUXOli*7Lg<#rW2V z0;mE!U_v+b8}Jit=ZwzDfy_G)d`c6&f+YBWELL)f^||ti_jW~^0=}#u{aqD1418FZ z=l{IshzcY0XC z`P8}4`8~_|wqkLI0@D1q?S++|j}8nchE+58NX4mY!|AqaMInDR7D9rWh0^j@qH!}( z0~#|rFu<)PAi@bY7dSWO(4;O(sW90AHT*0AgX0ClwN;lZ!_XRloGo^d(oR=yX`7eR z1>XR(6OY&6+M=Sd75vQ1EowgN+9r$4?EOtY4*lv1`$Lmj#GZ-`YDS!BGyYhnrmf$W z75wW^{L&R&KDp~P_kfF`!J&oab3foYFq|9uvJhbD!7kN%bw7DktjkmEy!5W?OT(c% zaGJp4Lp{#`F8Kj@Z>Ss0O%0@L z=_o3AS=j7D=%871sN3^>4%ZY_={S7NJKB5BZ|4RR zQ$Q7UxvnAL0uU9+9>1QsfJ}Vsk*j!!RFk+XflYjCk7$vTJ_2SjeXY~bvXqblWkH)8 zm_H8Xf6>cR-*W{BN_PLc7{{{Hc%%?Kj)Xka%N}5vxmf{!6{I)`F4FaaRen>B>7{M7 zFH;#D`{Vs0{<=mIehp`2#J!lZkG~;8{n4Mp0vT&&EO`ri*GTBE<@9%eA2EM~pMK|a z52w|kkFT#ceY#i1{l$%ZzzP>fzWZ#yiM*F4I6Ykr^6QAfqcIma+F$($yxTbswfDlgY zjgc~blW_GD#X`_8!LVXh#jx=VfgxneOSO`fgCvdo<$IRqBZc=+iQ4*V>q}zr*5$0y zCjk@J6MX~(C&%#*)pueRdgDq9e0j9PB zH6wwc{sz}!wSk_j`47%~w)U<~RoFV(39zI~L8E>5;}$1S)B!fUVwJTcH%^mMu~pJ2 zZPlV%ldph=kh!imgV=`k@d!MVYlsVmU#lPh>!3kmtG!ivoX)l=Bdj|w_Wt{f2|>{3 zNSJBa$L3sEA!C~DNco&iVHGD>@4!!uXNlu3Pk`?puU-1z@$Ouu+{YYp2%M>$YNN-R zX21B@IoT(UP0b=3v1js}LcOnCb?I|)r)^)mhCCFjNA8R6vyr}%?s@mhmn#KcH}bC% zW;QKLy@waI1`|<0|FQ+D!u#`z6h~9hlBk|$5N2e3gRK(2L6k3test;wIlH<@Hv+Qn92fx zxYGjYk#gV)nx5wDl36YZW|c(eQM1iTFxD$M4EWQ#@Ikmnos zgpO#tUHZE`YJGE~gbEs=MG9M`5m7I=qR>=1V z|2UtTmrRK@T1SpqX-PKPSeeIE#~-b^&hu!oPqmU-_+LgJG;WHj{q2!SZb7%m-xQ6! zprUP&%cs7y)ikUvpz?yHZLTdbd1_X+sV&8NcR6UqFVOS~I=djZX#X^7>faKhzJ#Bp zdXF`4{uJpL|DxC2*VjB(7e2@F)x1`h1r&p}vA@Wx#D!ct;SkNl>2{9Z_i?V?2dr?D zEd@K)v~=zX&B$_7XuJ*Q=;ZT)|s#?fm3jniC9CpukXut5IW=yN2N`|3UW`k#rI*J(Xog2^D)Y~x%W47}h`A5$ zmsV?ZyTV#5oJSmcHHL$rGkvPMqbhJO9T!=1UlzT!b*#&pQAD1fXRNT)LXTW-KH9P5 zqX6mHvf(zeb3x zEXeM>NHfb5+$HJGc+3)(nv@x8IBm+l(_C|(TuZNmP2*`>m!y$tW2AOSXO2r{YZStF z+Ccj=qg;lR(Uy42#$^$lL6qX^YC5E}J|Aurs@Ss9U?as1KZVF7dFk@jU~#Dse2ANf zF`pf3Q(VNOxBJMQUQBKAVH^sz485r#JAS)NU4%V+&Wow4Y{!*St3Gm=3c?7!luRLJ zg8-;Jw$eoq@LDU6z|5f3BMW1QW;(GV0rdsOsTMc{h*73QQFwmZi;R`xCLKjs4V{8z zpkLk}#kb!1H{sV&A#105ow)@<>CPfRO1^->7RCgfoa0qjRbtq>1#mQA6~Zmps*9$C zR{@xZBNKF?Mq2ai!d{@VHsOXn&+e@mbit@0s%m5tD@)I6_xzwH=z`O|vOpFckg9%m ze}V)thirtajxb6>mow9(IM=w0UNx?l27;MU_eGA7OLmk!q@j@SDNnEli|fF2ROYDX z(@@F^{@`$zOC}1MbT$&$^l@;LAtU!dl=fKGg;g3`;8!l{0*2`6io3n)3Z1lwW)qSMX&&H6B6op0BOsY^48CdE9CD;j|AytFc#uUQ^dVqKV zwPRM8q8!llV^uFELm7t;3^3M_RLO)8_Y+j<6@LtI9XsF1+}4a!SAPqcNLFg9^)`Fj zSgEmL4kjDU(UC-~)XR&&6b*YRSK8_SzPffPc3;=6(lfX%ve2OsF|@(LglrJAy6j&3 zQ53Gan!U=F)Di8RkReOBn>zer+=(TSwGnTf z*Rnzm*U6Wo*mtLhu4%hSke^_>nlU7&JcYPyEYiWY@cQ^DiF~Q?auFs3K@+K8;kuMg zwuV5kYV-V`8Pa0Rn8E0n?XNhH*Pzdpue#m!P-{kDo9Kc7o!U8?)FJFJY5DV=Q*K*H15|zoaeZ z;gxIT%0tMEjrEbAVn)F1EeL*5dWRT{nl;)MIguR%znlTsrb@ryC{?py2EGI|CFryT z!uC0_J2yACqMsk976rAxFnx|V^q+Qn7Iu;++gH158K^3#bC1z_krqGEZP2cH2SaAd zbWdZR#Bmx_1o4@I!Q%W3n9Tep>w1BA*_y zE*4?as4ov0?r$f9#I~7;2el*Mt(EV+zC5+-Le^6`%OR@XZ!})>Bn}{U%S&l75_70R zb>YYVd*B6-9;SVen?o4vme^s{;3Lh@2$FpuId@#!0V5XGt_n?Q?>0Aj{qI_?>+^xw zpWFpX8(TKSTB&wjom%A@uC4MfE>)(Z4|)#^vatul3d|Q&;^cbIOB)Ncc@bD-%Z)*b zPq1FtofUV>ei{WDtc7W$-qg(JrT|N}TkwuR+3~h=h~$sN2i|q+rc#10nyXjPFTte^ zX{QLKnDAZ)>$oJT&c$sbSl&ZaSmvY;Hy(U_{137EqvMIR4Tz3wJ*XZVoe?g>F+901 zYd1hLOzdEDvb{a#imlA+k7IPm1n=9%CPPZiV~iRw30G35qwSMmnzx? zIb+c;+iZk_2SHQzZBl&ygxB(x$tptwTl(*r^Cng#Z?J6bC#<$TK!Gh8s*s1u;;pQX zvRHWJVDysYrJS95YnW<`E0@-JJe=tSHzbs13RN2hQt&+7Ng;#3e^8-n6v{%EEkz8t7b~IQ zE0;F@wojhK9vK%HemcA8cBMI&s4v@}lHkJhXfrM1xj8Ej3nMj}xoUbosn^ObCdY7b ztp_(h)oP%ekys;b$wHPtmL%paSC_hQ*ReRSJSSzB+0-?Cy` z5(TS>p0S~tJG>R~%V(`qVL47z>BzEAo2^%wsckeF*O7_tEk%rL^AH+1}ZpX?fat+c#`9u{zqNInLk*PD-r4NK?HTgbbEW`hdk!^+)OerVxh}0<5*_sCkD)>jE>PECJ(`rs&vQSqiBi5#XrQ+l@&S1Yd zW~|6Kcs&JHx%qg0uNT5t*sdKbwI=mIMyH0=l~^7n4%Gx9Hr0&5HEkKzFe~Ccz#3>T z8x~`%;_^u&p%ch^L3|%V4fmqvp&jfpm{lcT_z+Z6sX{br`z*-z**l( zV*al|m~_3NXsFj%c&dvLtk<>Lzb&cp_>bRZ93&_w^(yYX=jDDbQn73PDp7cdU?aL*BL*VK;Q1cou@ z<%G;A5a@!4(@Hfo`NlXWafmoES8>Q#r+J<2e z(k-d+ZwTe`VlkbBAvPyD3t3`rz9J*x2ndxGh-PCkPFw{eMk~JwiK1`nq$^QlOp$CYm2hBso=rlg&n>nQl`gxTL!*$p%b2}P zBf8is+YZF7+2?v68)+4;J*=8pE|v(|x5qBE#a{YZEy5HT&i4U?GLdWzRHt;hud(O2N=D&%P3w#yDOqn~`& zeDzN3*cbj*P`#yuR3A_4HXNW$%i^6B_B8n4*HeP8ZuEu>)A(~TY$dutg3yjiq9{YiZ?V#Nt_LA)uWe9>rq zOHY``mM3W=EdOW_B57D+$7}l9V%T!+IC(oHe|atxeT|j1b1hi?4K?{V!Z>rS-^1@8 z=l5&k_Pl=J`@e>J5(Dl*2Vs8TAB=x%j{YCy*#9<1|Fiy=1;>BzKPK_(|NPN0lh*jjF#w9UmGnIgJ0%yOuB27j%sZCTS;t8-sn)vVC0#XPY$6p_koe4npSvG-=%AfGn*3X6--%4AUZ@@3_ahu(H#@uo&n zxre;2?qg+#zsr$OUQ@T-en-C`fQbw@O5YhpsEn&jzpAVR6zusmS^ltOlApN`RY_X~ zI;3&Oo?-f&#_gWM0U)t5HI+V1(@V7aD=M8lFE-^3tyu1#!4b=jvwO=Qleo`7FcV~*8oYO?n`U&ennfyJk^xQJE)AJRf`t%;S^ z`rFA&buF1xT+8q4X}bOSXMlwFm_N31W$SwnTG%Fk`{R(@-(`}(Hg{QC6mo|3uNnK`R*%TkSiL}N;=X8pxjI>x~k?l`hvnV_S^&7%)r-bq$H-gKFPQ1 zbPE7d;16MAoZJ~ZmW9r&iK%as6H9IJyyvmI?!@7Px0&B^L$k9cVQn6%oB2rdbW;lM zzlccZ`yY zb%o6E6xNkO*s7dVe9GAbbpt0G z#S(Rq!VJ14{_28x!6FY~v;`#sqGFDj(~AhsBH(PoQ(QJD5bF{JS}}>MFJl;{^0(8u z<~p337P0WT1+Z1U!t9=g6%jgQa-J~nW5YY*0L)x{M6)!a9E8i-C{Jf zC1qZ3Ju4q~Ov~+1ZN8NUe_VT+rbDnTLJ`I?T#rteXL)goXPMmWCA-9R870GE^e&K= zpw5b6wUSbaZMnvRYNF}#a#U4?33=bqiSdbQXve-VTu_dpjnWS-N2$V}PkQ+f)M1ce zS3vxWdnXr>Id@KfzEX=`WNer7%8^nn%(fsia8dL#VEHqwPSO0AywiDTzw+?k8iFB< zR)SiSjbbU1$53GloU_PXxbqpPwCAKk3%xQEsvusX%Z|>Y8 z$hFs9_1*nu9z7Q<)-#+=`|YAUlQPQTQDIKJ~`Bq9o{GoiVlM9 zks8$P!tjc6^$GbkdQ^iYJfTIohMEsb10N8G%WXpn@j)e)({uf8Z0=1zgBp*K#O1^u zX68l$9vUC+Hvsb1>qZ1096EvnKakT5X-ph$RjPebuUt|6!%uOq_mEeA5%}5C*LtvGPt2nN(CQ4$k*B4OxOsx=&{*8s}f87Kq>Ke&M;dh zo&PMi*My#^X$UgQM1Xz)M|lxbX0k8gq*DtnBErf`R9lR-7$cw59vzICBcG+YYO961 z@K&yAg4M?gGu!?(!lhm1W9BwIV6NaTS$&yXa!Jk%9cB?8mnUqLojR1UZX#C>ItR%; zG)_#*l;PTNF=kHof?cXZ*z}OqDTAckDzNk@I~rz$A&Yfttt9qf4rI|khDIwDkaCU0 z^{&56PF>BFbE~99Gu7d=+;EmYkd`~1b2M6~b&`{6A-5PHL|v%pwC}5f(ZX%K%v#z! zEg6NIPO&ZISs-$A9CmDoSN8Gr?>36*Qv;JNW5GxA`VKRyHULY~tkcJnk=aXVvn93a zv^?!_jh4r?GSp|#s|CM$XP*rVPo9;XwTDm!OcXxUzDIJ28bV)ZzH~feD?t22ytG@BiG0tF|Jr48RYwfkyUTe-hzpu0+vcJD^ zm1jDyZ`nlkG~eZbK*YsgFr2dmlDOKBhqZ?k=7km~+p9rBS&rhDAs$Hv&e(WQ!e00V zlb%AQAZBv$2TUq;OdBu26sDHtep#r@$42JkMaSdG(>!|=k-GdYZ$&d{JuBTtHSPns zcE^hIssoLqm!8pOT>gS;G0lDr0!OWbLxQurlvb}W9ogPdRow||T_}I_kmBf8)5d6O z(YyBp>hTvGD%o=7(~un0z*A_m(7@?eqIj9_Z7CWaJQiz9s3cyFpNShe9?ItFK`?E5 zpXL0a95Vq^BQ_oMGCLWT@+$t4Li(ln%P#6H^nKH?4A)P(S4}cJGs3C#d>NI@tW81s zij75YC|**UN#rEut6%X-TbDj=VoNPFvSB&m5^?dl#GcBbPZ=!m=GC6JODb|pSgZCw ztCg5B9PuE~OIR27yM(kMkQ(!Ayb3B97aDLpUe2mTmH^RYbkLF!W-<*pORgM&3RY5s zg->y6VNScDnxd0{AC*!28f+z{V4QhQq4&4FVZ3*R41Ar5Um(?ezKG+&&%9bfIA?M} zA9{i@<~yk3Dfs~1n4 z^@R26Nve`GN)Up+_acpcQyB{nAx4RYRdc8S$QIP7c?E7%!}0X$^5X zswW}mTFr6Z)wAfR#4*LC@Zr(ZX24543MFZLaO51*p(z*}G4P-52sT^khk#jOeWpzl2o!2Cc=buDucQ-a)H(-<0~A zgN{F!bDw%2A?63Ua6WjgUi-*deC;(kwk#Q$uy_N+Jq8TN*`sG#8s2XOELS-*0rZQF zre$(Nucb127C-ncK<7NfF#}p4#eG9J*|x=lDFdOoevYABGpHWRu>Le6p{46>jjd0G z7CwmzOJ-9=OmJlAfYKD!tWE4Q+Rn^}SYHVd>R6lyQ;$Dj-f}?qp3S~~{1VBz_iK1c z*2dOew4A+bma@?hLk1IUwYvdR&Bj&>_7yn$jeN%c>XPhYlwwjL&1|2^Df!~kgnolz zpp)zZcqrt1p}b#g8uGp$$8}a_Es*1sb4Y2m-fmwylOT!MukmT~H0658{#zf6@VAP@ z{HxGp_0wN$i4->&2cq)QAF(TC=XqA-%_F%|KF^+54?=Oy601KXeQEjTa->iF2*>${6U zNfJ7=tf9ndv)#TaYscj|kiq2aYO%3%V1#Pb#&v_gt})q~3Rhftzo*zb__9d)<;-T` z-WTuTJoD#xS~Ds1?$oh1JNulMim_Y7f#0$#naXiiT}_Xdp-MF|)K_C9wdvXyv%5-y zv=&BXwHKT?bgA13%ay~PkCV5H@RGHY+XLaK2QaYt!y;+hp#!6L8qp*MOeFNW{mIzH-2sTmXPW$mhoITa79;3sj0B`5yVnXsAFeC z9ZDFq4NNqb7#1P`fpMSN`T z*uXRg|6DEmNOyQtiG8>m#6Kv9V}lC`@K`{D=j&kMqDx=%RXm5Cs#?}NZ&Nckw0cO`W^Oc`hPtDT{_5b0WTY)dZ;8 zJ#&KTM2)%{3rt1enE@N&5v4?_1@OdUZn?U*`66nqHR|Gb>0h!<3W-O90hbQ&k# zOFNEtSV!X$Z0I^S&g*i3_`pPWc{K&*>4!C%EUetBw<7yuo5gc9T$B!axCqb{QTy(W z^#1NanWKZ7@1Me^J7Tqd!?spXS5Q#58l7Q`+!XVcPq|l#-8ws1?x?w0nkYHrBUNot z&gf=wtU(uMWI=R+;ukx_=|b$b&(09eFfUVAu=K8v`NO*k8p&oa2Sswj#TxpIf{Fr@ z(tViq2@(`F5I&mkMM>FQ7+j=3>gNofYMj8*I`Z#9&fih;50<=kIcAgLo|~R{pf)v` z$|oWmF>-GO%Lm=Vp`&b&hkP(X-7I+NEov>r*oQCfLrW#06P5=1aM%8QwzJWxUUgbM zd}6z`kDyFi6nnV*%hcf4OOdN_E2=Vk9sBCvKZB25VJPb7f`2PeB0RwFjZHLbsud>B z1dyZbAs+;_;)8!^A2&*6PLx0dJi9(t8H{=T&na_6*MA1*2zFChxe$C}qtkh{STX`B zAK>Atx8R3aPNf|W1L>EQBb0Yx*1inT$`Ow9$`*F&^q*O*EBGvZHcP`M3CH>lva- z)+;y$Y&K1gBDaAnEYFcRf`f>`N>F46K07E3qQx;O8zzS-d$r5*U%HQG9ydU0Gy|IZ zXJ_|zwLg4$B`^zKYg%l)LC*h63~KaHpa(1l2QE)&L-BX#saHBovuf~dm$X;TWgZ3^z|^;enzj_vgsX28+P== z1g#k33Mdl;W)o_+5MbR=1kQpO4B;wz`dnuYH;y6291Uu!S|jLym8>25G^ns+C`|i zU8?IW9*CTp+=#b1v3;Y^#gnj$#!+9~-|sxPtwrGTnms&B|#kyO6t`q~ZN) z-8vvD?Ni@K@@%2GwR4uD&%*w#xr>S@m~0^g3?_xG3yIyrQ6CRV_fuPnl-F=d`^?AX zqN8(~H)ERx><1xs6#_(7nFZ`Zn_$C<#Z#QKAMgjK6vXqkHN7lIM;2$a1`)G#dsp%3MXqQ{wZ zwi49qr;`zM68#yL*fzn`Zy;0UBVsAP5wjv8#}+Jr6m95Y0IfCV>V@ zbvtmr^LW8tUX$RWhiO>rp3Pf?u+B`GXp!>LMLVc9;05>a2 zJg&o$#;ZRz!6o zM+aOFeHgyi|3y;1HT~s)0vwjT4$uB`XqNHkGX|JE3rwSFZ*FXNO{*$x@XYAHF9euB zOPxR!tj6$=>Vc>ncnWFF6=Cu99TnveWvY;dB}fO*=jz$8^2oqZvCVhm(a3G)qhAId ziV&ZT=VdcI9fO~7JK{PfaAVnG(*ZCt_Gm>VlrhcJCtGjNTzP;?wh=9v`JIn#X!msA zrLV3}(zQ`NaiNV3U3C~@kypU2h{+$9cwifsq_f9O3rdU|0O>qFI?u;RqBqZNk7CJ7 z&bN5b6@lA2*K)iFnm1ZEIXsuEH-G)9!0fG@{es$9F}EXXf&2jKmJ2XsA)#caL_WWR z%TUPo6YkgK%^KbYtN3KnXElrVV?)7Iiq_SM^EO=WBOg{NQMP1~G<(Q$3etTtTooqz z269cn+^c>ZMaZxzD5hOH3l;p01qzD($UBz$R-@*KY#gO_`+f$w%N(Y`qyzct>8$qn z(+{*ZcOuU)#rtx|LZeXJ6=uvQ*lAgZmS|T@5O(s(D-a@Q?ayr@5L|2|Tg~@b_c>L2 z__306iq%m+V~qF|ACYkfKw@2R_x8;s&L%G&lTqswsbbZVW)adc+qf&Yk}xvc$5*Hs zagVTD?4VmRkx@0Huq5{>Ow41}GC-pn#uq1j{9>W!C#!^^&O#Qorn9Wg!-y6qM@Hue zltD~1T;WZB6p^cj=UtOntm|I}@3!o)2xEg7*X)Edk0Ky-fK zlJUBV+WA!)1|scHcmS1IS2+dMSbQ}7NBA4QZRYmjr15bEDB4JAnZ6yNQiy?}GU=8m z_LO*ACAVB!>ot4aZyUb(31GXc726pp{V9T{ZRe%vRC6#z(=tk)TL`C@5^K44rw?Rc z8~V=G3jbs~jxAArcF7d=(p)!m3ZHE@(5)^HA(K&E$5purbnHLtrd+b1-SlP`yS-_; zs(gPp);eC|BcB<--$ZA`Au9>%nZ%-H1n=5LuR*yuxjlpLK*OW~vo;pieYmOMNo8z< z+{>&h_|o*b5d+!4{Bv@D%CMklf!yP%?_o%UGk~!?^Q!^RMVLaTwYAdnjP;IzQ{C?c zuv>6|@i^+h&RwZ;u|OiYaI_~Y6sX_jGX0em)A^-l%B=R6_r`ejX4>>UJlGQyzhV~7 z7UEBjwMkz-AT;7Xgt~{a*NJoNIm<$|I*%{rk>Q^tFv!s@@a#Mxb9>7Mb?>Az3}5i# z!9W1HO)g>Q5n&fA5aAvP*WA(9Y(Kf6g1{H5*0SPOUN7o z%p2P2;4o09l~86ea|C^7znvop!ESRRyq*>}tr7vf(QOR$_V6riVv1WZZMV_ zKij&hvKF1vkP+LX!sPq`E!kNfBc7y$#~taz9UtA^7UgprsF_)y1;~Ry_)q*ZW1d$u zqTCy4I+?UI;f#B&DRznrAxfgrw=NkepspfGl1l)dh|){D2A1IphvFkWOeauvL9~n2 z{o`fCZZJ)G^evX4-41DP47S>$`O!em#-`S{Y8;T=5#(93h%qaig2 zNmzuYSAr{EEKnEE-X33eLrh`|7yCHEB8*K7K*Cun0!UEEj<%37yhOGHNSO6mpYAIp5NPaVSc9C{I!#62fF6mIEQ4?8sMEpE(o=9mky-V=L8TK-b^EV2!m+2m4c zE`)fOy&l!gie&EN`Ek<@>`rXD)UmsnW@E`k7%Gp$r;^e0*w*1J)T{t5)P{BLE`2p` z&RBkKZr)Qg@}QG7xp=00&A9}j zX{i}A7m@cV8btO(?xp&b;}E^r2}nJz3h8y8pJx=@4l>nsYb5BcKF*{ToSh4=-9g0Z zb)Ji2yc{J+v)`fAIQ*0+$Ty4SWD6T^=&0j{mFn`11?MH)Q@yG|joP^5P4BJ0GU{b9 zgG5``R2p!< zw1h!cv@m@@tjbOb-RiMdHA%4np26r3-GoG1E02X?W2~^SdUx)7d>7iq+4=HpfWm5R zCpo!$I^k@p-O+Tb`|;KJE}tjIvCr&A$&(u1aB=^IeS{I#$b(3GPC!WZft!euv0VQL zC%s;qM6RkX^&1BcQrKyq7b0%POVNLs7aEl%;X^dLxIf53jKVU zglZ0=okrM<2-%2jaNEZWGoD1kMSq!kv-+|pFQiQQo2AI5-1Si|v-Q{q+>$bF{R5vZ z0C>c{yy0gt>F|T%0-#sV5Bu=zmfMSY#~DmRI;%W*QyMF`fy?`8FxHofRh8L(pd9#& zb#iol1;`+wfFl3JT0dU7-!|pTa}F#4QlkMg*>x?oPL}e6FZUHIvy|EIqrsYGWzr5$ zp@6iWZVrWKSuy$KeXz2Iuw(8;M-&mgRI~;xo%M(6LqJY4BfqL*fgm;sdhZ8$%%bha zV1l61PHI34+lfw>Ys^~&4_$@Gbyk96Fef~;C{I}nK^DJG4XR|F)VJX&^V9dQZ-0oF zs6F8V+NWkvnni`AZ{LI}_J-hjhS~u)LLWEdY%H7*2{Dd=6*hs#TVU(J{fIq;An{!+ zn2E9-@ zZegpT_rXE8G#>nRy1^`PFscA@zvj@9dGerv1~1twD#bfWccCk}f9M(4R{{G+Xdpid z4xBBuZILxf;B5LMn~+%BC-~XsWfrFfI9JkG)0Ea%6w{014m)B|PL90ub8p2(2DX-m z8?3bf3dwMt1y(-_Q2g5?ZKI)b{kntGy^O zp23Ri;p0|TF733ZsFj*xQr3P(ET~^qr-%Ob<#$0~iCatY$H(a5T^5l6?ZBtp{7vXQ zswhdYscNN2y}nq5&+3AbZR>Vge}&Z;H@7ju4fN-=R2H-N%(&1+D#e>ru!x5(jVW>-HDcn3e*n zX1htG12i+^(gW&O{DdEi>_@-j^(U z5T3QjimlU@`B}qoK9=p6o#<6w?iB(~(kClUtuxD(6}y;MFESngI9m=Us@f$T%|J3o zaoL+0g0JBW&jdJMa~}E=kv)HGzSH0Lgd#`o(Qq3ifipq)M6qS)7`H8v+*#2#r>--C zY?X#Q0X!EvL9bjjNDeQq0*V^6J7^wA%Y*+*DXL{8cs1lFa466*l`Nh`wO$%hdBqOg^;OhX_VF} zQ6#S&_o-~%bm(%qpZ1v2$Y;I{dKilI)ZE)G*vKq9Pqb613ivS`X=&7f3>Zj- zKSd~}t{_w6Q!b&AvGTg_Wb@uJRrO;}Dx1|NiU&@Kn;TRk$|Y!rQcdH=8}F4%Uin(t z7W2uCLUq1ke+IBGzen))VEU<<)I-U z0r4L<3L+0=Bqfwp7!@S{(bc_0k~d^v5F7A^<(4Z9bO;D*TT>>}zxdIZo>-bQ-Oxf5 zu{C{R1?I8_3!WI;{AA&Kx8;|*Sxc|L%Yq3oukW?i;txy2_!Z7iCCTnOhujvVxsL8s zfLHR@l372@_uj9Z|0RHCOCe$cR#W&Fklmg2`(30gFlmnpxCv3<{R00jBpGmt)jxOF z-$7!m3g&ipU^Se7bt!nHfCVe;jepb31OcpxVKAgDnDqH}GqWiE0P=4v zM*~~qfA#gBV5Y@bA7+3DzB?F~`&QR(f^X2@Ud?}D{yE%DCHvdM^n&(};grErGS5tZ z)0sC#(phgcEQtOOkp8?$H#Mq-ZUMzJ{sGV*DzM)jo;M|3Z%-!PEWbznP2b&=Q@riG zlk>lv|J75!(1^Wz<~L>kt`!-7SU%tHo&RgV{pS2{s#)D0Wse1JLHtLi=ug!I?>6S9 zLejN_$q!o>{RPthtd(^a_okAL;4NH8iCeh;A2p`Cpf{CVu0?u&n3B{j(0^wQ{z$Ut zF3L@@iQ8Q&Df3g5{|HR{ZyGUoac@%YUrSm1Fhqr4PyPM@@$21lzgbIt%?SF#R&{=X@po9`C;Xsy0dCeKT$g13uui+5 z0{puM;jR|cUB@?HjlbPHOP;@U{EOm-yBIgK!q+d^|FClJUt#>_!rsi?U8j_P7-95J z-TpMeeD`E;CZujp^Iu|r>h)Jyz`M?GhLx{#T0cxN{^!pBAj5SRyKy50$qLSTURK|Fca-~JC(R-+UE literal 0 HcmV?d00001 diff --git a/android/gradle/wrapper/gradle-wrapper.properties b/android/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..7e7d24f --- /dev/null +++ b/android/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,7 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-9.6.0-bin.zip +networkTimeout=10000 +validateDistributionUrl=true +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/android/gradlew b/android/gradlew new file mode 100755 index 0000000..adff685 --- /dev/null +++ b/android/gradlew @@ -0,0 +1,248 @@ +#!/bin/sh + +# +# Copyright © 2015 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# SPDX-License-Identifier: Apache-2.0 +# + +############################################################################## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/android/gradlew.bat b/android/gradlew.bat new file mode 100644 index 0000000..e509b2d --- /dev/null +++ b/android/gradlew.bat @@ -0,0 +1,93 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:execute +@rem Setup the command line + + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/android/settings.gradle.kts b/android/settings.gradle.kts new file mode 100644 index 0000000..d146651 --- /dev/null +++ b/android/settings.gradle.kts @@ -0,0 +1,52 @@ +pluginManagement { + repositories { + google() + mavenCentral() + gradlePluginPortal() + } +} + +dependencyResolutionManagement { + repositories { + google() + mavenCentral() + } +} + +rootProject.name = "kadence-android" + +// `core` is plain Kotlin on the JVM: the matchers, the policy clock, the outbox +// reconciliation, the Glyph frame and the formatting. No Android, no device, no SDK — +// which is the whole point. `./gradlew :core:test` runs the logic suite on a machine +// that has nothing but a JDK, so almost none of this app needs a phone to verify. +include(":core") + +// `app` is the Android client and genuinely needs an SDK. Including it +// unconditionally would make every Gradle invocation fail on a machine without one, +// taking `:core:test` down with it — so it joins the build only when an SDK exists. +val androidSdk: java.io.File? = sequenceOf( + System.getenv("ANDROID_HOME"), + System.getenv("ANDROID_SDK_ROOT"), + file("local.properties") + .takeIf { it.isFile } + ?.readLines() + ?.firstOrNull { it.startsWith("sdk.dir=") } + ?.substringAfter('=') + ?.trim(), +).filterNotNull() + .filter { it.isNotBlank() } + .map { file(it) } + .firstOrNull { it.isDirectory } + +val appModule = file("app/build.gradle.kts") + +if (androidSdk != null && appModule.isFile) { + include(":app") +} else if (androidSdk != null) { + logger.lifecycle("SDK found, but app/ is not built out yet — :app excluded.") +} else { + logger.lifecycle( + "Android SDK not found (set ANDROID_HOME or local.properties' sdk.dir) — " + + ":app is excluded from this build. :core still compiles and tests.", + ) +} diff --git a/desktop/kadence_desktop/qml/ReportPage.qml b/desktop/kadence_desktop/qml/ReportPage.qml index 461e098..e1b95d3 100644 --- a/desktop/kadence_desktop/qml/ReportPage.qml +++ b/desktop/kadence_desktop/qml/ReportPage.qml @@ -41,8 +41,8 @@ ScrollView { caption: page.metrics && page.metrics.goal_met ? "goal met" : "goal not met yet", accent: true }, { label: "Focus", - value: page.metrics ? page.metrics.focus_minutes + "m" : "—", - caption: page.metrics ? page.metrics.break_minutes + "m resting" : "" }, + value: page.metrics ? Theme.humanMinutes(page.metrics.focus_minutes) : "—", + caption: page.metrics ? Theme.humanMinutes(page.metrics.break_minutes) + " resting" : "" }, { label: "Score", value: page.payload ? "" + Math.round(page.payload.score) : "—", caption: "out of 100" }, diff --git a/desktop/kadence_desktop/qml/Theme.qml b/desktop/kadence_desktop/qml/Theme.qml index be42ee7..a0969a1 100644 --- a/desktop/kadence_desktop/qml/Theme.qml +++ b/desktop/kadence_desktop/qml/Theme.qml @@ -70,4 +70,15 @@ QtObject { if (kind === "long_break") return "Long break" return "Focus" } + + // Mirrors the web app's humanMinutes() in lib/format.ts, so "125m" reads + // as "2h 5m" here too. + function humanMinutes(minutes) { + var rounded = Math.round(minutes) + var hours = Math.floor(rounded / 60) + var rest = rounded % 60 + if (hours && rest) return hours + "h " + rest + "m" + if (hours) return hours + "h" + return rest + "m" + } } diff --git a/desktop/kadence_desktop/qml/TimerPage.qml b/desktop/kadence_desktop/qml/TimerPage.qml index e1fd067..99c7ffe 100644 --- a/desktop/kadence_desktop/qml/TimerPage.qml +++ b/desktop/kadence_desktop/qml/TimerPage.qml @@ -213,10 +213,10 @@ ScrollView { Label { Layout.fillWidth: true text: controller.stats.today - ? controller.stats.today.focus_minutes + "m focused · " - + controller.stats.today.break_minutes + "m rested" + ? Theme.humanMinutes(controller.stats.today.focus_minutes) + " focused · " + + Theme.humanMinutes(controller.stats.today.break_minutes) + " rested" + (controller.stats.today.longest_stretch_minutes > 0 - ? " · longest run " + controller.stats.today.longest_stretch_minutes + "m" : "") + ? " · longest run " + Theme.humanMinutes(controller.stats.today.longest_stretch_minutes) : "") : "" color: Theme.muted font.pixelSize: 12 @@ -280,7 +280,7 @@ ScrollView { Repeater { model: [ { label: "Focus today", - value: controller.stats.today ? controller.stats.today.focus_minutes + "m" : "—", + value: controller.stats.today ? Theme.humanMinutes(controller.stats.today.focus_minutes) : "—", caption: controller.completedToday + " intervals" }, { label: "Interruptions", value: controller.stats.today ? "" + controller.stats.today.interruptions : "—",