From 45ca3243feddc7dc7aad70b8e8337e9329bff51e Mon Sep 17 00:00:00 2001 From: Jean-Luc Makiola Date: Fri, 17 Jul 2026 09:47:36 +0200 Subject: [PATCH] core-locale: locale-aware date formatting (currentLocale, localizedDateFormatter) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Both functions lived in Calendula's ui/common/LocaleSupport.kt. Neither is calendar-specific — "lay this date out the way this language writes dates" is family plumbing — so they move here, where Agendula can reach them too. localizedDateFormatter(locale, skeleton) takes a field list ("LLLLy", "dMMMy") and lets the locale arrange it, which is the only way to render a date correctly in a language you didn't hand-write a template for. Dropping a field from the skeleton drops it from the output, so callers ask for "no year" by omitting it rather than post-processing a longer pattern. currentLocale() reads the display locale from LocalConfiguration. This module's own AppLanguage.apply() changes the language inside a running process, so a locale captured once goes stale; keying on the configuration makes the UI follow the switch. core-locale gains Compose (runtime + ui only) for currentLocale(). Its build file previously declared itself Compose-free, but the alternative — parking the hook in a Compose module that depends back on this one — splits one concern across two modules to honour a comment. core-crash is the precedent for a core-* module carrying Compose. Leaves core-time's Instant.formatDate() family alone despite the overlap: it is unused by Calendula but visible to Agendula, so reconciling it is that app's call, not a drive-by here. Noted in the changelog. Co-Authored-By: Claude Opus 4.8 (1M context) --- CHANGELOG.md | 32 +++++++++++++++++ README.md | 2 +- core-locale/build.gradle.kts | 34 ++++++++++++++++--- .../floret/locale/DateFormatting.kt | 33 ++++++++++++++++++ .../floret/locale/LocaleCompose.kt | 26 ++++++++++++++ 5 files changed, 121 insertions(+), 6 deletions(-) create mode 100644 core-locale/src/main/kotlin/de/jeanlucmakiola/floret/locale/DateFormatting.kt create mode 100644 core-locale/src/main/kotlin/de/jeanlucmakiola/floret/locale/LocaleCompose.kt diff --git a/CHANGELOG.md b/CHANGELOG.md index cbdbfe5..b355af0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,38 @@ are no binary releases; "version" tracks the shared `version` in the root build ## [Unreleased] +### Added + +- **`core-locale`** — the locale-aware formatting half of the module, so apps + stop hand-rolling `"$day. $month $year"` templates that bake one language's + field order (and its separators, and its ordinal dot) into every language they + ship: + - `localizedDateFormatter(locale, skeleton)` — a `DateTimeFormatter` for a + field skeleton ("LLLLy", "dMMMy", "EEEdMMM") laid out in the locale's own + order, via Android's best-pattern matching. Drop a field from the skeleton to + drop it from the output — the locale still supplies the arrangement. + - `currentLocale()` — the display locale, observed from `LocalConfiguration`. + Since `AppLanguage.apply()` changes the language inside a running process, a + locale captured once goes stale; this keys recomposition to the change. + +### Changed + +- **`core-locale`** now carries Compose (runtime + ui only) for `currentLocale()`. + The module previously declared itself Compose-free; applying a language + mid-process is its own API, so the hook that makes the UI notice belongs beside + it rather than in a Compose module depending back on this one. `core-crash` is + the precedent for a `core-*` module carrying Compose. + +### Known gaps + +- `core-time`'s `Instant.formatDate()` family now overlaps `core-locale`. Its + private `dateNoYearFormatter` strips the year by regex-ing the pattern string, + which `localizedDateFormatter(locale, "dMMM")` does properly; and its + formatters resolve `Locale.getDefault()` once at class-init ("locale changes + within a running process are rare enough to ignore"), which `AppLanguage.apply()` + makes untrue. Left alone for now — it is unused by Calendula but Agendula-visible. + Reconcile when Agendula next re-pins. + ## [0.1.0] - 2026-07-07 ### Added diff --git a/README.md b/README.md index 2d94e95..c406f73 100644 --- a/README.md +++ b/README.md @@ -36,7 +36,7 @@ See [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) for the full consumption mode |--------|------|---------------| | `core-time` | JVM | Date/time helpers: `DayWindow` local-day windows, locale/zone-aware `Instant` formatting, `TimeBridge` (millis ↔ `Instant`). No Android, no deps. | | `core-reminders` | JVM | Reminder-lead plumbing: the lead-time unit model (`ReminderUnit`, `decomposeReminderMinutes`), the per-target override model (`ReminderOverride` + `reminderLeadFor` / `applyReminderOverride`) and the stored-format codec (`ReminderOverrideCodec`, separators configurable per app). Each app layers its own DataStore + string labels on top. | -| `core-locale` | Android | Per-app language plumbing (`AppLanguage`): read the shipped languages from the app's `res/xml/locales_config.xml`, get/set the applied language via `AppCompatDelegate`, render each language's autonym. The app passes its own `locales_config`; appcompat only, no Compose. | +| `core-locale` | Android | Everything "what language are we in". Per-app language plumbing (`AppLanguage`): read the shipped languages from the app's `res/xml/locales_config.xml`, get/set the applied language via `AppCompatDelegate`, render each language's autonym. Plus `currentLocale()` (observes the applied language from Compose) and `localizedDateFormatter(locale, skeleton)` (lays a field skeleton out in the locale's own order). The app passes its own `locales_config`. | | `core-crash` | Android | Privacy-respecting on-device crash capture + report dialog + issue-tracker hand-off. Parameterized per app via `CrashConfig`. | | `identity` | Android | The M3 Expressive theme factory `FloretExpressiveTheme(…)`, `rememberNavSlideSpec()`, the content transitions (`expandEnter`/`collapseExit`/`itemEnter`/…) and the `predictiveBack` peek. Each app supplies its own seed/palette. | | `components` | Android | Shared Compose vocabulary + recipes: `GroupedSurface`/`GroupedRow`, `InlineTextField`, `OptionCard`, `CollapsingScaffold`, `OptionPicker`, `ReorderableColumn`, `DebugRibbon`, `pastelize()`, `DialogControls`, `OnboardingScaffold`, `OptionalFormSection`, `AboutCard`, `LanguagePickerRow`. | diff --git a/core-locale/build.gradle.kts b/core-locale/build.gradle.kts index bec725c..02636b4 100644 --- a/core-locale/build.gradle.kts +++ b/core-locale/build.gradle.kts @@ -1,10 +1,20 @@ -// core-locale — per-app language plumbing shared across the family: read the -// shipped languages from res/xml/locales_config.xml, get/set the applied -// language via AppCompatDelegate, and render each language's autonym. App- -// agnostic — the consuming app passes its own locales_config resource id; no -// Compose, no DataStore. +// core-locale — everything "what language are we in", shared across the family: +// read the shipped languages from res/xml/locales_config.xml, get/set the applied +// language via AppCompatDelegate, render each language's autonym, observe the +// current locale from Compose, and format dates in that locale's own field order. +// App-agnostic — the consuming app passes its own locales_config resource id; no +// DataStore. +// +// Compose is here for currentLocale() alone: applying a language mid-process is +// this module's own API, so the hook that makes the UI notice belongs beside it +// rather than in a Compose module that would have to depend back on this one. +// (core-crash is the precedent for a core-* module carrying Compose.) Deliberately +// lean: runtime + ui only, no material3, no foundation. plugins { + // AGP 9.x provides built-in Kotlin compilation, so only the Compose plugin is + // applied alongside the Android library plugin. alias(libs.plugins.android.library) + alias(libs.plugins.kotlin.compose) } android { @@ -20,6 +30,10 @@ android { targetCompatibility = JavaVersion.VERSION_17 } + buildFeatures { + compose = true + } + testOptions { unitTests { all { it.useJUnitPlatform() } @@ -39,6 +53,16 @@ dependencies { // annotation (XmlRes) transitives. implementation(libs.androidx.appcompat) + // ConfigurationCompat for currentLocale(). Reachable transitively via + // appcompat, but declared because this module uses it directly. + implementation(libs.androidx.core.ktx) + + // currentLocale() only needs the runtime (@Composable, remember) and ui + // (LocalConfiguration) — api() so consumers can use the returned Locale in + // their own composables without re-declaring Compose themselves. + api(platform(libs.androidx.compose.bom)) + implementation(libs.androidx.ui) + testImplementation(libs.junit.jupiter.api) testRuntimeOnly(libs.junit.jupiter.engine) testRuntimeOnly(libs.junit.platform.launcher) diff --git a/core-locale/src/main/kotlin/de/jeanlucmakiola/floret/locale/DateFormatting.kt b/core-locale/src/main/kotlin/de/jeanlucmakiola/floret/locale/DateFormatting.kt new file mode 100644 index 0000000..bbf7c7f --- /dev/null +++ b/core-locale/src/main/kotlin/de/jeanlucmakiola/floret/locale/DateFormatting.kt @@ -0,0 +1,33 @@ +package de.jeanlucmakiola.floret.locale + +import java.time.format.DateTimeFormatter +import java.util.Locale + +/** + * A [DateTimeFormatter] for [skeleton]'s fields laid out in [locale]'s own order, + * via Android's best-pattern matching. + * + * A skeleton lists the *fields* you want, not their arrangement: "dMMMy" asks for + * day, abbreviated month and year, and the locale decides that en-US renders + * "Jul 17, 2026" while de-DE renders "17. Juli 2026". Hand-rolled templates like + * `"$day. $month $year"` can't do this — they bake one locale's order (and its + * separators, and its ordinal dot) into every language the app ships. + * + * Drop a field to drop it from the output: "dMMM" is the same date without the + * year, still in the locale's order. Prefer that over post-processing a longer + * pattern, which cannot know which separators belonged to the removed field. + * + * Common skeletons: "LLLLy" (standalone month + year), "dMMMy" (day, month, year), + * "EEEdMMM" (weekday too). [locale] should come from [currentLocale] in Compose, + * so formatting follows an in-process language change. + * + * NB: this delegates to `android.text.format.DateFormat`, so it needs a real + * Android runtime — under unit tests with `isReturnDefaultValues` it yields no + * pattern. Test the skeleton *choice* in your own code; the layout itself is ICU's + * job and is not worth mocking. + */ +fun localizedDateFormatter(locale: Locale, skeleton: String): DateTimeFormatter = + DateTimeFormatter.ofPattern( + android.text.format.DateFormat.getBestDateTimePattern(locale, skeleton), + locale, + ) diff --git a/core-locale/src/main/kotlin/de/jeanlucmakiola/floret/locale/LocaleCompose.kt b/core-locale/src/main/kotlin/de/jeanlucmakiola/floret/locale/LocaleCompose.kt new file mode 100644 index 0000000..ec770a3 --- /dev/null +++ b/core-locale/src/main/kotlin/de/jeanlucmakiola/floret/locale/LocaleCompose.kt @@ -0,0 +1,26 @@ +package de.jeanlucmakiola.floret.locale + +import androidx.compose.runtime.Composable +import androidx.compose.runtime.remember +import androidx.compose.ui.platform.LocalConfiguration +import androidx.core.os.ConfigurationCompat +import java.util.Locale + +/** + * The current display [Locale], read observably from [LocalConfiguration]. + * + * Use this rather than [Locale.getDefault] anywhere a composable formats a date, + * a name or a number. [AppLanguage.apply] changes the language inside a running + * process, so a locale captured once — in a `val`, a top-level formatter, or a + * `remember {}` with no key — goes stale and keeps rendering the old language. + * Reading through [LocalConfiguration] keys recomposition to the configuration, + * so the UI follows the switch. (Android lint flags the alternative as + * NonObservableLocale.) + */ +@Composable +fun currentLocale(): Locale { + val configuration = LocalConfiguration.current + return remember(configuration) { + ConfigurationCompat.getLocales(configuration).get(0) ?: Locale.getDefault() + } +}