Author SHA1 Message Date
Incido Developer 765191ac8e docs(phase-1/m5.5): HiDPI correction — Xft.dpi is the real scaling mechanism
Controlled re-runs kill the M5.3 sun.java2d.uiScale verdict: the jpackage
launcher JVM picks the property up yet renders 1:1, in-process setProperty is
also inert, and 1.7.3 Window/rememberWindowState expose no scale arg (javap).
Xft.dpi IS the lever: xrdb 192 + plain bin/incido -> 1920x1016 (1090.dp
clamped), pixel RMSE 0.071 for the 2x-upscaled scale-1 crop (0.000 identical /
0.250 unscaled controls) -> glyphs render proportionally; HiDPI check CLOSED.
Also recorded: uinput virtual keyboard dropped by the compositor like XTEST
(keypress check is physical-keys-only), branch pushed to origin, and the tag
run held for user decision since v*.*.* also fires release.yml.

Verify: bin/incido under Xft.dpi=192 geometry 1920x1016, under 96 -> 1090x730
restored; magick compare RMSE 0.0707 (b6 vs 2x-a), controls 0 and 0.2497;
Main.kt --ui-scale experiment reverted (git checkout, tree was clean).
2026-10-06 23:52:45 +13:00
Incido Developer 9f6124a501 feat(phase-1/m5.5): perf pass legs --perf-smoke/--perf-verify; M5 closed
Seeds 3000 notes against the real streaming UI (279 ms total, ~0.09 ms/note),
fresh observeAll 70 ms, favorite toggle 1 ms, reopen first non-empty emission
89 ms; only 4 RENDER lines during the seed (size-keyed emission coalesces).
The multi-thousand-note unknown from the Phase-0 recommendation closes:
desktop perf is a non-event at 3000 notes. §7 marked DONE + handoff
"first actions" rewritten for post-M5 sessions (four pending-MANUAL checks
listed).

Verify: :desktopApp:run --args="--data-dir /tmp/incido-perf --perf-smoke
--exit-after 150" (PERF seed 3000/279ms, rc 0) then --perf-verify same dir
(reopen 89 ms, rc 0); :desktopApp:createDistributable + image --self-test
rc=0; --keys-smoke KEYS ALL-OK; :core:data-jvm:smoke M1a PASS;
assembleDebug SUCCESSFUL.
2026-10-06 23:18:27 +13:00
Incido Developer 6f16e87ec0 feat(phase-1/m5.4): desktop-release Gitea workflow — Linux packaging job
Tag (v*.*.*) + workflow_dispatch (same retry rationale as release.yml). Linux
runner only: jpackage cannot cross-compile and macOS/Windows GA is Phase 2
(§8) — commented job stubs record the matrix shape. createDistributable ->
image smoke under xvfb (SKIPPED-with-message if absent, never faked) ->
packageDeb only when dpkg exists (failure degrades to recorded skip) ->
tar.gz bundling packaging/incido.desktop + icon.png -> attach to the release
with release.yml's retry-and-verify upload pattern. .gitignore: root
libobjectbox-jni-linux-x64.so is ObjectBox CWD self-extraction noise.

Verify: python yaml parse (job + 6 steps); packageDeb/createDistributable/
printPackageVersion exist in :desktopApp:tasks; their local runs green per
M5.3 log. First real tag run remains the live check (recorded).
2026-10-06 23:10:11 +13:00
Incido Developer c894321fdf feat(phase-1/m5.3): packaging wired — derived version, icon/.desktop, image smoke, HiDPI+Wayland verdicts
packageVersion derived from app versionName (0.4.2.0 -> 0.4.2; printPackageVersion
task). packaging/icon.png + packaging/incido.desktop template ship the icon (1.7.3
DSL exposes no iconFile — recorded). Image smoke caught a REAL bug: jlink runtime
lacked jdk.unsupported, DataStore protobuf died on sun/misc.Unsafe only inside the
image; fixed via modules.add. createDistributable re-verified: 171 MB image,
bin/incido --self-test inside it rc=0. HiDPI: sun.java2d.uiScale=2 doubles requested
geometry (screen-clamp proves it). Native Wayland: AWT probe on JDK17 AND 27 both
resolve X11 XToolkit — stays XWayland; JBR bundling is Phase 2. New §3 traps +
M5.3 run log recorded.

Verify: :desktopApp:createDistributable (SUCCESSFUL, 171 MB); image bin/incido
--data-dir /tmp/incido-img-smoke --self-test --exit-after 6 (SELFTEST id=1, RENDER
notes=1, rc=0); :desktopApp:run --keys-smoke KEYS ALL-OK; :core:data-jvm:smoke
M1a PASS; assembleDebug SUCCESSFUL.
2026-10-06 23:05:54 +13:00
Incido Developer 0cad7729aa feat(phase-1/m5.2): tray + single-instance lock + first-run onboarding
SingleInstanceLock (OS FileLock on <dataDir>/incido.lock) claims the library
before the container starts; a second launch prints INSTANCE and exits 0 —
which also converts the wedged-child trap into a clean message. Tray
(ApplicationScope extension; Item/Separator menu) attaches only for
non-scripted, non-headless, SystemTray-capable sessions; close=quit kept.
First-run dialog explains the per-machine library + backup bridge, gated on
onboarded_v1 in the window store. Two new §3 traps recorded (Window
iconBitmap overload ambiguity; Tray receiver/params) + new harness legs in §1.

Verify: second launch same dir (INSTANCE ... exits, 0); interactive run
(TRAY attached, live KDE SNI); :desktopApp:run --args="--data-dir
/tmp/incido-m52-ob --onboarding-smoke --exit-after 8" (shown=true,
flag-persisted=true PASS) then --onboarding-verify (shown=false gate
respected); --keys-smoke KEYS ALL-OK; --self-test id=1;
:core:data-jvm:smoke M1a PASS; assembleDebug SUCCESSFUL.
2026-10-06 22:54:48 +13:00
Incido Developer 639f39d187 feat(phase-1/m5.1): desktop Esc back stack + Ctrl+N/Ctrl+comma shortcuts
JVM PlatformBackHandler made real (PlatformBackStack + LocalPlatformBackStack);
window drains it on Esc via Window(onPreviewKeyEvent) — the editor rides the
shared seam unchanged (draft flush + discard prompt). Shell registers
drawer/settings Esc; preview-phase shortcuts. New --keys-smoke leg drives the
exact dispatch headlessly. Keypress capture pending-manual (KWin/Wayland drops
xdotool XTEST events to the XWayland window).

Verify: ./gradlew assembleDebug :composeApp:compileKotlinJvm :desktopApp:build
(SUCCESSFUL); :desktopApp:run --args="--data-dir /tmp/incido-keys --keys-smoke
--exit-after 12" (KEYS ALL-OK); --self-test/--settings-smoke/--editor-smoke
green; :core:data-jvm:smoke M1a PASS.
2026-10-06 22:37:37 +13:00
Incido Developer faab0cde98 chore(phase-1/m4.5c): delete spike modules; record M4.4/M4.5 findings
6.6 executed: :spike:data-jvm and :spike:compose-jvm leave the build
now that :desktopApp hosts the real screens (M4.5b) — everything they
proved has a permanent home in :core:data-jvm, :composeApp (jvm) and
:desktopApp; their findings already live in the feasibility log.

tools/DESKTOP_FEASIBILITY.md gains the M4.4a-e + M4.5a-c entries:
seam inventory (image decode, editor intake, voice slot, platform
back, shared settings sections, JVM EXIF), the hide-not-fake §6.5
rulings applied, the harness note about cold-build run timeouts,
the M4.4/M4.5 verification suite, and the M5 next-up.

Verified post-deletion: assembleDebug :desktopApp:build SUCCESSFUL
+ run --self-test --settings-smoke --editor-smoke (SELFTEST id=1,
SETTINGS shown, EDITOR shown, ST_EXIT=0) + :core:data-jvm:smoke
(M1a PASS) + orientationSmoke (M4.4e PASS).
2026-10-06 19:55:26 +13:00
Incido Developer cce35587fc feat(phase-1/m4.5b): desktop shell hosts the REAL shared screens
DesktopShell replaces the M1b placeholder two-pane window with the
app's own composables from commonMain: NoteListScreen (search, FAB,
cards), IncidoDrawer (filters + recent hashtags, in a
ModalNavigationDrawer) and NoteEditorScreen (ViewModel, attachments,
intake seam) — all over LocalAppGraph provides DesktopContainer (the
M4.3 AppGraph face). App.kt's navigation reduces to three pieces of
state (filter / editor / settings). IncidoTheme (shared theme, static
palettes on JVM via the null platformDynamicColorScheme actual) now
themes the window.

The M2/M3 menu skins (BackupActions/SecurityActions composables) are
removed — dead UI once the settings screen drives their exact flows
(BackupFlows / SecurityKeyFlows / toggleDesktopEncryption all live on).
RENDER logging simplified (the shell owns selection now).

Scripted legs: --settings-smoke and --editor-smoke compose the real
screens headlessly — the editor leg proves its ViewModel + intake seam
work on the JVM (JetBrains lifecycle's fallback store owner; the last
open M4 unknown). Both run to clean auto-exit; earlier 124s exits were
cold-build harness time, warm reruns exit 0.

Verified: assembleDebug :desktopApp:build SUCCESSFUL + :desktopApp:run
--self-test --settings-smoke (SELFTEST id=1, SETTINGS shown, ST_EXIT=0)
+ run --self-test --editor-smoke (EDITOR shown, EST_EXIT=0)
+ :core:data-jvm:smoke (M1a PASS); models clean.
2026-10-06 19:48:37 +13:00
Incido Developer d264238640 feat(phase-1/m4.5a): desktop settings screen on the shared sections
DesktopSettingsScreen composes the M4.4d common sections (Appearance
/ Backup / About + building blocks) plus desktop-only Encryption rows.
Android-incapable surfaces are hidden per 6.5: dynamic-color row
(onDynamicColor null), Carnet importer (onImportCarnet null),
SecuritySection entirely (no BiometricPrompt/FLAG_SECURE on the JVM).

Flow dedupe so settings drives the EXACT M2/M3 behaviour, not a copy:
- BackupActions split: BackupFlows/rememberBackupFlows owns the pick+
  bridge + dialog machinery; the menu is now a thin skin (launchImport/
  launchExportPlain/launchExportEncrypted + Dialogs()).
- SecurityActions split: SecurityKeyFlows owns the recovery-key export/
  import dialogs (hasKey gate, overwrite warning, import leg);
  toggleDesktopEncryption() keeps the enable/disable ordering.
- M4.4d sections became PUBLIC (desktopApp is a separate module).

Main.kt: gear button routes list-window <-> settings in-place (no nav
stack yet — desktop nav polish is M5). New scripted leg
--settings-smoke renders the screen headlessly before auto-exit.

Verified: assembleDebug :desktopApp:build SUCCESSFUL + :desktopApp:
run --self-test --settings-smoke (SELFTEST id=1, RENDER notes=1
selected=1, SETTINGS shown, ST_EXIT=0) + :core:data-jvm:smoke
(M1a PASS); models clean.
2026-10-06 19:27:02 +13:00
Incido Developer 0dc5935d1d feat(phase-1/m4.4e): real JVM EXIF orientation normalizer
The §6.3 EXIF row deferred implementation to "M4+ when the JVM
attachment intake lands" — it landed in M4.4c, so the last NoOp
placeholder is gone. JvmImageOrientationNormalizer keeps the Android
contract exactly: orientation 6/3/8 -> bake 90/180/270 into pixels,
re-encode JPEG @ 0.92, return input UNCHANGED for normal/absent/mirror
tags or any decode/rotate failure.

Tooling differs, contract doesn't: com.drewnoakes:metadata-extractor
2.19.0 (first Central pull this phase — recorded) for the tag read,
BufferedImage + AffineTransform for the rotate, ImageIO JPEG writer at
explicit 0.92 for the encode. DesktopContainer now wires it into
NoteRepositoryImpl (was ImageOrientationNormalizer.NoOp).

New probe: :core:data-jvm:orientationSmoke hand-builds an
EXIF-Orientation-90 JPEG (APP1 splice — metadata-extractor is
read-only) and asserts: no-EXIF passthrough, EXIF-90 rewrite, pixels
rotated (4x2 -> 2x4), output stability, garbage passthrough.

Verified: :core:data-jvm:orientationSmoke (RESULT: M4.4e PASS, 5/5)
+ ./gradlew assembleDebug :desktopApp:build SUCCESSFUL
+ :desktopApp:run --self-test (SELFTEST id=1 -> RENDER notes=1
selected=1); objectbox-models clean.
2026-10-06 19:04:09 +13:00
Incido Developer 018db4819c feat(phase-1/m4.4d): shared settings sections to commonMain
AppearanceSection / BackupSection / AboutSection + the building-blocks
helpers (SettingsSection, SettingsToggle, SettingsRow) lifted verbatim
to commonMain as internal — desktop settings (M4.5) composes exactly
these. SettingsScreen keeps the Android-only Security section, the
PIN/biometric screens, the timeout dialog and all SAF wiring.

Design decision (as planned): full commonization of the 1026-LOC
screen buys nothing — SecuritySection is BiometricPrompt + PIN state
machines and the export/import pickers are SAF; sharing the sections
shares the UI, each platform keeps its plumbing. Two callbacks went
nullable to HIDE platform-incapable rows (dynamic color on desktop,
Carnet importer) — Android passes non-null so its pixels are unchanged.

Verified: ./gradlew assembleDebug :desktopApp:build SUCCESSFUL
+ :composeApp:compileKotlinJvm :composeApp:compileDebugKotlinAndroid
+ :desktopApp:run --self-test (SELFTEST id=1 -> RENDER notes=1
selected=1).
2026-10-06 18:56:44 +13:00
Incido Developer 6b5c24e1bc feat(phase-1/m4.4c): editor to commonMain; intake/voice/back seams
NoteEditorScreen + its private helpers move to commonMain. New seams (§6.3/6.5):

- EditorIntake (interface + expect rememberEditorIntake): Android actual
  holds the verbatim launcher code (camera TakePicture + permission
  chain, SAF OpenDocument, RECORD_AUDIO dance, FileProvider/
  ACTION_VIEW open, Toasts, createTempCameraUri/queryDisplayName);
  JVM actual = AWT FileDialog picker + Desktop.open/xdg-open, with
  supportsCamera/supportsVoice=false so the editor HIDES camera + mic
  buttons instead of stubbing them (§6.5).
- VoiceNoteSlot expect composable: Android renders the untouched
  VoiceNoteSection (MediaStore recorder); JVM renders nothing.
- PlatformBackHandler: activity-compose BackHandler on Android, no-op
  on desktop (Esc routing is M5 polish).
- securityManager param became the neutral beginExternalActivity:
  (() -> Unit)? lambda (Android names the Android type only in its
  actual; call sites unchanged). VoiceNoteSection takes the same
  lambda now; App.kt adapts the one call site.

Verified: ./gradlew assembleDebug :desktopApp:build SUCCESSFUL
+ :composeApp:compileKotlinJvm :composeApp:compileDebugKotlinAndroid
+ :desktopApp:run --self-test (SELFTEST id=1 -> RENDER notes=1
selected=1) + :core:data-jvm:smoke (M1a PASS); models clean.
2026-10-06 18:51:47 +13:00
Incido Developer 56949c485f feat(phase-1/m4.4b): image-decode seam; viewer + list move to commonMain
expect/actual decodeImageBytes (§6.3 image-decode): Android actual is
the verbatim BitmapFactory.decodeByteArray + asImageBitmap; JVM actual
is skia Image.makeFromEncoded().toComposeImageBitmap() with
runCatching to keep the null-on-failure contract BitmapFactory gave
the screens. Screens switch produceState<Bitmap?> ->
produceState<ImageBitmap?> and the three BitmapFactory call sites
(list thumbnail, viewer, editor thumbnail stays with the screen next
step). Dispatchers.IO -> the existing M4.3c ioDispatcher seam
(identical actuals).

Verified: ./gradlew :composeApp:compileKotlinJvm
:composeApp:compileDebugKotlinAndroid (BUILD SUCCESSFUL); full gate +:desktopApp:run --self-test + :core:data-jvm:smoke run at the end
of the step chain.
2026-10-06 18:31:08 +13:00
Incido Developer bdb3d7157d feat(phase-1/m4.4a): first screens to commonMain + shared clipboard
Pure moves: IncidoDrawer, ReleaseNotesDialog, PassphraseDialog
(clipboard: Context.getSystemService -> LocalClipboardManager, the
SAME API both targets ship in Compose 1.7.3 - the section 6.3
LocalClipboard+ClipEntry swap is a Compose 1.8-only API, recorded
for M5+). PassphraseGenerator moves behind an internal expect/
actual secureRandomInt (blockingFirst precedent; identical
SecureRandom actuals - both targets ARE the JVM).

New seams justified: secureRandomInt (java.security is not common);
commonMain gains jetbrains lifecycle viewmodel-compose +
runtime-compose (the SAME coordinates androidMain resolved since
M4.1) and material-icons-extended (moved with the screens).

Verified: ./gradlew assembleDebug :desktopApp:build SUCCESSFUL
+ :composeApp:compileKotlinJvm + :desktopApp:run --self-test
(SELFTEST id=1 -> RENDER notes=1 selected=1) + :core:data-jvm:smoke
(M1a PASS); objectbox-models clean.
2026-10-06 18:26:07 +13:00
Incido Developer 31408172df docs(phase-1/m4.3): M4.3 status + §1 gate output; plan handed to M4.4
Also two new §3 traps paid for during the gate re-run: daemon-surviving
desktop JVMs after a client kill (use pkill -9 before re-running against
the same data dir), and never parallelizing two --data-dir runs (leg B
against leg A's half-written library produces bogus FAILs).
2026-10-06 16:44:39 +13:00
Incido Developer 59bd6e106b feat(phase-1/m4.3c): ViewModels off APPLICATION_KEY; DesktopContainer implements AppGraph
Completes the M4.3 container seam:

* NoteListViewModel + NoteEditorViewModel (UiStates and SharedImage
  included) move to commonMain. NoteEditorViewModel had zero android.*
  imports; its four withContext(Dispatchers.IO) sites become
  withContext(ioDispatcher) — a new internal expect/actual whose ACTUALS
  are literally Dispatchers.IO on both targets, so Android behaviour is
  byte-identical (invariant §2.1), merely spelled through the seam.
* New commonMain EncryptionBadge/LibraryVerification: the read-only
  mirror of :core:data's EncryptionVerification. Required because
  :core:data is an androidLibrary invisible to commonMain and must stay
  so (invariant §2.3 — objectbox-android vs objectbox-java classpaths).
  AppGraph gains encryptionBadge; both containers map the real verifier
  result 1:1 at their own seam.
* SettingsViewModel stays in androidMain (SecurityManager, Keystore key
  provider, BackupManager Uri IO, CarnetImporter are genuine Android-only
  services — the graph was NOT widened to fake them, §9) but its factory
  now takes the concrete AppContainer via a new LocalAndroidContainer,
  provided alongside LocalAppGraph in IncidoApp. No APPLICATION_KEY /
  IncidoApplication reference survives in ANY ViewModel: all six call
  sites (drawer, list, editor, settings, pin setup, pin change) build
  factories from the graph/container locals at composition time.
* M4.3 exit proof: DesktopContainer : AppGraph — the same face
  (noteRepository/settingsRepository/encryptionBadge) the commonMain
  ViewModels consume, compiler-checked by :desktopApp building against
  :composeApp's jvm target. repository → noteRepository rename.
  The stand-in two-pane UI still runs (M4.5 consumes the real screens).

Verification (all green, one suite):
  ./gradlew assembleDebug :composeApp:compileKotlinJvm :desktopApp:build
      → BUILD SUCCESSFUL
  ./gradlew :desktopApp:run … --self-test --exit-after 6 → SELFTEST id=1, clean exit
  ./gradlew :core:data-jvm:smoke → RESULT: M1a PASS
  crypto legs (separate processes): leg-A ALL-OK → LEG-B PASS/ALL-OK
  git diff '*/objectbox-models/*' → empty
2026-10-06 16:42:48 +13:00
Incido Developer cd363c7aa5 feat(phase-1/m4.3b): AppGraph seam + first commonMain ViewModel (§6.4 probe GREEN)
M4.3's container seam, proven with the smallest ViewModel:

* commonMain di/AppGraph.kt — the platform-neutral container face
  (noteRepository + settingsRepository) plus LocalAppGraph /
  requireAppGraph. Scope discipline per §9: only services BOTH platforms
  can honestly serve; Keystore/SecurityManager/BackupManager/CarnetImporter
  stay on the concrete AppContainer.
* :core:settings + lifecycle-viewmodel enter commonMain (settings as api —
  AppGraph exposes it). Lifecycle coordinates are the SAME
  org.jetbrains.androidx.lifecycle 2.8.4 aliases androidMain already
  resolved since M4.1, so the §6.4 "verify the artifact set" question is
  answered GREEN for both targets and the state-holder fallback is NOT
  needed: DrawerViewModel moves with its androidx.lifecycle.* imports
  UNCHANGED (offline set keeps the androidx FQCNs).
* DrawerViewModel.Factory(APPLICATION_KEY as IncidoApplication) →
  factory(graph: AppGraph). AppContainer implements AppGraph; IncidoApp
  provides LocalAppGraph at the root (same fallback chain it already used).

Verification (one run):
  ./gradlew :composeApp:compileKotlinJvm assembleDebug → BUILD SUCCESSFUL
  (jvm target = first compile of a commonMain ViewModel on desktop deps)
2026-10-06 16:33:53 +13:00
Incido Developer 5bce1934c1 feat(phase-1/m4.3a): :core:settings → multiplatform (androidTarget + jvm)
Verbatim M4.2 (:core:domain) playbook — both source files moved UNMODIFIED
into commonMain (git records the rename; UserSettings.kt is a pure rename).
This is the visibility gate for M4.3's AppGraph: a KMP commonMain cannot see
plain kotlin("jvm") modules, and M4.3's container seam needs
SettingsRepository/UserSettings from composeApp commonMain.

One new seam, justified per §9 (never widen silently): kotlinx.coroutines
`runBlocking` has no commonMain declaration, so SettingsRepository.snapshot()
now goes through an internal expect/actual `blockingFirst(Flow<T>): T`.
Both actuals are the identical two-liner because both targets are JVM.
Same startup-safety contract (block off the UI thread at startup only).

Consumers unchanged by design: :desktopApp (plain jvm) and :composeApp's
androidMain resolve through variant metadata — zero import changes.

Verification (both green):
  ./gradlew assembleDebug :composeApp:compileKotlinJvm :core:data-jvm:smoke
      → BUILD SUCCESSFUL — RESULT: M1a PASS (one run, all consumers)
  ./gradlew :desktopApp:run --args="--data-dir /tmp/incido-desktop-smoke --self-test --exit-after 6"
      → SELFTEST wrote note id=1 → RENDER notes=1 selected=1
  git diff core/data/objectbox-models → empty (ID model file unchanged)
2026-10-06 16:27:10 +13:00
Incido Developer b774a1feb6 docs(phase-1/m4.2): M4.2 status; plan handed to M4.3 (container seam) 2026-10-06 12:23:00 +13:00
Incido Developer 9ad7c60537 feat(phase-1/m4.2): :core:domain → multiplatform (androidTarget + jvm); NoteColors to commonMain
Phase-0 recommendation #1 ("core:domain is already JVM-clean —
convert it first; zero code changes"), now unlocked by M4.1: common
source sets cannot see plain kotlin("jvm") projects, so the domain
deploy was the gate for making composeApp's commonMain depend on
Note/NoteColor/NoteRepository. Sources move untouched (pure renames);
Flow moves implementation → api (it is in the public repository
interfaces — was already leaking, now stated).

androidTarget() drags in the AGP plugin + a namespace — the module is
now a library-for-Android too, but emits no Android-specific code and
needed no manifest (AGP 8 + namespace). Plain-JVM consumers
(:core:data-jvm, :core:backup, :core:settings, :desktopApp) and AGP
consumers (:core:data, :app) resolve through variant metadata with
ZERO import or build-line changes — verified below.

Then composeApp: api(project(":core:domain")) in commonMain (up from
androidMain), NoteColors.kt moves to commonMain — first real shared
UI-layer file with a domain dependency.

Verified: ./gradlew assembleDebug + :composeApp:compileKotlinJvm +
:core:data-jvm:smoke (M1a PASS) in one run, and
:desktopApp:run --args="--data-dir /tmp/incido-desktop-smoke3
--self-test --exit-after 6" (SELFTEST wrote note id=1).
2026-10-06 12:20:05 +13:00
Incido Developer bce8e9a0dc docs(phase-1/m4.1): M4.1 status + §1 gate re-run output; plan carried to M4.2 2026-10-06 12:17:51 +13:00
Incido Developer fef8f9c2e9 feat(phase-1/m4.1): :composeApp in-place → Kotlin Multiplatform (androidTarget + jvm)
Plan §6.1 step 1, the conservative shape: build converts, Android code
moves UNMODIFIED (git shows pure renames; behaviour diff = zero), and
commonMain starts with only the files that compile for both targets
today — theme Color/Type, PasswordPolicy, ReleaseNotes, LinkedShare-
Composer — behind two new expect/actual seams (justification per §9):

* platformDynamicColorScheme — Android actual keeps the pre-M4
  Build.VERSION + dynamicColorScheme branch verbatim; JVM actual
  returns null (desktop hides dynamic color, per M3's posture).
* relativeTimestamp — Android actual is DateUtils verbatim; JVM
  actual is a java.time approximation of the same format (English-
  only until M4 follow-up; desktop has no locale switch yet).

New friction found paying itself into §3/§2 (all fixed in-tree):
* kotlinMultiplatform must be registered at the ROOT with apply false
  like the other Kotlin markers — sibling modules' markers put KGP on
  the buildscript classpath and the subproject request then dies with
  the kapt-style 'already on classpath with unknown version' (§2.5).
* KMP source-set dependency handlers: platform(libs.x) returns raw
  notation, not a Dependency — use project.dependencies.platform(…);
  debugImplementation is not on the handler (moved to a project-level
  dependencies block); androidTestImplementation dropped (no tests).
* ColorScheme is androidx.compose.material3.ColorScheme, NOT
  ui.graphics — desktop ships it inside material3-desktop, no extra
  artifact needed.
* AGP 8.7.2 > KGP 2.0.21's tested max 8.5 — warning only, same as
  the kapt modules; assembleDebug green.

Deliberate deferrals (documented in the build file): :core:domain is
still kotlin("jvm") so commonMain can't see it — NoteColors moves
when domain converts (M4.2, per the Phase-0 recommendation); screens,
ViewModels and AppContainer move with the container seam (M4.3).

Verified: ./gradlew :composeApp:compileKotlinJvm + assembleDebug +
:core:data-jvm:smoke (M1a PASS) + :desktopApp:run --self-test
(SELFTEST wrote note, clean exit) + git status clean over
core/**/objectbox-models (ID model file unchanged, invariant 2).
2026-10-06 12:15:15 +13:00
Incido Developer 6b8db18cdf docs(phase-1/m3.4): M3 status + scripted key-envelope legs; plan handed to M4
Closes milestone M3 (DESKTOP_PHASE_PLAN §5).

Code (one addition): --key-export / --key-import CLI legs in Main.kt —
the SecurityActions menu's exact codec calls, headless. This makes the
pending physical-phone leg a one-liner once a Waydroid container is
live (recipe recorded in the feasibility doc).

Docs: DESKTOP_FEASIBILITY.md gains the M3.1–M3.4 status section with
the actual run output (leg A/B, KEYENV logs, 0600 ls lines); plan §1
lists the two crypto legs among the must-stay-green commands; §5 marked
DONE; first-actions now point a fresh session at M4 task 1.

Exit criteria, per the plan's wording:
- encrypted desktop library passes EncryptionVerifier's trial-decrypt
  sweep: MET (leg A verified=1 failed=0, wrong key -> AEAD failure
  count, leg B relaunch all-ok).
- phone-exported recovery key decrypts on desktop: MET at format level
  (shared codec source, 84B INCKEY1 envelope, AEADBadTagException on
  wrong passphrase, byte-identical key into a fresh 0600 file); the
  physical phone export is FLAGGED pending (Waydroid container FROZEN,
  start is sudo-gated) with the exact re-run recipe — not assumed done.

Verified: ./gradlew assembleDebug, :core:data-jvm:smoke,
:spike:data-jvm:run, :desktopApp:run --self-test, and both crypto legs
— all green in one final pass (one self-test teardown hang under the
compositor, rc=124, clean on immediate rerun — recorded, environmental).
2026-10-06 07:39:54 +13:00
Incido Developer 000f4095cc feat(phase-1/m3.3): desktop at-rest encryption — key file, container wiring, security menu
Milestone M3 task 3 (DESKTOP_PHASE_PLAN §5). Three pieces:

1. DesktopKeyProvider — the JVM FieldKeyProvider. The plan's keyring
   condition is FAILed honestly: no keyring library is in the catalog
   and the candidates are unverified on this stack, so the sanctioned
   fallback applies: the 32-byte field key lives in `field.key` inside
   the library dir, written via temp+atomic-move with 0600 POSIX perms
   (File.setReadable/setWritable fallback for non-POSIX fs). It speaks
   the phone's recovery format natively through EncryptedKeyCodec
   (importRecoveryKey / exportRecoveryKey — INCKEY1, PBKDF2-200k,
   AES-GCM, wrong passphrase throws before anything is written).
   Key retention on disable: the sweep decrypts first, then flags
   clear, but the key file stays (Android's deleteKey-on-disable is
   Keystore-scoped; keeping it lets users re-enable and re-export).
   Stated, not silent.

2. DesktopContainer now mirrors AppContainer fully: settings -> cipher
   auto-install from snapshot (isEncryptionActive AND key on disk)
   BEFORE the repository -> NoteCryptoService -> EncryptionVerifier ->
   checkNow at startup. shutdown() cancels appScope.

3. UI: SecurityActions menu (theme cycle + encrypt/decrypt toggle +
   recovery-key import/export, incl. Android's overwrite-warning gate)
   reusing the backup menu's pickFile/PassphraseDialog (now internal,
   parameterized title/extensions). theme_mode drives Material3 via
   colorScheme (M3 MaterialTheme has no darkTheme param). dynamic_color
   / use_biometric / block_screenshots are NOT shown — no JVM
   equivalent, hide-don't-fake. Window geometry persists to its own
   incido_window.preferences_pb (desktop-only state; position left to
   KWin).

Verification (scripted legs in Main.kt, --crypto-self-test / --crypto-reopen):
  leg A: probe note -> key+cipher+sweep -> verifier trial-decrypt
    PASS (verified=1 failed=0) -> transparent repo read -> WRONG KEY
    REJECTED via AEAD tag -> INCKEY1 envelope 84 bytes, wrong-pw
    rejected, key byte-match -> LEG-A PASS.
  leg B (separate process = real relaunch): settings survived, cipher
    auto-installed, sweep all-ok, decrypt sweep reverses it -> PASS.
  :desktopApp:run --self-test regression green; assembleDebug green.
  ls confirms field.key is -rw------- (0600).
One environmental note: a leg-A run earlier in the session wedged in
XWayland window teardown (never reached exitApplication); the rerun
auto-exited cleanly — same one-off as the M3.2 startup wedge.
2026-10-06 07:26:17 +13:00
Incido Developer 40e2b9ff52 feat(phase-1/m3.2): FieldKeyProvider seam — AesGcmFieldCipher + EncryptionVerifier shared
Milestone M3 task 2 (DESKTOP_PHASE_PLAN §5): the cipher the desktop
build needs. AesGcmFieldCipher never touched Android APIs — only its
key SOURCE (ObjectBoxKeyProvider) did. New fun interface
FieldKeyProvider { getOrCreateKey(): ByteArray } in org.incido.data.crypto
is the seam; the class moves into the shared sources compiled by BOTH
:core:data (Android) and :core:data-jvm (desktop).

EncryptionVerifier (pure coroutines over NoteCryptoService) moves with
it — M3's desktop container needs the same trial-decrypt badge logic,
and the plan names the CipherHolder/NoteCryptoService/EncryptionVerifier
wiring as the thing to preserve.

Android diff is mechanical: AppContainer + SettingsViewModel pass
objectBoxKeyProvider::getOrCreateKey (SAM conversion) instead of the
provider object; NoteListViewModel's FQN import follows the package.
Behavior unchanged — same class, same bytes on the wire.

Justification for widening the seam (rules of engagement §9): the
interface replaces the concrete-class constructor parameter exactly as
planned; no other API moved.

Verified: ./gradlew assembleDebug (green) + ./gradlew :desktopApp:run
--args="--data-dir /tmp/incido-desktop-smoke --self-test --exit-after 6"
(green — :core:data-jvm compiles the shared crypto). One unrelated
GTK/XWayland window-startup wedge observed on a background run (process
never reached first composition; not reproducible on re-run, not a data
regression) — recorded for honesty.
2026-10-06 06:31:18 +13:00
Incido Developer 8db835640e feat(phase-1/m3.1): :core:settings — SettingsRepository shared, store injected
Milestone M3 task 1 (DESKTOP_PHASE_PLAN §5): move UserSettings +
SettingsRepository into a plain kotlin("jvm") module so the desktop
build reads/writes the SAME preferences keys and .preferences_pb format
the phone uses. Package name org.incido.compose.data.settings kept, so
the Android diff is file moves + one constructor change.

Seam: SettingsRepository now takes an injected DataStore<Preferences>.
Android supplies the preferencesDataStore(name = "incido_settings")
Context-extension store (new AndroidSettingsStore.kt, moved verbatim);
desktop builds it with PreferenceDataStoreFactory.create(
corruptionHandler = ReplaceFileCorruptionHandler, produceFile) — the
Phase-0 API delta (no Context extension on the multiplatform core
artifact). snapshot() keeps runBlocking for startup-only use.

DesktopContainer grows settingsRepository first, mirroring AppContainer
construction order ahead of M3's cipher install. dynamic_color /
use_biometric / block_screenshots keys ride along but have no desktop
UI — hidden, not faked (M3 exit rule).

Verified: ./gradlew assembleDebug (green; :app needed :core:settings on
its classpath — MainActivity reads userSettingsFlow, same pattern as
:core:domain) + ./gradlew :desktopApp:run --args="--data-dir
/tmp/incido-desktop-smoke --self-test --exit-after 6" (RENDER/SELFTEST
sequence intact) + ./gradlew :core:data-jvm:smoke (green).
2026-10-06 06:20:13 +13:00
Incido Developer 561d16eb0c fix(phase-1/m2.4b): encrypted imports were a silent no-op on-device
Manual Waydroid pass (phone exports encrypted -> re-imports the same
file through the real UI) caught it: the confirm dialog closed but no
import ran and no snackbar appeared. PassphraseDialog.onConfirm's
shared preamble nulls all URI slots before routing on mode, and the
IMPORT branch never re-armed pendingImportUri -- so the preview
confirm dialog's Import button read null and skipped viewModel.import
entirely. Plain-JSON imports bypass the passphrase dialog, which is
why every scripted desktop leg (M2.1-2.5) stayed green.

Fix: re-arm pendingImportUri in the IMPORT branch before preview;
wrong-pw/dismiss paths still null it and zero the retained chars.

Verified on-device after rebuild + `waydroid app install`: export
snackbar, magic-sniffed "Decrypt backup" sheet, 4-note preview, and
the dedupe snackbar "Imported 0 note(s), skipped 4 already imported."

Also lands the Waydroid test rig used for the pass (tools/WAYDROID_
TESTING.md + tools/inject2.c: uinput tap/move/key/text/swipe injector)
and the full M2.4b write-up in DESKTOP_FEASIBILITY.md. M2 exit
criteria met: bidirectional lossless round-trip plain+encrypted.
2026-10-06 05:40:44 +13:00
Incido Developer 29288b0370 test(m2): make :core:data-jvm:smoke idempotent — wipe its probe library in doFirst
The probe asserts exact note counts; running it twice in a row against the surviving build/data-jvm-smoke directory failed on count assertions (found while verifying m2.5). The task now cleans the directory like backupSmoke does.
2026-10-05 19:48:54 +13:00
Incido Developer 9cb7fdbf58 perf(phase-1/m2.5): export memory measured on synthesized worst-case libraries
Phase 1 M2 task 5 (tools/DESKTOP_PHASE_PLAN.md §4): measure & record,
no redesign. New :core:data-jvm:backupMemory probe (2g heap) samples
heap-used at 1 ms during BackupBridge.exportPlain — the phone's own
export path — across four fresh libraries:

  24 MB data (3 att)  → peak 230 MB   |  2 MB text x2000 notes → 140 MB
  80 MB data (10 att) → peak 777 MB   | 320 MB data (40 att)  → OOM at -Xmx2g

Attachments drive memory (~9–10x allocation pressure: store load →
base64 String → UTF-8 bytes → JsonElement tree); note count alone is
trivial. The plan's 250 MB gate trips at ~25–30 MB of attachments, and
the phone (no largeHeap) shares the ceiling — a pre-existing Android
limitation, unchanged by the bridge extraction. The real library
exports at 366 KB ≈ 1000x headroom. Bonus: a ~1.6 GB library dies in
objectbox-java's DbFullException before the bridge ever sees it.

Verdict: record, don't redesign. Streaming formatVersion=2 stays parked
for Phase 2, required only if attachment libraries approach ~25 MB.
2026-10-05 19:48:02 +13:00
Incido Developer 52ccceb732 feat(phase-1/m2.4a): scripted encrypted backup legs — the app round-trips ICDBKP1 envelopes
Phase 1 M2 task 4, desktop half (tools/DESKTOP_PHASE_PLAN.md §4). New
--backup-export-enc <path> + --backup-passphrase <pw> flags drive the
exact calls the RequirePassphrase/Passphrase dialogs make, headlessly.

Verified across two launches on fresh libraries:
  run A: import plain(27) → reimport skipped=27 → exported-enc=27 magic ok
  run B: preview encrypted=true → imported=27 → wrong-pw preview rejected
         → reimport imported=0 skipped=27

Gotcha found (and honoured): EncryptedBackupCodec zeroes the passphrase
CharArray in BOTH encrypt and decrypt — the array is single-use fuel.
The dialogs already comply (fresh toCharArray() per call); the scripted
block re-derives it via newPw() for the same reason.

Device half (4b: phone re-imports a desktop-made envelope + sees the
dedupe snackbar) follows on Waydroid with the M2 wrap-up.
2026-10-05 19:43:42 +13:00
Incido Developer 031d8570b4 feat(phase-1/m2.3): import dedupe — importing the same file twice adds nothing
Phase 1 M2 task 3 (tools/DESKTOP_PHASE_PLAN.md §4). Logic lives in
BackupBridge so both platforms get it through the one bridge:

- BackupBridge.import gains skipExisting (default true) and returns
  ImportSummary(imported, skipped). A note is skipped when the library
  already holds the key (createdAt, updatedAt, sha256(content)) — the
  triple the export preserves verbatim, trustworthy only since the M2
  import-timestamp fix. Keys are snapshotted BEFORE importing, so two
  genuinely identical notes inside one file still both import into a
  fresh library; only a second import of the same file is a no-op.
  Snapshotted keys include trashed notes. skipExisting=false restores
  the old additive behaviour (the documented override).
- Android: BackupManager.import passes the flag and returns the summary
  (signature-identical call for SettingsViewModel); its snackbar now
  reports the skip count. Screen layouts untouched — exit criterion
  "Android backup screens unchanged" holds.
- Desktop: the import confirm dialog swaps its "duplicates persist"
  warning for a working "Skip notes that are already here" checkbox
  (default ON); scripted path prints the re-import outcome.
- Format unchanged: formatVersion stays 1 (streaming/dedupe-at-format
  level stays a Phase-2 formatVersion=2 idea).

Verification passed: :core:data-jvm:backupSmoke (new step — re-import
skipped=27, override added 27, store=54; RESULT M2 round-trip PASS on
the real export) + :desktopApp:run --args="--data-dir /tmp/incido-m2t3
--backup-import <export> --backup-export … --exit-after 8" (imported=27
skipped=0 → exported=27 → reimport imported=0 skipped=27, clean exit) +
assembleDebug + :core:data-jvm:smoke + :desktopApp:run --self-test —
all green; output recorded in DESKTOP_FEASIBILITY.md.

Known limitation (by design): attachments are not in the key.
2026-10-05 19:33:07 +13:00
Incido Developer cf0e74b68d feat(phase-1/m2.2): desktop Import/Export — the phone bridge has a UI
Phase 1 M2 task 2 (tools/DESKTOP_PHASE_PLAN.md §4): :desktopApp can now
speak the phone's backup format through the extracted bridge.

- New BackupActions.kt: top-bar overflow menu (Import from file… /
  Export plain / Export encrypted). Import = AWT FileDialog ->
  BackupBridge.preview -> passphrase dialog on INCDBK1 (wrong passphrase
  stays open for retry) -> BackupPreview confirm dialog -> import.
  Export = save-picker -> exportPlain / passphrase + exportEncrypted.
  All heavy bridge calls run on Dispatchers.IO; results via Snackbar.
- Same package-level BackupBridge calls Android's BackupManager shim
  makes — format shared by construction, not reimplementation. Android's
  PassphraseDialog.kt deliberately NOT ported (M4 moves the real one to
  common code).
- :desktopApp gains implementation(:core:backup).
- Scripted headless path for CI: --backup-import/--backup-export drive
  the identical bridge calls without dialog clicking.

Verification passed: :desktopApp:run --args="--data-dir /tmp/...
--backup-import <real phone export> --backup-export /tmp/m2t4-exp.json
--exit-after 8" (preview 27 / imported 27 / exported 27, clean exit) +
:core:data-jvm:backupSmoke on the DESKTOP-written export (all PASS) +
python cross-check: notes (createdAt,updatedAt,content) and attachment
Base64 identical phone->desktop->phone + assembleDebug +
:core:data-jvm:smoke + :desktopApp:run --self-test — all green.
Output recorded in DESKTOP_FEASIBILITY.md (incl. one unreproduced
first-run exit hang to watch in M5).
2026-10-05 19:23:47 +13:00
Incido Developer 8facbe718b test(m2): backupSmoke — round-trip a real Android export through :core:backup, + import-timestamp fix
Phase 1 M2 verification probe, driven by a real phone export (27 notes,
1 attachment, 14 orphan tags; the file is user data and stays out of the
repo):

- :core:data-jvm:backupSmoke --args="<export.incido.json> [libDir]" —
  preview, import into a fresh JVM library, re-export + field-by-field
  compare, encrypted envelope export (wrong passphrase rejected),
  encrypted import into a 2nd library with attachment-byte equality.

The probe caught a PRE-EXISTING Android bug the phone also has: upsert /
saveNoteWithHashtags stamped createdAt+updatedAt to now on every insert,
so backup import rewrote every note's history — and would defeat the
(createdAt, updatedAt, sha256(content)) dedupe key M2 task 3 depends on.
Justified behavior change (invariant 1: not silent): non-zero caller
timestamps are now honoured, 0 still means now. The Android editor
passes its own stamps (verified at both Note(...) sites), so only the
import path changes. addAttachment gains createdAt: Long = 0L;
importSnapshot passes the phone value through.

Verification passed: :core:data-jvm:backupSmoke (RESULT: M2 round-trip
PASS on the real export) + assembleDebug + :core:data-jvm:smoke (after a
forced codegen regen: "ID model file unchanged") + :desktopApp:run
--self-test + :spike:data-jvm:run — all green; output recorded in
DESKTOP_FEASIBILITY.md.

Known pre-existing gap left open (documented): importSnapshot never
recreates orphaned hashtag rows.
2026-10-05 19:03:31 +13:00
Incido Developer 7cc4eda90d feat(phase-1/m2.1): :core:backup — codecs + stream-based BackupBridge
Phase 1 M2 task 1 (tools/DESKTOP_PHASE_PLAN.md §4): extract the backup
bridge from :composeApp into a plain kotlin("jvm") module so the desktop
build can import/export the phone file format.

- git mv BackupCodec / EncryptedBackupCodec / EncryptedKeyCodec into
  core/backup, keeping the org.incido.compose.data.backup package so the
  Android diff is file moves + one dependency line (no import churn).
- New BackupBridge: the four BackupManager operations over
  InputStream/OutputStream instead of Uri (incl. the v0.3.3.3 preview
  hotfix catches); BackupPreview moves with it, same package.
- BackupManager stays in :composeApp as a thin Uri -> stream SAF shim,
  public API unchanged. Dedupe = task 3, desktop picker UI = task 2.

Verification passed: ./gradlew :core:backup:build :core:data-jvm:smoke
:spike:data-jvm:run + assembleDebug + :desktopApp:run --args="--data-dir
/tmp/incido-desktop-smoke --self-test --exit-after 6" — all green; run
output recorded in tools/DESKTOP_FEASIBILITY.md (Phase 1 status).
2026-10-05 18:51:07 +13:00
Incido Developer b11c02e1b4 docs(phase-1): cold-start handoff plan for the desktop track
Adds tools/DESKTOP_PHASE_PLAN.md: everything a fresh session needs with no
prior context — current module shape, the exact commands that must stay
green, pinned versions, the invariants (tracked ObjectBox model file, the
objectbox-android / objectbox-java classpath rule, kapt and Compose
Desktop plugin quirks), the traps already paid for, and the M2/M3/M4/M5
milestones with exit criteria.

Every claim is checked against the working tree rather than remembered:
the coupling inventory (per-file android.* import counts), the 8
DataStore keys, AesGcmFieldCipher's single getOrCreateKey() call, the
portability of BackupCodec/EncryptedBackupCodec, and the pinned versions
(Kotlin 2.0.21, AGP 8.7.2, Compose Multiplatform 1.7.3, ObjectBox 4.0.3).

Open questions are marked as such rather than guessed — the JVM EXIF
decoder and OS-keyring libraries are unverified, and the AGP/KMP
friction around the composeApp conversion is called out as the least-known
part of M4, with a fallback shape and a time-boxed decision rule.
2026-10-05 18:38:52 +13:00
Incido Developer 5f45b0921b feat(phase-1/m1b): :desktopApp — desktop shell over the real repository
Phase 1 milestone M1b: a Compose Multiplatform window driven by the same
NoteRepositoryImpl the Android app uses, over its own ObjectBox library.

  DesktopContainer  mirrors AppContainer's construction order (store,
                    CipherHolder, repository). Owns its library at
                    $XDG_DATA_HOME/incido — a separate library per machine,
                    since ObjectBox is single-writer; the backup file (M2)
                    is the only bridge to the phone. --data-dir opens
                    another library, e.g. one pulled off a phone.
  Main.kt           two panes, save-as-you-type with a 400ms debounce,
                    favourite toggle. Material 3 defaults on purpose: the
                    app's theme and screens arrive with the M4 composeApp
                    conversion, which deletes this stand-in.

Verified headlessly (--self-test drives the same repository calls the "+"
button and the star make, --exit-after auto-closes), against a library
previously written by :core:data-jvm:smoke — i.e. a different module's
generated MyObjectBox, same schema:

  RENDER notes=0 selected=null    first frame (collectAsState initial value)
  RENDER notes=1 selected=1       ObjectBox flow delivered
  SELFTEST wrote note id=2        write path through the UI's own calls
  RENDER notes=2 selected=2       and it came back through the flow
  reopen -> RENDER notes=2        persisted

Gotcha recorded in the findings doc: the first composition always sees the
empty initial value of collectAsState, so anything asserting on note counts
must watch the flow rather than the first frame.

Still synthetic: theme + screens. Not wired yet: settings, encryption (M3),
backup bridge (M2), packaging (M5). assembleDebug verified green.
2026-10-05 18:28:24 +13:00
Incido Developer 9fe4763aa7 feat(phase-1/m1a): platform-neutral data layer + :core:data-jvm
Phase 1 milestone M1a (Development Plan §6, desktop track): make the whole
data layer usable from a non-Android build, without touching what the
Android app compiles.

:core:data splits its sources:
  src/main/kotlin      platform-neutral — entities, repository, field
                       crypto, NoteCryptoService. Compiled by BOTH
                       :core:data and :core:data-jvm. Must not import
                       android.*
  src/androidMain/kotlin  Android-only seam implementations.

Two seams were required, both identified by the Phase-0 spike:
  ObjectBoxStore          Context on Android, a directory on desktop. Same
                          FQN in sibling modules that are never on one
                          classpath — which is also what keeps
                          objectbox-android and objectbox-java (they ship
                          the same io.objectbox.* classes) apart.
  ImageOrientationNormalizer  EXIF rotation needs a bitmap decoder; the
                          implementation moved verbatim out of
                          NoteRepositoryImpl, which is now platform-free.
                          The parameter is required, not defaulted, so a
                          platform that forgets it fails the build.

New :core:data-jvm compiles those shared sources against objectbox-java /
objectbox-linux with its own codegen. `:core:data-jvm:smoke` runs the real
NoteRepositoryImpl (save + hashtags + attachment round-trip + close/reopen)
on the JVM: PASS, with the generator reporting "ID model file unchanged" —
one schema, two generated runtimes.

Also: .gitignore excluded **/objectbox-models/, so the schema contract was
never committed and a fresh clone regenerated UIDs. default.json is now
tracked; the rest of that directory stays ignored. This matters more now
that two modules generate from it.

Verified: :core:data-jvm:smoke PASS, assembleDebug green.
2026-10-05 18:20:59 +13:00
Incido Developer 8b66e82acb spike(desktop): Phase 0 feasibility probes + findings
Adds the throwaway Phase-0 spike (Development Plan §6.3) that answers
whether Incido can become a Compose Multiplatform desktop app without
abandoning ObjectBox, its crypto layer, or its UI layer. All six
questions came back PASS; findings live in tools/DESKTOP_FEASIBILITY.md.

  :spike:data-jvm    ObjectBox kapt codegen + native runtime on a plain
                     JVM, DataStore Preferences without a Context, and
                     the app's own EncryptedKeyCodec round-tripping.
  :spike:compose-jvm Compose Desktop rendering the app's real theme
                     layer + core:domain, plus jpackage packaging.

Additive only: nothing outside spike/ depends on these, and the Android
build is untouched (assembleDebug verified green).
2026-10-05 18:20:46 +13:00
Incido Developer f87ca17ded feat: v0.4.2.0 — voice notes (Opus 32 kbps mono), toolbar reorder, backup-first release notes
dev / Build debug APK (push) Successful in 57s
release / Build & attach release APK (push) Successful in 1m31s
Voice notes: record in-note via framework MediaRecorder; takes stored as compact Opus-in-Ogg (.opus, 32 kbps, single channel, 48 kHz) on API 29+ with AAC/.m4a fallback on API 26-28; MediaPlayer bar with Download to system Downloads. Editor toolbar reordered Photo / Voice / Attach / Tasks / Shopping list, hashtag justified flush right. Release notes across README / PREVIOUS_HISTORY / ReleaseNotes / CONTRIBUTING / Development Plan now open every release with a back-up-before-installing warning (standing convention). versionCode 38, versionName 0.4.2.0, APP_VERSION lockstep; assembleDebug + assembleRelease green.
2026-09-23 16:56:57 +12:00
Incido Developer 1d97376aef fix: v0.4.1.1 — saved notes leave Drafts; Enter adds row in price box
dev / Build debug APK (push) Successful in 47s
release / Build & attach release APK (push) Successful in 1m20s
Two editor regressions shipped in v0.4.1.0, both fixed here:

- Saving a note published it but left UiState.existing.isDraft = true,
  so the editor's dispose-time flushDraft() re-persisted the note as a
  draft and it reappeared under Drafts. The save path now adopts the
  published row into state (isDraft = false, current hashtags kept),
  letting persistDraftNow()'s already-published guard make that flush
  a no-op; saved notes stay on Home.
- Enter on a shopping-list Price field had no keyboard handler, so the
  bare ImeAction.Next fell through to system focus traversal and — the
  price being the row's last field inside the LazyColumn — wrapped the
  cursor back to the Title. The field now wires
  KeyboardActions(onNext = onAddAfter) like the Product field: Enter
  adds a fresh row with the cursor in its Product box.

Version lockstep per §11.1: versionCode 37, versionName 0.4.1.1,
APP_VERSION, README intro + current-release line + smoke-test
regression steps, PREVIOUS_HISTORY.md section, ReleaseNotes.RECENT
(v0.3.8.1 drops off the 5-entry tail), Dev Plan §10 row.

assembleDebug + assembleRelease both green (CONTRIBUTING step 4).
2026-09-23 06:14:36 +12:00
Incido Developer d9043db857 feat: v0.4.1.0 — colour filters, drafts, empty trash, editor polish
dev / Build debug APK (push) Successful in 58s
release / Build & attach release APK (push) Successful in 1m27s
Ships everything staged since v0.4.0.0 as v0.4.1.0:

- Colour filters: a five-swatch strip under the drawer's Favorites
  narrows the list to active notes of that colour (NoteFilter
  ByColor, observeByColor/searchByColor, color:<NAME> route).
- Auto-saved drafts: new notes persist as drafts while typed
  (Note.isDraft, Drafts filter + drawer row, debounced autosave
  with flush-on-exit) and ride along in encrypted backups.
- Empty Trash: a DeleteForever button + confirmation dialog in the
  Trash view; deleteAllTrashed() cascades hashtag xrefs and
  attachments exactly like delete().
- Editor row rebuild: EditorLineField unified on one underlined
  BasicTextField (M3 TextField's 56 dp min container was the root
  of the double-height rows); checklist controls centre vertically
  beside wrapping labels.
- Untitled drafts read "Shopping List — (draft)" on cards and in
  the editor bar via NoteType.displayName (display-only; stored
  content untouched).

Version lockstep per §11.1: versionCode 36, versionName 0.4.1.0,
APP_VERSION, README intro + smoke-test checklist, PREVIOUS_HISTORY.md
section, ReleaseNotes.RECENT (v0.3.7.0 drops off the tail), Dev Plan
§10 row.
2026-09-23 05:24:23 +12:00
Incido Developer d45cb7c31e docs(release-notes): drop stray trailing rule from v0.4.0.0 section
dev / Build debug APK (push) Successful in 3m16s
v0.4.0.0 was the only per-version section ending with its own '---', which combined with the CI footer divider rendered as a doubled rule on the published release. Removing it matches every other section (heading separated by a blank line) and is part of the same single-line-consistency cleanup.
2026-09-18 18:13:46 +12:00
Incido Developer 3d234f307e docs(release-notes): unwrap PREVIOUS_HISTORY notes to single lines
dev / Build debug APK (push) Successful in 3m21s
release-notes.py copies each version section verbatim, so the hard-wrapping in the v0.4.0.0 and v0.3.8.1 sections (and the file preamble) shipped as premature returns in the Gitea release description and Incido-<version>-changes.md asset. Unwrap them to one line per note, matching every section from v0.3.8.0 down. Also normalise the redundant '- **Title.** — desc' bullet heads to the house '- **Title.** desc' style across the file. Record the rule (write each note as one complete line; the release UI reflows it) in Development Plan 11.1 and CONTRIBUTING 5 so it does not recur.
2026-09-18 17:58:21 +12:00
Incido Developer ffa821bf28 docs(readme): sync README with the v0.4.0.0 release
dev / Build debug APK (push) Successful in 37s
Bump the intro + 'Current release' to v0.4.0.0 and add the new in-app Carnet/QuickNote (.zip) import to the feature list. Reframe the reinstall note: the new CI signing key dates from v0.3.8.1 and is reused on every release, so only installs from v0.3.8.0 or earlier need a clean reinstall; v0.3.8.1 onwards upgrades in place. Drop the now-wrong 'identical to v0.3.8.0' line, which predates the import feature.
2026-09-18 17:27:14 +12:00
134 changed files with 9686 additions and 1412 deletions

No files matched your search

+164
View File
@@ -0,0 +1,164 @@
name: desktop-release
# Phase 1 M5.4 — Linux desktop packaging (jpackage app-image + deb).
# jpackage cannot cross-compile (§7 of the phase plan), and macOS/Windows
# GA is explicitly Phase 2 (§8) — this job therefore runs ONLY on the
# Linux self-hosted runner; the deferred jobs at the bottom document the
# shape the matrix takes when matching runners exist.
on:
push:
tags:
- 'v*.*.*'
# Same retry rationale as release.yml: a tag push pins this file to the
# tag's commit, so re-dispatching against main replays main's current
# workflow against an already-published tag.
workflow_dispatch:
inputs:
tag:
description: 'Existing tag to rebuild desktop assets for, e.g. v0.4.2.0'
required: true
type: string
jobs:
desktop-linux:
name: Build Linux desktop image (+deb when dpkg present)
runs-on: ubuntu-latest
timeout-minutes: 40
env:
RELEASE_TAG: ${{ github.event.inputs.tag || github.ref_name }}
steps:
- name: Checkout
run: |
git clone https://git.trevena.info/nick/incido.git repo
cd repo
git fetch --depth=1 origin tag "$RELEASE_TAG" || true
git fetch --tags origin
git checkout "$RELEASE_TAG"
- name: Set up JDK 17
run: |
WORKDIR=/var/lib/gitea-runner/work
if [ ! -d "$WORKDIR/jdk" ]; then
wget -q 'https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.13%2B11/OpenJDK17U-jdk_x64_linux_hotspot_17.0.13_11.tar.gz' -O /tmp/jdk.tar.gz
mkdir -p "$WORKDIR/jdk"
tar -xzf /tmp/jdk.tar.gz -C "$WORKDIR/jdk" --strip-components=1
rm /tmp/jdk.tar.gz
fi
echo "JAVA_HOME=$WORKDIR/jdk" >> $GITHUB_ENV
echo "PATH=$WORKDIR/jdk/bin:$PATH" >> $GITHUB_ENV
- name: Set up Android SDK
run: |
# Desktop modules don't use it, but AGP evaluation of :app /
# :composeApp needs ANDROID_HOME during the configuration
# phase of every build in this repo. Same cache as dev.yml.
WORKDIR=/var/lib/gitea-runner/work
SDK=$WORKDIR/android-sdk
if [ ! -d "$SDK/cmdline-tools/latest" ]; then
mkdir -p "$SDK"
wget -q 'https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip' -O /tmp/cmdline-tools.zip
unzip -q /tmp/cmdline-tools.zip -d /tmp/cmdline-tools-extract
mkdir -p "$SDK/cmdline-tools"
mv /tmp/cmdline-tools-extract/cmdline-tools "$SDK/cmdline-tools/latest"
rm -rf /tmp/cmdline-tools.zip /tmp/cmdline-tools-extract
yes | "$SDK/cmdline-tools/latest/bin/sdkmanager" --licenses > /dev/null 2>&1 || true
"$SDK/cmdline-tools/latest/bin/sdkmanager" --install \
"platform-tools" \
"platforms;android-34" \
"build-tools;34.0.0" > /dev/null 2>&1
fi
echo "ANDROID_HOME=$SDK" >> $GITHUB_ENV
echo "ANDROID_SDK_ROOT=$SDK" >> $GITHUB_ENV
- name: Build desktop distribution
timeout-minutes: 30
run: |
cd repo
chmod +x gradlew
./gradlew --stop 2>/dev/null || true
# App-image first — it needs no host tooling (Phase 0 Q6).
./gradlew :desktopApp:createDistributable :desktopApp:printPackageVersion --no-daemon
VERSION=$(./gradlew -q :desktopApp:printPackageVersion | grep PACKAGE-VERSION | awk '{print $2}')
echo "PKG_VERSION=$VERSION" >> $GITHUB_ENV
IMAGE_DIR=desktopApp/build/compose/binaries/main/app/incido
test -x "$IMAGE_DIR/bin/incido"
# M5.3 contract: smoke the IMAGE, not just the run task (the
# jlink runtime hides missing modules until inside the image).
if command -v xvfb-run >/dev/null 2>&1; then
rm -rf /tmp/ci-desktop-smoke
xvfb-run -a "$IMAGE_DIR/bin/incido" --data-dir /tmp/ci-desktop-smoke --self-test --exit-after 6 \
| tee /tmp/desktop-smoke.log
grep -q 'SELFTEST wrote note' /tmp/desktop-smoke.log
echo 'Image smoke PASS'
else
echo 'NO xvfb on this runner — image smoke SKIPPED (recorded, not faked).'
fi
# deb only when dpkg exists; rpm needs rpmbuild (absent here).
if command -v dpkg >/dev/null 2>&1; then
./gradlew :desktopApp:packageDeb --no-daemon || \
echo 'deb packaging failed (recorded; app-image still shipped)'
else
echo 'NO dpkg on this runner — deb build skipped (recorded).'
fi
- name: Stage assets
run: |
cd repo
VERSION="${PKG_VERSION:-$RELEASE_TAG}"
IMAGE_DIR=desktopApp/build/compose/binaries/main/app/incido
# Bundle the M5.3 .desktop template + icon INSIDE the tarball.
cp desktopApp/packaging/incido.desktop desktopApp/packaging/icon.png "$IMAGE_DIR/"
tar -czf "Incido-${VERSION}-linux-x64.tar.gz" -C "$(dirname "$IMAGE_DIR")" incido
ls -la Incido-*.tar.gz
cp desktopApp/build/compose/binaries/main/deb/*.deb "Incido-${VERSION}-linux-x64.deb" 2>/dev/null \
|| echo 'no deb produced (dpkg absent or failed) — asset list will omit it'
- name: Attach desktop assets to the release
env:
GH_TOKEN: ${{ secrets.TOKEN }}
run: |
set -e
cd repo
TAG="$RELEASE_TAG"
API="http://192.168.8.17:3000/api/v1/repos/nick/incido"
RELEASE_ID=$(curl -s "$API/releases/tags/$TAG" \
-H "Authorization: token $GH_TOKEN" \
| python3 -c "import sys,json; print(json.load(sys.stdin).get('id','') or '')")
if [ -z "$RELEASE_ID" ]; then
echo "No release for $TAG yet (APK release job may not have run) — creating it."
RELEASE_ID=$(curl -s -X POST "$API/releases" \
-H "Authorization: token $GH_TOKEN" \
-H "Content-Type: application/json" \
-d "{\"tag_name\":\"$TAG\",\"name\":\"$TAG\",\"body\":\"Desktop assets for $TAG\",\"draft\":false,\"prerelease\":false}" \
| python3 -c "import sys,json; print(json.load(sys.stdin).get('id','') or '')")
fi
test -n "$RELEASE_ID"
for ASSET in Incido-*.tar.gz Incido-*.deb; do
[ -f "$ASSET" ] || continue
for attempt in 1 2 3 4 5; do
echo "--- Uploading $ASSET (attempt $attempt/5) ---"
curl -s -f -X POST "$API/releases/$RELEASE_ID/assets?name=$ASSET" \
-H "Authorization: token $GH_TOKEN" \
-F "attachment=@$ASSET" \
--max-time 900 --retry 2 --retry-all-errors --retry-delay 15 >/dev/null || true
if curl -s "$API/releases/$RELEASE_ID" -H "Authorization: token $GH_TOKEN" \
| python3 -c "import sys,json; d=json.load(sys.stdin); sys.exit(0 if any(a['name']=='$ASSET' for a in d['assets']) else 1)"; then
echo "Verified: $ASSET attached."
break
fi
[ "$attempt" = 5 ] && { echo "ERROR: $ASSET not attached after 5 attempts"; exit 1; }
sleep 15
done
done
# Deferred per phase plan §8 (macOS/Windows GA = Phase 2): enable when
# this Gitea instance has runner labels for those OSes. jpackage will
# not cross-compile; each OS needs its own host.
#
# desktop-macos:
# runs-on: macos-latest # (a self-hosted macOS runner label)
# steps: [ ...createDistributable with Dmg; codesigning TBD... ]
# desktop-windows:
# runs-on: windows-latest # (a self-hosted Windows runner label)
# steps: [ ...createDistributable with Msi/Exe... ]
+11 -3
View File
@@ -24,9 +24,16 @@ captures/
# Kotlin
.kotlin/
# ObjectBox generated models (kept under build, but ignore if moved out)
**/objectbox-models/
**/objectbox-models/default.json
# ObjectBox generated models. The *model file itself* is the schema
# contract — UIDs in it must stay stable across machines and across the two
# modules that generate from the same entities (:core:data and
# :core:data-jvm), so default.json is tracked and everything else stays out.
**/objectbox-models/*
!**/objectbox-models/default.json
# ObjectBox self-extraction lands this at the process CWD (repo root for
# gradle runs) — a build artifact, never source (the tracked copies live in
# desktopApp/ and core/data-jvm/).
/libobjectbox-jni-linux-x64.so
# VS Code
.vscode/
@@ -38,3 +45,4 @@ Thumbs.db
# Built APKs at the repo root (stamped with version — see Incido
# Development Plan §11 for the release build procedure).
incido-*.apk
Incido-*.apk
+11 -2
View File
@@ -66,7 +66,16 @@ or your feature's manual verification steps.
We use [Conventional Commits](https://www.conventionalcommits.org/).
Per-version user-facing notes live in `PREVIOUS_HISTORY.md`
(Development Plan §11.1) — the release CI attaches the matching section
to each Gitea release automatically:
to each Gitea release automatically. Write each note (paragraph or bullet)
as **one complete line — do not hard-wrap it**: the CI copies the section
verbatim, so manual line breaks ship as premature returns, and the release
UI reflows the text for you. **From v0.4.2.0 on, every new release section
must open with the standard backup-warning callout** — ask users to make
certain they have a current backup (Settings → Backup & Restore → Export,
plus the encryption-key export under Settings → Security) before
installing the new version. This reminder ships with every release.
Commit types:
| Type | Use for |
|------|---------|
@@ -144,7 +153,7 @@ under GPL-3.0 before opening the PR.
> fails immediately — there's a validator in `app/build.gradle.kts`.
1. Bump `versionCode` (+1) and `versionName` in `app/build.gradle.kts`.
2. Update the Development Plan §10 history table with the new dot-name.
2. Update the Development Plan §10 history table with the new dot-name, and give the release its `PREVIOUS_HISTORY.md` section — opening, as every release does from v0.4.2.0 on, with the standard backup-warning callout (users must back up before installing).
3. Tag the commit: `git tag -s vX.Y.Z.W -m "vX.Y.Z.W — short summary"`.
4. `./gradlew assembleDebug assembleRelease` — confirm both green.
5. Upload `app/build/outputs/apk/release/app-release.apk` to Gitea Releases.
+16 -1
View File
@@ -370,6 +370,10 @@ A short reference for AI assistants:
| Version | Date | Notes |
|---------|------|-------|
| 0.4.2.0 | 2026-09-23 | **Feature release — voice notes, with a maintenance pass folded in (Opus recording format + editor toolbar reorder).** **1. Voice notes.** New `NoteType.VOICE_NOTE` toggled by a mic button on the editor's bottom toolbar (`RECORD_AUDIO` requested on first tap into voice mode): `VoiceRecorder` (framework `MediaRecorder`) writes the take via `cacheDir/voice_rec/`; `VoiceNoteSection` pins a record/re-record card plus a `MediaPlayer`-backed player bar (play/pause, seek, elapsed/total) at the top of the body, with a Download action (MediaStore Downloads on API 29+, FileProvider share-sheet fallback on API 26–28). Takes ride the ordinary attachment pipeline (`PendingAttachment` → `NoteAttachment`) — encrypted at rest, included in backups, survive type changes; one take per note, re-recording replaces the old one. `Note.firstAudioAttachment` convenience; mic badge on cards; zero new dependencies. **2. Opus audio format (maintenance).** Takes record as Opus-in-Ogg (`.opus` — 32 kbps, single channel, 48 kHz) via `OutputFormat.OGG` + `AudioEncoder.OPUS` on API 29+ (the public-API floor for OGG output), keeping the previous AAC/MPEG-4 (`.m4a`, 96 kbps) path for API 26–28; `VoiceRecorder.recordedMimeType` propagates the actual container to the attachment mime (`audio/ogg`), display name (`Voice_*.opus`), playback cache file, MediaStore download mime and share-intent type. Opus frame size / encoder complexity are platform defaults — `MediaRecorder` exposes no knob (120 ms frames + complexity 10 would require bundled native libopus; deferred). Existing `.m4a` takes still play; no migration. **3. Editor toolbar reorder (maintenance).** Bottom action row is now Photo · Voice · Attach · Tasks · Shopping list, with the hashtag button justified flush right via a weighted `Spacer`, separated from the cluster; handlers, permission flows and tints unchanged. **4. Backup-warning convention.** From this version every release section opens with a ⚠️ back-up-before-installing callout (PREVIOUS_HISTORY.md header, §11.1, CONTRIBUTING release process, README upgrade callout). **Lockstep (§11.1).** versionCode 37→38, versionName 0.4.1.1→0.4.2.0, `SettingsViewModel.APP_VERSION` bumped, README intro + current-release line + smoke-test step, PREVIOUS_HISTORY.md section (backup callout first; feeds the release description + `Incido-0.4.2.0-changes.md` asset), `ReleaseNotes.RECENT` (v0.3.8.0 drops off the 5-entry tail). |
| 0.4.1.1 | 2026-09-23 | **Emergency hotfix — two v0.4.1.0 editor regressions.** **1. Saved notes landed in Drafts.** `NoteEditorViewModel.save()` published the note but left `UiState.existing.isDraft = true`, so the editor's dispose-time `flushDraft()` immediately re-persisted the just-saved note as a draft — every confirmed note ended up in Drafts. The save path now adopts the published row into state (`isDraft = false`, current hashtags kept), letting `persistDraftNow()`'s already-published guard turn that flush into a no-op. **2. Enter on a shopping-list Price field wrapped the cursor to the Title.** A bare `ImeAction.Next` with no handler fell through to system focus traversal — price being the row's last field inside the LazyColumn wrapped focus all the way back to the Title; the field now passes `KeyboardActions(onNext = { onAddAfter() })`, matching Enter on the Product field (fresh row, cursor in its Product box). **Lockstep (§11.1).** versionCode 36→37, versionName "0.4.1.0"→"0.4.1.1", SettingsViewModel.APP_VERSION bumped, README current-release line + two smoke-test regression steps, PREVIOUS_HISTORY.md section (feeds the release description + `Incido-0.4.1.1-changes.md` asset), ReleaseNotes.RECENT (v0.3.8.1 drops off the 5-entry tail). |
| 0.4.1.0 | 2026-09-23 | **Feature release — colour filters + auto-saved drafts, plus Trash & editor polish.** **1. Colour filters.** The drawer gains a horizontal five-swatch strip (Blue / Green / Amber / Red / Purple) between Favorites and Drafts — no labels, the colours are self-explanatory; selecting a swatch shows ONLY **active** notes of that colour (tagged and untagged eligible, trashed never — same rules as Favorites / Untagged), search narrows within the colour, re-tapping the selected swatch returns to Home. `NoteFilter` gains `ByColor` (+ `color:<NAME>` route parsing in `App.kt`); the repository gains `observeByColor` / `searchByColor` reusing the shared `decorate()` / `matchingNoteIds()` trash-exclusion path. **2. Auto-saved drafts.** New notes persist as drafts while being written: `Note.isDraft` (indexed ObjectBox property; mirrored in `BackupNote`, defaulted false for older backups), `NoteFilter.Drafts` (+ `drafts` route + drawer row) with repository `observeDrafts` / `searchDrafts`; `NoteEditorViewModel` runs a debounced signature-driven autosave with `flushDraft()` on back-navigation / dispose; drafts appear ONLY in the Drafts view until saved (then Home) or trashed (then Trash); an untitled draft is labelled by kind — "Task List — (draft)", "Shopping List — (draft)" — on cards and the editor bar via `NoteType.displayName` + `Note.UNTITLED` (display-only; stored content untouched). **3. Empty Trash.** Trash view shows a `DeleteForever` top-bar action whenever it holds notes, gated by a confirmation `AlertDialog`; `deleteAllTrashed()` cascades note rows + hashtag xrefs + attachment rows exactly like `delete()`. **4. Editor row rebuild.** `EditorLineField` unified on one `BasicTextField` with a hand-drawn 2 dp underline — the old two-branch design mixed M3 `TextField`'s 56 dp min container with compact fields, producing double-height rows; `ChecklistItemRow` moved `Alignment.Top`→`Alignment.CenterVertically` so checkbox / delete / +/- controls ride centred beside wrapping labels. versionCode 35→36, versionName "0.4.0.0"→"0.4.1.0", SettingsViewModel.APP_VERSION bumped in lockstep, README current-release line, PREVIOUS_HISTORY.md section, and the in-app What's New dialog (ReleaseNotes.RECENT — v0.3.7.0 drops off the 5-entry tail). |
| 0.4.0.0 | 2026-09-18 | **Feature release — in-app import of 3rd-party notes.** Settings → Backup & Restore gains an "Import 3rd Party Notes" button that reads a Carnet / QuickNote `.zip` export (a single archive bundling one `.sqd` per note, where each `.sqd` is itself a zip of index.html + metadata.json + optional data/ attachments) and imports every note directly on-device — no pre-conversion step. Rich-text bodies are flattened to plain text; colours, keywords (imported as tags) and links carry over; to-do lists become native checklists; image attachments are imported (auto-generated preview thumbnails are skipped). Import is additive with per-note fault isolation, and imported notes get fresh IDs. New `CarnetImporter` in `composeApp/data/backup` + entry point in the Settings screen/view model. versionCode 34→35, versionName "0.3.8.1"→"0.4.0.0", SettingsViewModel.APP_VERSION bumped in lockstep, README current-release line, PREVIOUS_HISTORY.md section, and the in-app What's New dialog (ReleaseNotes.RECENT — v0.3.6.0 drops off the 5-entry tail). |
| 0.3.8.1 | 2026-09-17 | **Emergency hotfix — rebuild / re-release of v0.3.8.0. Zero app-code changes; release-pipeline fix only.** **1. Why.** The release job had been failing to publish reliably. `.gitea/workflows/release.yml` now addresses the Gitea API as `http://192.168.8.17:3000/api/v1/repos/nick/incido` (LAN, direct) instead of the Cloudflare-fronted `https://git.trevena.info/...`, which was the source of the mid-upload 524 origin timeouts that 4a28f4f could only retry around. **2. Signing key rotated — INSTALLED BUILDS CANNOT UPDATE IN PLACE.** The job ran on a runner whose `/var/lib/gitea-runner/work` cache held no `release.jks`, so the mint-if-absent branch (release.yml) generated a NEW certificate; Android rejects an APK whose signing cert differs from the installed one, so v0.3.8.1 must be uninstalled before it will install. Because `allowBackup="false"` (AndroidManifest) keeps notes out of Android's cloud/D2D restore, an uninstall DESTROYS the user's notes — so the release notes lead with "export a backup first" (Settings → Backup → Export, plus Settings → Security → Export encryption key when encryption is on), then uninstall → install → restore. **Follow-up worth doing:** copy the original `release.jks` onto the runner at `/var/lib/gitea-runner/work/release.jks` to restore in-place upgrades and stop the rotation; until then every release repeats this. **3. Lockstep (§11.1).** versionCode 33→34, versionName "0.3.8.0"→"0.3.8.1", SettingsViewModel.APP_VERSION bumped, README current-release line + reinstall warning, PREVIOUS_HISTORY.md section (feeds the release description + `Incido-0.3.8.1-changes.md` asset), and the in-app What's New dialog (ReleaseNotes.RECENT — v0.3.5.1 drops off the 5-entry tail). |
| 0.3.8.0 | 2026-09-16 | **Feature release — task lists, shopping lists, hashtag-autocomplete fix** (closes §6.1 "Checklists / to-do items within notes" + "Grocery list with running price total"). **1. Note types.** New `NoteType` enum in `:core/domain` (TEXT / TASK_LIST / SHOPPING_LIST) carried by `Note.type` and an additive `NoteEntity.typeKey` Short column (ObjectBox auto-migrates; old rows = TEXT). List bodies persist as GitHub-flavoured `- [ ] item` lines (`Note.splitListContent` / `serializeListContent`), so content stays the single source of truth: full-text search, AES-GCM field encryption, share-into, the v0.2 inline checklist card summaries, and Trash all keep working untouched. **2. Task-list editor.** Checklist button next to the # tag button in the editor's bottom action row converts the note into editable rows (Checkbox + item text + remove, "+ Add item", first non-checkbox line kept as the title field); tapping the active button reverts to plain text. Active mode tints primary. Cards already showed "- [ ]" open/done counts; shopping cards now show a basket icon instead of the checkbox glyph. **3. Shopping list + running total.** Same mechanism with two structured fields per row: a read-only **quantity picker (1–9)** (`ExposedDropdownMenuBox` — no keyboard ever opens) and a **POS-style price field** (`KeyboardType.Number`; every digit typed is a cent — the field stores the RAW digits verbatim (e.g. `199` = $1.99) so mid-field cursor placement behaves like a normal text field and can never scramble the amount, with a non-editable `$` prefix; the total bar renders dollars). A sticky `ShoppingTotalBar` stays pinned above the rows — always visible, updated live — summing `qty × price` of CHECKED (= in-basket) items in **integer cents** (no binary-float drift). Storage puts both values in an explicit end-of-line marker `- [x] Eggs {q12 p2.40}`, so the PRODUCT TEXT IS NEVER SCANNED FOR NUMBERS ("Battery AA 3", "Poster 50 x 60" stay pure product names); hand-typed §6.1 shapes (`Milk 3.50`, `Eggs 12 x 2.40`) still import once into the structured fields on conversion (decimals required on the legacy forms to avoid exactly that ambiguity). Converting to a task list folds values back into plain text tokens (`Eggs 12 x 2.40`) so nothing is lost across mode switches. **4. Add-tag suggestions repaired.** The autocomplete collector in `NoteEditorViewModel.init` was `tagInputFlow.collect { pool.collect { … } }` over infinite ObjectBox callbackFlows — the outer lambda suspended in the inner collect forever, keystrokes never re-queried, and `openAddTagSheet()` zeroed the list, so the sheet only ever offered "+ Create". Rebuilt on `flatMapLatest` over `tagInputFlow` (sheet opens showing every existing tag most-used-first, filters live per keystroke). **5. Backups** round-trip the new type via defaulted `BackupNote.noteType` ("TEXT") — pre-v0.3.8.0 files import unchanged, `ignoreUnknownKeys` covers older readers; encrypted backups reuse the same shape. ViewModel: `isDirty` gains the type axis; list edits keep `content` synchronised with the row serialisation so save/preview/canSave gates need no changes. versionCode 32→33, versionName "0.3.7.1"→"0.3.8.0", SettingsViewModel.APP_VERSION bumped in lockstep. |
| 0.3.7.1 | 2026-08-30 | **Maintenance release — UI polish + one bug fix.** **1. Editor top bar decluttered.** The Add/Edit `TopAppBar` carried six right-side actions (camera, attach, tag, favourite, save, overflow), which crowded the title on narrow screens. Camera / Attach file / Add tag move to a Keep-style bottom action row (hairline `HorizontalDivider` above it; rides above the nav bar / keyboard via the existing IME insets). The top bar is now back + "New note" / "Edit note" title (`maxLines = 1`, ellipsis) + favourite + save + overflow (Move to Trash when editing) — always fits, and matches the §5.2 spec. **2. Image-viewer false failure fixed.** `ImageViewerScreen` checked `bitmap == null` in a `LaunchedEffect` before the async load finished, so a "Couldn't decode image attachment" toast fired on every persisted image open. Replaced with a `loadFailed` state set only after the byte load / decode genuinely fails; the placeholder switches from "Loading…" to "Couldn't load image" (toast removed). **3. Search QoL.** The list search field auto-focuses on open (`FocusRequester` + `LaunchedEffect(state.isSearchActive)`) and gains a trailing clear (✕) button while the query is non-empty. **4. Drawer tag-list overflow fixed.** The scrollable "Recent tags" column in `IncidoDrawer` had no height cap, so long tag lists could overflow the sheet bottom; it now takes `weight(1f)` and scrolls within the remaining height. Dead `_ignored` workaround val removed. **5. Add-tag sheet autofocus.** The sheet's input field is focused on open so the keyboard is already up. Also small hygiene: unused `persistedBytes` param dropped from `AttachmentStrip`; fully-qualified `Spacer` / `Image` / `Column` / `Dispatchers` references replaced with imports. **6. New flat app icon.** `incido_flat_icon.png` (1024×1024, squircle + shield + pen nib, transparent corners) replaces the v0.3.3.8 artwork: LANCZOS-downscaled into `drawable-{mdpi…xxxhdpi}/ic_launcher_foreground.png` (108/162/216/324/432 px, full 108dp canvas — the artwork's fill colour matches the background layer so the squircle edges blend seamlessly) and legacy `mipmap-{mdpi…xxxhdpi}/ic_launcher{,_round}.png` (48/72/96/144/192 px); `ic_launcher_background` re-tinted `#010435` → `#352999`. versionCode 31→32, versionName "0.3.7.0"→"0.3.7.1", SettingsViewModel.APP_VERSION bumped in lockstep. |
@@ -435,7 +439,18 @@ A small Gradle task called `copyReleaseApks` (registered in
line. **`PREVIOUS_HISTORY.md`** — append a new
`## v<NEW_VERSION> — <DATE>` section at the top: friendly user-facing
bullets, newest first (this file replaced the old README Changelog
table). On tag push the release workflow runs
table). **Write each note (paragraph or bullet) as one complete line —
do not hard-wrap it:** the CI copies the section verbatim into the release
description and the `Incido-<version>-changes.md` asset, so a manual line
break ships as a premature return; the release UI reflows the text for you. **From v0.4.2.0 on, every new section
must open with the standard backup-warning callout** (blockquote
`> ⚠️ **Before installing:** ...`): ask users to make certain they
have a current backup — Settings → Backup & Restore → Export, plus
the encryption key export under Settings → Security — before
installing the new version. The same reminder leads the matching
ReleaseNotes.kt entry and repeats on the README front page; it ships
with EVERY release from now on.
On tag push the release workflow runs
`scripts/ci/release-notes.py` and attaches that section to the Gitea
release as its description **and** as an `Incido-<version>-changes.md`
asset beside the APKs — so keep one section per released version and
+51 -54
View File
@@ -1,61 +1,58 @@
# Incido — Previous Release History
Reference archive of Incido's user-facing release history (formerly the
README changelog table).
Reference archive of Incido's user-facing release history (formerly the README changelog table).
Current downloads ship **with their own notes**: every release on the
[Releases page](https://git.trevena.info/nick/incido/releases) carries its
version's changelog — rendered in the release description and also
attached beside the APKs as `Incido-<version>-changes.md`. The CI generates
both from the matching section below via `scripts/ci/release-notes.py`
at tag-build time.
Current downloads ship **with their own notes**: every release on the [Releases page](https://git.trevena.info/nick/incido/releases) carries its version's changelog — rendered in the release description and also attached beside the APKs as `Incido-<version>-changes.md`. The CI generates both from the matching section below via `scripts/ci/release-notes.py` at tag-build time.
**Adding a release:** append a `## v<VERSION> — <DATE>` section at the
top of this file (see Development Plan §11.1). Newest first; never delete
or reorder older sections — the CI must find a section for whatever tag it
builds, and hotfix retags can target any version. If a tag has no section,
the release falls back to a plain "Release <tag>" description.
**Adding a release:** append a `## v<VERSION> — <DATE>` section at the top of this file (see Development Plan §11.1). Newest first; never delete or reorder older sections — the CI must find a section for whatever tag it builds, and hotfix retags can target any version. If a tag has no section, the release falls back to a plain "Release <tag>" description. **Every new section must open with the standard backup-warning callout** (from v0.4.2.0 onwards): ask users to back up their data — Settings → Backup & Restore, plus their encryption key under Settings → Security — before installing the new version.
---
## v0.4.2.0 — 2026-09-23
> ⚠️ **Before installing:** please make certain you have a current backup of your data — Settings → Backup & Restore → Export, plus your encryption key from Settings → Security if encryption is on — then install the new version and restore if you need to. Every Incido release from now on will carry this same reminder.
New in this release: **voice notes**.
- **Record right inside a note.** The editor's bottom toolbar gained a mic button — first in the row, right after the camera. The whole toolbar is now laid out Photo · Voice · Attach · Tasks · Shopping list, with the hashtag button moved to the far right, separated from the others. Tap the mic (Incido asks for microphone access the first time) and the note grows a recording card at the top of its body, right above the text. Tap to record, tap stop — your take gets a proper media player: play / pause, a seek bar, elapsed and total time.
- **Small, crisp recordings.** Takes are captured as Opus audio (`.opus` — 32 kbps, single channel): tiny files with clear speech. Devices on Android 8.x / 9 fall back to the previous AAC format automatically; playback and downloading work identically either way.
- **The recording is part of the note.** Takes are stored with the note like any other attachment — encrypted at rest when encryption is on, and included in backups — and a download button on the player copies the file out to your device's Downloads folder when you need it (older devices get the share sheet, which saves to the same places).
- **Still a normal note.** Voice notes keep the title, the text body, colours, tags, favourites, drafts and search; re-recording replaces the old take, tapping 🗑 removes it, and converting the note back to a plain text note leaves the recording in place as an ordinary attachment. Voice-note cards carry a small mic badge so you can spot them at a glance.
- **No new engines on board.** Recording and playback use the Android framework's own media APIs — no new libraries, no network access: recordings never leave your device.
## v0.4.1.1 — 2026-09-23
Hotfix over v0.4.1.0 — two editor fixes, nothing else changed. Installing it over v0.4.1.0 is a normal in-place update.
- **Saved notes stay put.** In v0.4.1.0 every note you saved ended up in Drafts instead of Home — the editor still believed the note was a draft and quietly re-saved it as one when you left the screen. Saving now publishes the note properly: it goes to Home and leaves Drafts for good.
- **Enter behaves in the price box.** In a shopping list, pressing Enter in a row's Price field jumped the cursor all the way back to the note title. It now works exactly like Enter in the product field: a fresh item row appears below, with the cursor ready in its Product box.
## v0.4.1.0 — 2026-09-23
New in this release: **colour filters**, **auto-saved drafts** and an **Empty Trash** button — plus a steadier editor.
- **Colour filters in the drawer.** A horizontal strip of five swatches — Blue, Green, Amber, Red and Purple — sits right under Favorites. Tap a swatch and the list shows ONLY your notes in that colour: untagged colour notes appear, tagged ones appear too, and a trashed note of that colour is never shown — the filter follows the same rules as Favorites and Untagged. Tap the selected swatch again to return to Home.
- Search works inside colour views as well: whatever you type narrows the selected colour's notes, exactly like search does on Favorites.
- **Auto-saved drafts.** A brand-new note now saves itself as a draft while you type — no save button needed, no lost work. If you back out or close the app before finishing, the note waits in the new Drafts row in the navigation drawer; open it again and you are exactly where you left off.
- A draft never gets in your way: it stays out of Home, Favorites, tag views and search until you save the note, and an untitled draft introduces itself by its kind — "Task List — (draft)", "Shopping List — (draft)" — on its card and in the editor's title bar. Drafts ride along in encrypted backups, so a restore brings them back too.
- **Empty Trash.** The Trash view gains an Empty Trash button whenever it holds notes. One tap — confirmed by a dialog first — permanently deletes every trashed note, attachments included.
- **Steadier editor rows.** The to-do and shopping-list editors now render title, item and quantity fields at one even, underlined row height, so rows sit evenly instead of the tall/short mix before. Long task labels wrap inside their row instead of stretching it, and the checkbox, delete and +/- controls stay centred alongside however many lines the label takes.
## v0.4.0.0 — 2026-09-18
New in this release: **Import 3rd Party Notes**. Settings → Backup & Restore
now has an "Import 3rd Party Notes" button that ingests a Carnet / QuickNote
`.zip` export — a single archive bundling one `.sqd` per note — straight
on-device, with no pre-conversion step. Rich-text bodies are flattened to plain
text; note colours, keywords (imported as tags) and links carry over; to-do
lists become native checklists; and image attachments are imported
(auto-generated preview thumbnails are skipped). Import is additive — existing
notes are preserved and imported notes get fresh IDs.
---
New in this release: **Import 3rd Party Notes**. Settings → Backup & Restore now has an "Import 3rd Party Notes" button that ingests a Carnet / QuickNote `.zip` export — a single archive bundling one `.sqd` per note — straight on-device, with no pre-conversion step. Rich-text bodies are flattened to plain text; note colours, keywords (imported as tags) and links carry over; to-do lists become native checklists; and image attachments are imported (auto-generated preview thumbnails are skipped). Import is additive — existing notes are preserved and imported notes get fresh IDs.
## v0.3.8.1 — 2026-09-17
> **⚠️ Reinstall required — please export a backup first.** This build is signed
> with a **new CI signing key** (the previous key lived in the old build runner's
> cache and was not carried over), so Android will refuse to install it over an
> existing Incido — it reports a signature conflict. Incido deliberately doesn't
> participate in Android's automatic backup/restore, so **uninstalling deletes
> your notes**. To update safely: **Settings → Backup → Export** (and
> **Settings → Security → Export encryption key** if you use encryption),
> then uninstall Incido, install this APK, and restore from your backup.
> If you'd rather keep using v0.3.8.0, that's fine — nothing in it is broken.
> **⚠️ Reinstall required — please export a backup first.** This build is signed with a **new CI signing key** (the previous key lived in the old build runner's cache and was not carried over), so Android will refuse to install it over an existing Incido — it reports a signature conflict. Incido deliberately doesn't participate in Android's automatic backup/restore, so **uninstalling deletes your notes**. To update safely: **Settings → Backup → Export** (and **Settings → Security → Export encryption key** if you use encryption), then uninstall Incido, install this APK, and restore from your backup. If you'd rather keep using v0.3.8.0, that's fine — nothing in it is broken.
- **No app changes.** v0.3.8.1 is a re-release of v0.3.8.0: same task lists,
shopping lists with the running total, and add-tag suggestions fix. Only the
build number and the release pipeline changed.
- **Why the rebuild.** The release pipeline had been failing to publish builds
reliably. Release uploads now go to the Gitea API over the local network
instead of the proxied public address, which is where the upload timeouts were
coming from — so this is the first build in a while to ship with its APKs and
notes attached the way §11.1 intends.
- **No app changes.** v0.3.8.1 is a re-release of v0.3.8.0: same task lists, shopping lists with the running total, and add-tag suggestions fix. Only the build number and the release pipeline changed.
- **Why the rebuild.** The release pipeline had been failing to publish builds reliably. Release uploads now go to the Gitea API over the local network instead of the proxied public address, which is where the upload timeouts were coming from — so this is the first build in a while to ship with its APKs and notes attached the way §11.1 intends.
## v0.3.8.0 — 2026-09-16
- **Task lists + shopping lists (Development Plan §6.1).** New checklist button in the editor's bottom action row (next to the `#` tag button) converts any note into an editable task list — real checkboxes, add / remove item rows; tap the button again to return to plain text (`NoteType`, additive `typeKey` column, auto-migrated). New shopping-basket button works the same way but gives every row a tap-to-pick **quantity (1–9) dropdown** and a supermarket-style price field where the number pad types cents — enter `199` and it counts as **$1.99** in the maths (the price box keeps exactly the digits you typed, so cursor placement can never scramble them, while the total bar speaks real dollars). An always-visible running total sits above the list, adding quantity × price for everything checked (= in the basket). The three values are strictly separate fields saved with an explicit end-of-line marker (`- [x] Eggs {q12 p2.40}`), so numbers inside a product name (like "Battery AA 3") can never leak into the money maths; hand-typed classic lines (`Milk 3.50`, `Eggs 12 x 2.40`) are still recognised when converting older notes. Lists persist as GitHub-flavoured `- [ ]` lines, so search, encryption, backups (new defaulted `noteType` field — old files still import), and card "N open · M done" summaries keep working; shopping cards show a basket icon.
- **Add-tag sheet suggestions fixed** — the nested-collect autocomplete pipeline never resumed past the first keystroke, so only "+ Create…" ever showed; rebuilt on `flatMapLatest`, existing tags now list immediately when the sheet opens and filter live per keystroke.
- **Add-tag sheet suggestions fixed.** The nested-collect autocomplete pipeline never resumed past the first keystroke, so only "+ Create…" ever showed; rebuilt on `flatMapLatest`, existing tags now list immediately when the sheet opens and filter live per keystroke.
## v0.3.7.1 — 2026-08-30
@@ -71,7 +68,7 @@ notes are preserved and imported notes get fresh IDs.
## v0.3.6.2 — 2026-08-19
- **CI / release-pipeline tag.** — re-tag of v0.3.6.1 used to exercise the Gitea Actions release workflow (keystore minted on the release runner; debug + release APKs attached to the Gitea release). No app changes.
- **CI / release-pipeline tag.** Re-tag of v0.3.6.1 used to exercise the Gitea Actions release workflow (keystore minted on the release runner; debug + release APKs attached to the Gitea release). No app changes.
## v0.3.6.1 — 2026-08-19
@@ -87,7 +84,7 @@ notes are preserved and imported notes get fresh IDs.
## v0.3.5.1 — 2026-08-17
- **"Encrypted" badge now appears the moment you flip the switch.** A race in `EncryptionVerifier.checkNow()` could silently drop the post-migration verification, leaving cards without the badge until a second toggle; replaced with a serializing Mutex so every check runs in invocation order.
- **"Encrypted" indicator is now a single lock icon next to the date** — consistent position on every card instead of a centred "lock + label" group at the bottom.
- **"Encrypted" indicator is now a single lock icon next to the date.** Consistent position on every card instead of a centred "lock + label" group at the bottom.
## v0.3.5.0 — 2026-08-17
@@ -97,9 +94,9 @@ notes are preserved and imported notes get fresh IDs.
## v0.3.4.0 — 2026-08-17
- **Attachment indicator on note cards.** — a paperclip icon now appears on the right edge of every card that carries an attachment.
- **Light-theme readability over image thumbnails.** — cards with a dark photo background now force light text/icon colours over the image so notes stay readable in Light mode.
- **Auto-Lock "Immediately" no longer locks during file pickers.** — attaching a file, taking a photo, viewing an attachment, or exporting/importing a backup no longer destroys your in-progress note.
- **Attachment indicator on note cards.** A paperclip icon now appears on the right edge of every card that carries an attachment.
- **Light-theme readability over image thumbnails.** Cards with a dark photo background now force light text/icon colours over the image so notes stay readable in Light mode.
- **Auto-Lock "Immediately" no longer locks during file pickers.** Attaching a file, taking a photo, viewing an attachment, or exporting/importing a backup no longer destroys your in-progress note.
## v0.3.3.8 — 2026-08-17
@@ -148,13 +145,13 @@ notes are preserved and imported notes get fresh IDs.
- **At-rest encryption.** ObjectBox store is opened with a 32-byte AES-256 key wrapped by the Android Keystore; toggling the switch generates / deletes the key and surfaces a "Re-encrypting notes…" dialog.
- **PIN lock + biometric.** 4–6 digit PIN (PBKDF2-hashed, 100k iters, constant-time compare) with optional fingerprint / face unlock; cold launch + auto-lock timeout gate.
- **Backup / Import / Export.** JSON codec with Base64 attachment bytes; encrypted variant uses AES-256-GCM + PBKDF2(passphrase, 200k iters) with a Generate button + Copy to clipboard. Passphrase policy: 12–32 chars, ≥1 digit, ≥1 special.
- **Release notes dialog.** — tap the version number on the About card. Adds `USE_BIOMETRIC` + `USE_FINGERPRINT` permissions (still no INTERNET).
- **Release notes dialog.** Tap the version number on the About card. Adds `USE_BIOMETRIC` + `USE_FINGERPRINT` permissions (still no INTERNET).
## v0.3.1.2 — 2026-08-15
- **Three v0.3.1.1 issues fixed.** **card thumbnails are actually visible now** — the v0.3.1.1 layout had the thumbnail Image as a sibling of the Card, so the Card's opaque `containerColor` was drawn on top and the image was completely hidden; the architecture is restructured so the Image + dark scrim live INSIDE the Card, and `containerColor = Color.Transparent` when a thumbnail is present (plain notes still get the existing tinted/surface background).
- **Camera photos honour EXIF orientation** — `NoteRepositoryImpl.normalizeImageOrientation(bytes)` runs at storage time inside `addAttachment` (guarded `if (mimeType.startsWith("image/"))`); reads EXIF `Orientation`, rotates the bitmap, re-encodes as JPEG quality 92, and stores the corrected bytes so every render path (editor thumbnail, card thumbnail, full-screen viewer) sees the photo the right way up.
- **Non-image attachments open in the system viewer** — `AttachmentThumbnail.onClick` now branches on `isImage`: image taps still go to the in-app full-screen viewer; non-image taps write the bytes to a `cacheDir` temp file, get a `FileProvider` URI, and launch `Intent.ACTION_VIEW` with `FLAG_GRANT_READ_URI_PERMISSION` (the previous unconditional viewer path silently failed for PDFs/MP3s/etc. with a stuck "Loading…"). `file_paths.xml` already exposes `cacheDir` via `<cache-path>`, so no manifest change was needed. Attaching arbitrary file types from the paperclip icon was already shipped in v0.3.1.1 (the `*/*` intent filters) — no code change here, just called out so it's clear what was already in place.
- **Three v0.3.1.1 issues fixed.** **card thumbnails are actually visible now.** The v0.3.1.1 layout had the thumbnail Image as a sibling of the Card, so the Card's opaque `containerColor` was drawn on top and the image was completely hidden; the architecture is restructured so the Image + dark scrim live INSIDE the Card, and `containerColor = Color.Transparent` when a thumbnail is present (plain notes still get the existing tinted/surface background).
- **Camera photos honour EXIF orientation.** `NoteRepositoryImpl.normalizeImageOrientation(bytes)` runs at storage time inside `addAttachment` (guarded `if (mimeType.startsWith("image/"))`); reads EXIF `Orientation`, rotates the bitmap, re-encodes as JPEG quality 92, and stores the corrected bytes so every render path (editor thumbnail, card thumbnail, full-screen viewer) sees the photo the right way up.
- **Non-image attachments open in the system viewer.** `AttachmentThumbnail.onClick` now branches on `isImage`: image taps still go to the in-app full-screen viewer; non-image taps write the bytes to a `cacheDir` temp file, get a `FileProvider` URI, and launch `Intent.ACTION_VIEW` with `FLAG_GRANT_READ_URI_PERMISSION` (the previous unconditional viewer path silently failed for PDFs/MP3s/etc. with a stuck "Loading…"). `file_paths.xml` already exposes `cacheDir` via `<cache-path>`, so no manifest change was needed. Attaching arbitrary file types from the paperclip icon was already shipped in v0.3.1.1 (the `*/*` intent filters) — no code change here, just called out so it's clear what was already in place.
## v0.3.1.1 — 2026-08-15
@@ -162,10 +159,10 @@ notes are preserved and imported notes get fresh IDs.
## v0.3.1.0 — 2026-08-15
- **Context-aware search.** — on the Favorites and Untagged pages, the search icon is now visible and a typed query intersects with the active filter (search only favourites on Favorites, only untagged notes on Untagged). On Home, search spans everything.
- **Photo / File attachments.** — the editor now has Camera (camera icon) and Attach File (paperclip icon) buttons. Photos are captured via `MediaStore.ACTION_IMAGE_CAPTURE` (with a transient `FileProvider` outbox; bytes live in the database, the temp file is deleted) and files via `ACTION_OPEN_DOCUMENT`. Attachments are stored as `ByteArray` columns inside ObjectBox — no filesystem paths to manage. Each note's attachments show up as a thumbnail strip in the editor with a ✕ in the top-right corner to remove. Tapping a thumbnail opens a full-screen viewer with pinch-to-zoom + pan (`Modifier.transformable`) and a close button.
- **Card thumbnails.** — notes with image attachments show the first image as a (alpha-blended, scrimmed) background on the list card.
- **Share-into.** — the app accepts `ACTION_SEND` (text + image) and `ACTION_SEND_MULTIPLE` (multiple images) from other apps. Inbound bytes are copied into a process-singleton `SharedIntentBuffer` and pre-filled into a new-note editor. Adds the `CAMERA` permission — still no `INTERNET`, still fully offline.
- **Context-aware search.** On the Favorites and Untagged pages, the search icon is now visible and a typed query intersects with the active filter (search only favourites on Favorites, only untagged notes on Untagged). On Home, search spans everything.
- **Photo / File attachments.** The editor now has Camera (camera icon) and Attach File (paperclip icon) buttons. Photos are captured via `MediaStore.ACTION_IMAGE_CAPTURE` (with a transient `FileProvider` outbox; bytes live in the database, the temp file is deleted) and files via `ACTION_OPEN_DOCUMENT`. Attachments are stored as `ByteArray` columns inside ObjectBox — no filesystem paths to manage. Each note's attachments show up as a thumbnail strip in the editor with a ✕ in the top-right corner to remove. Tapping a thumbnail opens a full-screen viewer with pinch-to-zoom + pan (`Modifier.transformable`) and a close button.
- **Card thumbnails.** Notes with image attachments show the first image as a (alpha-blended, scrimmed) background on the list card.
- **Share-into.** The app accepts `ACTION_SEND` (text + image) and `ACTION_SEND_MULTIPLE` (multiple images) from other apps. Inbound bytes are copied into a process-singleton `SharedIntentBuffer` and pre-filled into a new-note editor. Adds the `CAMERA` permission — still no `INTERNET`, still fully offline.
## v0.3.0.5 — 2026-08-15
+38 -15
View File
@@ -6,25 +6,41 @@ Incido is a privacy-first, on-device note-taking application for Android.
All data stays on your device by default — no accounts, no cloud, no
trackers.
This repository contains the **v0.3.8.1** release: a single-user, offline
This repository contains the **v0.4.2.0** release: a single-user, offline
note app with hashtags, favourites, task lists, shopping lists with a
running total, colour-coded notes, photo and file attachments,
share-into from other apps and the
web, Trash (soft delete with Restore / permanent delete), at-rest
running total, voice notes with an in-app media player and downloadable
recordings, colour-coded notes with per-colour swatch filters,
auto-saved drafts, photo and file attachments, share-into from other
apps and the web, importing notes from third-party apps (Carnet /
QuickNote `.zip` exports) directly on-device, Trash (soft delete with
Restore / permanent delete / one-tap Empty Trash), at-rest
AES-256-GCM encryption with screenshot blocking, PIN / biometric lock,
encrypted backup and restore, and an exportable encryption key for
device migrations. The architecture is multi-module Android today and
is structured so iOS / Desktop ports can happen later without UI
rewrites.
device migrations. The architecture is multi-module Android today and is
structured so iOS / Desktop ports can happen later without UI rewrites.
**Current release:** v0.3.8.1 — full release notes ship **on its entry on
the [Releases page](https://git.trevena.info/nick/incido/releases)**.
**Current release:** v0.4.2.0 (voice notes — a mic button turns any note
into a recordable voice note with a built-in media player; recordings are
compact Opus files (32 kbps, mono) stored with the note and downloadable
to the device; the editor toolbar is reordered Photo · Voice · Attach ·
Tasks · Shopping list with the hashtag button flush right) —
full release notes ship **on its entry on the [Releases
page](https://git.trevena.info/nick/incido/releases)**.
> **v0.3.8.1 needs a clean reinstall** (a new CI signing key makes it conflict
> with any existing Incido install). **Export a backup from
> Settings → Backup first** — Incido doesn't use Android's automatic backup, so
> uninstalling deletes your notes. Otherwise this build is identical to
> v0.3.8.0.
> **Back up before every update:** from v0.4.2.0 onwards, every release
> asks the same of you — **export a backup first** (Settings → Backup &
> Restore → Export, plus your encryption key from Settings → Security if
> you use encryption) before installing a new version. Incido is offline
> by design and doesn't use Android's automatic backup, so a current
> backup is your only safety net for any update.
> **Upgrading from v0.3.8.0 or earlier?** Releases are signed with a **new CI
> key introduced in v0.3.8.1**, so Android won't update an old install in place
> — it reports a signature conflict. **Export a backup from Settings → Backup
> first** (and your encryption key from Settings → Security if you use
> encryption), then uninstall and install fresh — Incido doesn't use Android's
> automatic backup, so uninstalling deletes your notes. **Upgrading from
> v0.3.8.1 onwards is a normal in-place update.**
> **Version scheme (from v0.3.0.0 onwards):** `MAJOR.MINOR.MAINTENANCE.EMERGENCY` —
> e.g. `0.3.0.0`. `MAJOR.MINOR.MAINTENANCE` are normal release numbers;
@@ -172,13 +188,20 @@ After the first push:
```
[ ] Launch app — "Incido" title centred, hamburger top-left
[ ] Tap hamburger → drawer slides in with Home / Favorites / Untagged + divider + Recent tags
[ ] Tap hamburger → drawer slides in with Home / Favorites / colour-swatch strip (Blue·Green·Amber·Red·Purple) / Drafts / Untagged / Trash / Settings + divider + Recent tags
[ ] Tap "Favorites" → list shows only starred notes
[ ] Tap "Untagged" → list shows only notes with zero hashtags
[ ] Tap a colour swatch (e.g. Blue) → list shows only ACTIVE notes of that colour; untagged ones appear, trashed ones never; search narrows within the colour; tapping the selected swatch again returns to Home
[ ] Start a new note, type, then back out without saving → it lands under "Drafts"; an untitled draft is titled "Task List — (draft)" / "Shopping List — (draft)"; reopening it restores the content; saving it moves it to Home
[ ] Save a note (new or draft) → it appears on Home and NOT in Drafts — saving exits draft mode for good (v0.4.1.1 regression)
[ ] Shopping list: press Enter in a row's Price field → a fresh row appears below with the cursor in its Product field, not back in the Title (v0.4.1.1 fix)
[ ] Tap the mic button in a note's bottom toolbar → grant microphone access → a recording card appears above the text field; tap it, record, stop → a media player shows with play/pause, seek and elapsed/total time (v0.4.2.0)
[ ] Voice note: tap the download button on the player → the recording lands in the system Downloads folder; the card also appears in the attachment strip; converting the note back to text keeps the recording (v0.4.2.0)
[ ] Tap a recent hashtag → list filters to that tag
[ ] Tap "Trash" → list shows only soft-deleted notes
[ ] Delete a note → it disappears from Home/search/tag/Favorites and appears in Trash
[ ] Trash card overflow → "Restore" returns the note; "Delete permanently" destroys it
[ ] Trash holds notes → "Empty Trash" (∞-forever icon) appears in the top bar → confirm dialog → everything in Trash is permanently deleted
[ ] Tap "Home" → back to all active notes
[ ] Open a note → chip row above text field shows current tags (empty placeholder if none)
[ ] Tap "#" icon → sheet opens, type "wo" → suggestions filter
+34 -14
View File
@@ -28,20 +28,36 @@ android {
applicationId = "org.incido.app"
minSdk = 26
targetSdk = 35
// v0.4.0.0: MINOR feature release — in-app import of 3rd-party
// notes. Settings → Backup & Restore gains an "Import 3rd Party
// Notes" button that reads a Carnet / QuickNote `.zip` export (a
// single archive bundling one `.sqd` per note, where each `.sqd` is
// itself a zip of index.html + metadata.json + optional data/
// attachments) and imports every note directly on-device — no
// pre-conversion step. Rich-text bodies are flattened to plain text;
// colours, keywords (as tags) and links carry over; to-do lists
// become native checklists; image attachments are imported (auto-
// generated preview thumbnails are skipped). Import is additive with
// per-note fault isolation.
// - versionCode monotonic +1 from v0.3.8.1 (34).
versionCode = 35
versionName = "0.4.0.0"
// v0.4.1.1: EMERGENCY hotfix — two editor regressions shipped
// in v0.4.1.0. (1) Saving a note landed it in Drafts: the save
// path published the note but left UiState.existing.isDraft =
// true, so the editor's dispose-time flushDraft() immediately
// re-persisted it as a draft; the state now adopts the
// published row (isDraft = false), letting persistDraftNow()'s
// already-published guard make the flush a no-op. (2) Enter on
// a shopping-list Price field fell through to system focus
// traversal and wrapped the cursor back to the Title; it now
// wires KeyboardActions(onNext = onAddAfter) like the Product
// field — Enter adds a fresh row with the cursor in its
// Product box.
// - versionCode monotonic +1 from v0.4.1.0 (36).
// v0.4.2.0: FEATURE release — voice notes. New note type (mic
// button on the editor's bottom toolbar toggles it; the toolbar
// is reordered Photo · Voice · Attach · Tasks · Shopping list
// with the hashtag button pushed flush right): a record /
// re-record card plus a MediaPlayer-backed player bar (play/
// pause, seek, elapsed/total) pinned at the top of the body,
// with a Download action copying the take to the system
// Downloads folder (share-sheet fallback on API 26–28). Takes
// record as Opus in Ogg (.opus, 32 kbps, mono, 48 kHz) on
// API 29+; API 26–28 keeps the AAC/MP4 fallback. Audio
// rides the ordinary attachment pipeline — encrypted at rest,
// in backups, survives type changes. RECORD_AUDIO permission
// added; zero new dependencies (framework MediaRecorder /
// MediaPlayer only).
// - versionCode monotonic +1 from v0.4.1.1 (37).
versionCode = 38
versionName = "0.4.2.0"
}
// --- Signing ---
@@ -182,6 +198,10 @@ dependencies {
// viewer + the list card thumbnails). It's the *interface* in
// :core:domain, not the impl, so this stays clean of ObjectBox.
implementation(project(":core:domain"))
// Phase 1 (M3 task 1): same reason for SettingsRepository — MainActivity
// reads userSettingsFlow / snapshot() and its type moved with the class
// into the shared :core:settings module.
implementation(project(":core:settings"))
implementation(libs.androidx.core.ktx)
implementation(libs.kotlinx.coroutines.android)
// v0.3.2.0: MainActivity now extends FragmentActivity so the
+11
View File
@@ -11,6 +11,11 @@
database and are never uploaded anywhere.
-->
<uses-permission android:name="android.permission.CAMERA" />
<!-- v0.4.2.0: RECORD_AUDIO for voice notes. Recordings are stored
as ordinary audio attachments inside the ObjectBox database
(at-rest encryption applies) and never leave the device —
still no INTERNET, no analytics, no cloud. -->
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<!-- v0.3.2.0: biometric (fingerprint / face) unlock for the
app-lock PIN alternative. USE_BIOMETRIC is the modern
permission; USE_FINGERPRINT is the pre-Android-10 alias and
@@ -21,6 +26,12 @@
<uses-feature
android:name="android.hardware.camera"
android:required="false" />
<!-- v0.4.2.0: voice notes need a mic; devices without one simply
never see the recorder UI light up (the permission request
fails gracefully). -->
<uses-feature
android:name="android.hardware.microphone"
android:required="false" />
<uses-feature
android:name="android.hardware.fingerprint"
android:required="false" />
+6
View File
@@ -6,6 +6,12 @@ plugins {
alias(libs.plugins.androidLibrary) apply false
alias(libs.plugins.kotlinAndroid) apply false
alias(libs.plugins.kotlinJvm) apply false
// Phase 1 (M4.1): must be registered here too — otherwise :composeApp's
// request for the multiplatform plugin collides with the KGP classes the
// other Kotlin plugin markers already put on the buildscript classpath
// ("already on classpath with unknown version" — same family as the
// kapt trap in tools/DESKTOP_PHASE_PLAN.md §2.5).
alias(libs.plugins.kotlinMultiplatform) apply false
alias(libs.plugins.kotlinCompose) apply false
alias(libs.plugins.ksp) apply false
}
+137 -45
View File
@@ -1,16 +1,139 @@
// composeApp — Android UI module hosting all screens, ViewModels, theme,
// navigation, and the manual DI container. Regular Android Compose (not
// Compose Multiplatform) is used in v0.1 to keep the build simple; the
// migration path to Multiplatform in v0.2 is a module-level refactor.
// composeApp — Incido's UI module: all screens, ViewModels, theme,
// navigation, and the manual DI container.
//
// Phase 1 (M4.1): converted in place from `kotlin("android")` to
// `kotlin("multiplatform")` with `androidTarget()` + `jvm()`, per the
// order of attack in tools/DESKTOP_PHASE_PLAN.md §6.1. The split is
// deliberately conservative — the goal of THIS step is the build shape:
//
// * commonMain — every file that compiles for both targets today
// (theme Color/Type, PasswordPolicy, ReleaseNotes,
// LinkedShareComposer) plus two expect/actual seams:
// `platformDynamicColorScheme` and `relativeTimestamp`.
// The Android actuals keep the pre-M4 code verbatim.
// * androidMain — everything still touching `android.*` (screens,
// ViewModels, AppContainer, security, backup IO, …),
// moved UNMODIFIED. Zero behaviour change; the seams
// for these move file-by-file in M4.2/M4.3.
// * jvmMain — the JVM actuals. Nothing else yet: :desktopApp keeps
// its own stand-in UI until M4.5 consumes this target.
//
// Note: :core:domain converted to multiplatform in M4.2, so commonMain
// sees it — NoteColors.kt moved up with that commit.
plugins {
alias(libs.plugins.androidLibrary)
alias(libs.plugins.kotlinAndroid)
alias(libs.plugins.kotlinMultiplatform)
// org.jetbrains.compose provides the `compose.*` dependency accessors
// that resolve to the right artifact per target (androidx.compose.*
// on androidTarget, *-desktop jars on jvm).
alias(libs.plugins.compose)
alias(libs.plugins.kotlinCompose)
// v0.3.2.0 — Kotlin Serialization for the Backup JSON codec.
// v0.3.2.0 — Kotlin Serialization for the Backup JSON codec (used by
// CarnetImporter today; the plugin stays target-agnostic).
alias(libs.plugins.kotlinSerialization)
}
kotlin {
jvmToolchain(17)
androidTarget()
jvm()
sourceSets {
commonMain.dependencies {
implementation(compose.runtime)
implementation(compose.ui)
implementation(compose.foundation)
implementation(compose.material3)
// Phase 1 (M4.4a): moved screens (IncidoDrawer, PassphraseDialog)
// use extended icons (Drafts/LabelOff/Tag/ContentCopy/Visibility).
// androidMain already had the same jetbrains coordinate (it
// resolves to androidx on that target); on jvm this pulls the
// ~100 MB material-icons-extended-desktop jar (§3 trap — a first
// build can time out; retry, don't debug).
implementation(libs.compose.material.icons.extended)
implementation(libs.kotlinx.coroutines.core)
// Phase 1 (M4.3b): the §6.4 artifact check resolves GREEN —
// these org.jetbrains.androidx.lifecycle coordinates are what
// androidMain has been resolving since M4.1 (assembleDebug
// proves they coexist with the AndroidX BOM on the android
// target), and the desktopApp runtime already carried the
// matching -desktop jars. Here they enter commonMain so the
// ViewModels move with their `androidx.lifecycle.*` imports
// UNCHANGED (the offline set keeps the androidx FQCNs).
implementation(libs.androidx.lifecycle.viewmodel)
// Phase 1 (M4.4a): screens move with their construction sites
// intact — `viewModel(factory = …)` from viewmodel-compose and
// `collectAsStateWithLifecycle` from runtime-compose. These are
// the SAME jetbrains coordinates androidMain already resolved
// since M4.1 (collectAsStateWithLifecycle reached the Android
// classpath through them), now declared in commonMain so the
// moved screens compile for both targets (§6.4 GREEN).
implementation(libs.androidx.lifecycle.viewmodel.compose)
implementation(libs.androidx.lifecycle.runtime.compose)
// Phase 1 (M4.2): :core:domain is multiplatform now (M4.2's own
// conversion), so commonMain can see it — this is what let
// NoteColors.kt move up. api: screens/ViewModels across all
// targets consume Note/NoteColor/NoteRepository from it.
api(project(":core:domain"))
// Phase 1 (M4.3a): :core:settings converted in the same shape —
// M4.3's AppGraph exposes SettingsRepository/UserSettings to
// commonMain, so this has to be api too.
api(project(":core:settings"))
}
androidMain.dependencies {
implementation(project(":core:data"))
// Phase 1 (M2 task 1): backup codecs + bridge now live here; the
// org.incido.compose.data.backup package name was kept, so no imports
// changed — only this dependency line.
implementation(project(":core:backup"))
// Phase 1 (M3 task 1): settings repository, same treatment — package
// kept, the Context-based construction moved to AndroidSettingsStore.kt.
implementation(project(":core:settings"))
// Core / lifecycle
implementation(libs.androidx.core.ktx)
implementation(libs.androidx.lifecycle.viewmodel)
implementation(libs.androidx.lifecycle.viewmodel.compose)
implementation(libs.androidx.lifecycle.runtime)
implementation(libs.androidx.lifecycle.process)
implementation(libs.kotlinx.coroutines.android)
// Compose BOM keeps all Compose artefact versions aligned.
// (Called inline — the KMP source-set dependency handler's
// platform() returns a raw notation, not a Dependency, so the
// old `val composeBom = platform(…)` idiom fails here.)
implementation(project.dependencies.platform(libs.composeBom))
implementation(libs.androidx.activity.compose)
implementation(libs.androidx.navigation.compose)
// Compose (same org.jetbrains.compose artifacts as before the
// M4.1 conversion — they resolve to the androidx variants on
// this target; version alignment unchanged).
implementation(libs.compose.ui)
implementation(libs.compose.ui.tooling.preview)
implementation(libs.compose.foundation)
implementation(libs.compose.material3)
implementation(libs.compose.material.icons.extended)
// v0.3.2.0 — Settings (DataStore Preferences), Security (Biometric),
// and Backup (Kotlin Serialization JSON) support.
implementation(libs.androidx.datastore.preferences)
implementation(libs.androidx.biometric)
implementation(libs.kotlinx.serialization.json)
}
jvmMain.dependencies {
// Nothing yet — the compose artifacts arrive via commonMain;
// :core:data-jvm / :core:settings wiring lands with M4.3's
// container seam when :desktopApp starts consuming this target.
}
}
}
android {
namespace = "org.incido.compose"
compileSdk = 35
@@ -19,20 +142,15 @@ android {
minSdk = 26
}
buildFeatures {
compose = true
buildConfig = true
}
// M4.1: `buildFeatures.compose` is NOT set — the org.jetbrains.compose
// plugin owns Compose wiring on this target (setting it here alongside
// the KMP plugin is the classic double-wire; see §3 trap 6's sibling).
compileOptions {
sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17
}
kotlin {
jvmToolchain(17)
}
packaging {
resources {
excludes += "/META-INF/{AL2.0,LGPL2.1}"
@@ -40,37 +158,11 @@ android {
}
}
// AGP's debug-only configurations are project-level, so the Compose
// tooling dependency that was `debugImplementation` before the M4.1
// conversion keeps that exact scope here (the KMP `sourceSets { … }`
// dependency handlers only expose implementation/api/compileOnly).
dependencies {
implementation(project(":core:domain"))
implementation(project(":core:data"))
// Core / lifecycle
implementation(libs.androidx.core.ktx)
implementation(libs.androidx.lifecycle.viewmodel)
implementation(libs.androidx.lifecycle.viewmodel.compose)
implementation(libs.androidx.lifecycle.runtime)
implementation(libs.androidx.lifecycle.process)
implementation(libs.kotlinx.coroutines.android)
// Compose BOM keeps all Compose artefact versions aligned
val composeBom = platform(libs.composeBom)
implementation(composeBom)
androidTestImplementation(composeBom)
implementation(libs.androidx.activity.compose)
implementation(libs.androidx.navigation.compose)
// Compose
implementation(libs.compose.ui)
implementation(libs.compose.ui.tooling.preview)
implementation(libs.compose.foundation)
implementation(libs.compose.material3)
implementation(libs.compose.material.icons.extended)
debugImplementation(libs.compose.ui.tooling)
// v0.3.2.0 — Settings (DataStore Preferences), Security (Biometric),
// and Backup (Kotlin Serialization JSON) support.
implementation(libs.androidx.datastore.preferences)
implementation(libs.androidx.biometric)
implementation(libs.kotlinx.serialization.json)
}
@@ -0,0 +1,283 @@
package org.incido.compose
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.DrawerValue
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.ModalNavigationDrawer
import androidx.compose.material3.rememberDrawerState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.runtime.snapshots.SnapshotStateList
import androidx.compose.runtime.toMutableStateList
import androidx.compose.ui.platform.LocalContext
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.compose.LocalLifecycleOwner
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.navigation.NavType
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.currentBackStackEntryAsState
import androidx.navigation.compose.rememberNavController
import androidx.navigation.navArgument
import kotlinx.coroutines.launch
import org.incido.compose.data.security.SecurityManager
import org.incido.compose.data.settings.SettingsRepository
import org.incido.compose.di.LocalAndroidContainer
import org.incido.compose.di.LocalAppGraph
import org.incido.compose.share.SharedIntentBuffer
import org.incido.compose.ui.drawer.IncidoDrawer
import org.incido.compose.ui.editor.NoteEditorScreen
import org.incido.compose.ui.editor.SharedImage
import org.incido.compose.ui.notelist.NoteListScreen
import org.incido.compose.ui.settings.SettingsScreen
import org.incido.compose.ui.settings.auth.PinChangeScreen
import org.incido.compose.ui.settings.auth.PinEntryScreen
import org.incido.compose.ui.settings.auth.PinSetupScreen
import org.incido.compose.ui.theme.IncidoTheme
import org.incido.domain.model.NoteColor
import org.incido.domain.model.NoteFilter
import org.incido.domain.repository.NoteRepository
/** Top-level navigation destinations. */
private object Routes {
const val LIST = "list"
const val EDITOR = "editor/{noteId}"
const val SETTINGS = "settings"
const val PIN_SETUP = "pin_setup"
/** v0.3.3.0: three-step "Reset PIN" flow. */
const val PIN_CHANGE = "pin_change"
fun editor(noteId: Long?): String = "editor/${noteId ?: -1L}"
}
/** Stable serialisation for [NoteFilter] so `rememberSaveable` works. */
private fun NoteFilter.toSaveableKey(): String = key()
private fun String.toNoteFilter(): NoteFilter = when {
this == "home" -> NoteFilter.Home
this == "favorites" -> NoteFilter.Favorites
this == "untagged" -> NoteFilter.Untagged
this == "drafts" -> NoteFilter.Drafts
this == "trash" -> NoteFilter.Trash
startsWith("tag:") -> NoteFilter.ByTag(this.removePrefix("tag:"))
startsWith("color:") -> NoteColor.values()
.firstOrNull { it.name == this.removePrefix("color:") }
?.let { NoteFilter.ByColor(it) }
?: NoteFilter.Home
else -> NoteFilter.Home
}
/**
* v0.3.1.0: Holds the share-into payload (text + pre-loaded image
* bytes) so the [NoteEditorScreen] can read it on first composition.
* Cleared as soon as the editor is created.
*
* v0.3.6.0: also carries [subject] (`Intent.EXTRA_SUBJECT`) so the
* editor can put the page title on the note's first line for URL
* shares — still offline-only, no network fetch.
*/
private class ShareIntoHolder {
var text: String? = null
var images: List<SharedImage> = emptyList()
var subject: String? = null
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun IncidoApp(
repository: NoteRepository? = null,
securityManager: SecurityManager? = null,
settingsRepository: SettingsRepository? = null,
) {
val context = LocalContext.current
val app = context.applicationContext as IncidoApplication
// v0.3.2.0: prefer explicit params, fall back to the application
// container. Both hosts (`MainActivity` + tests) supply them in
// production — the fallback is just a robustness net.
val resolvedSecurity = securityManager ?: app.container.securityManager
val resolvedSettings = settingsRepository ?: app.container.settingsRepository
// v0.3.2.0: collect user settings to drive theme + the auth gate.
val settings by resolvedSettings.userSettingsFlow.collectAsStateWithLifecycle(
initialValue = org.incido.compose.data.settings.UserSettings(),
)
val lockState by resolvedSecurity.lockState.collectAsStateWithLifecycle()
// M4.3: the platform graph reaches the screens through the composition —
// the same face DesktopContainer implements (commonMain di/AppGraph.kt).
CompositionLocalProvider(
LocalAppGraph provides app.container,
LocalAndroidContainer provides app.container,
) {
IncidoTheme(
darkTheme = settings.themeMode.resolveDark(isSystemInDarkTheme()),
dynamicColor = settings.dynamicColor,
) {
// v0.3.2.0: hard lock gate. If the app is locked we render
// the PIN entry screen in place of the regular UI.
if (lockState is SecurityManager.LockState.Locked) {
PinEntryScreen()
return@IncidoTheme
}
val navController = rememberNavController()
val drawerState = rememberDrawerState(initialValue = DrawerValue.Closed)
val scope = rememberCoroutineScope()
var filterMode by rememberSaveable(
stateSaver = androidx.compose.runtime.saveable.Saver(
save = { it.toSaveableKey() },
restore = { it.toNoteFilter() },
),
) { mutableStateOf<NoteFilter>(NoteFilter.Home) }
// v0.3.1.0: consume any inbound share-into payload once at
// composition. The buffer is single-shot — first composition
// wins. If a payload is present, we open a fresh editor with
// the shared content pre-filled.
val shareHolder = remember { ShareIntoHolder() }
LaunchedEffect(Unit) {
val payload = SharedIntentBuffer.consume()
if (payload != null && !payload.isEmpty) {
shareHolder.text = payload.text
shareHolder.images = payload.images
shareHolder.subject = payload.subject
navController.navigate(Routes.editor(null)) {
popUpTo(Routes.LIST)
}
}
}
val currentBackStack by navController.currentBackStackEntryAsState()
val currentRoute = currentBackStack?.destination?.route?.substringBefore("/")
// Disable the drawer on the editor so back arrow / gesture do
// exactly what the user expects there.
val isListRoute = currentRoute == Routes.LIST
LaunchedEffect(currentRoute) {
// If we land on the editor via deep link without a list in
// the back stack, snap the drawer closed.
if (!isListRoute && drawerState.isOpen) drawerState.close()
}
// v0.3.2.0: forward app foreground/background transitions to
// the SecurityManager so it can re-lock when the timeout
// elapses. LifecycleEventObserver wires ON_RESUME / ON_STOP
// automatically.
val lifecycleOwner = LocalLifecycleOwner.current
DisposableEffect(lifecycleOwner) {
val observer = LifecycleEventObserver { _, event ->
when (event) {
Lifecycle.Event.ON_RESUME -> resolvedSecurity.onAppForegrounded()
Lifecycle.Event.ON_STOP -> resolvedSecurity.onAppBackgrounded()
else -> Unit
}
}
lifecycleOwner.lifecycle.addObserver(observer)
onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }
}
ModalNavigationDrawer(
drawerState = drawerState,
gesturesEnabled = isListRoute,
drawerContent = {
IncidoDrawer(
currentFilter = filterMode,
onSelectFilter = { picked ->
filterMode = picked
scope.launch { drawerState.close() }
},
onOpenSettings = {
scope.launch { drawerState.close() }
navController.navigate(Routes.SETTINGS)
},
)
},
) {
NavHost(navController = navController, startDestination = Routes.LIST) {
composable(Routes.LIST) {
NoteListScreen(
filterMode = filterMode,
onOpenDrawer = { scope.launch { drawerState.open() } },
onOpenEditor = { id -> navController.navigate(Routes.editor(id)) },
// v0.3.1.0: thread the NoteRepository through so the
// card thumbnail composables can fetch image bytes.
repository = repository,
)
}
composable(
route = Routes.EDITOR,
arguments = listOf(
navArgument("noteId") {
type = NavType.LongType
defaultValue = -1L
},
),
) { entry ->
val raw = entry.arguments?.getLong("noteId") ?: -1L
val id = if (raw <= 0L) null else raw
// Read the share payload ONCE (consume) so back-then-reopen
// doesn't re-route us into the editor with stale data.
val sharedText = shareHolder.text.also { shareHolder.text = null }
val sharedImages = shareHolder.images.also { shareHolder.images = emptyList() }
// v0.3.6.0: also drain the page-title subject from the
// share intent so the editor can format the note
// with title on the first line.
val sharedSubject = shareHolder.subject.also { shareHolder.subject = null }
NoteEditorScreen(
noteId = id,
onClose = { navController.popBackStack() },
initialSharedText = sharedText,
initialSharedImages = sharedImages,
initialSharedSubject = sharedSubject,
repository = repository,
// v0.3.4.0 hotfix: suppress auto-lock around
// the editor's picker / camera / system-viewer
// round-trips. M4.4c: the editor lives in
// commonMain now and cannot name the Android
// SecurityManager — it takes this neutral
// lambda instead.
beginExternalActivity = resolvedSecurity
?.let { sec -> { sec.beginExternalActivity() } },
)
}
composable(Routes.SETTINGS) {
SettingsScreen(
onBack = { navController.popBackStack() },
onRequestPinSetup = { navController.navigate(Routes.PIN_SETUP) },
// v0.3.3.0: "Reset PIN" row navigates here.
onRequestPinChange = { navController.navigate(Routes.PIN_CHANGE) },
// v0.3.4.0 hotfix: suppress auto-lock around
// the backup export/import SAF pickers.
securityManager = resolvedSecurity,
)
}
composable(Routes.PIN_SETUP) {
PinSetupScreen(
onDone = { navController.popBackStack() },
onCancel = { navController.popBackStack() },
)
}
composable(Routes.PIN_CHANGE) {
PinChangeScreen(
onDone = { navController.popBackStack() },
onCancel = { navController.popBackStack() },
)
}
}
}
}
}
}
// Suppress unused-import lint for the snapshots helper that may be
// re-introduced in future filter-state extensions.
@Suppress("unused")
private fun <T> List<T>.toSnapshotStateList(): SnapshotStateList<T> = toMutableStateList<T>()
@@ -8,8 +8,10 @@ import org.incido.compose.di.AppContainer
* Application class. Constructs the singleton [AppContainer] holding the
* ObjectBox store and the note repository.
*
* ViewModels reach the container via `(application as IncidoApplication).container`
* (see `NoteListViewModel.Factory` and `NoteEditorViewModel.factory`).
* M4.3: the screens reach the container through `LocalAppGraph` (provided
* by `IncidoApp`); the graph-based ViewModel factories (`factory(graph)`)
* no longer touch the Application through CreationExtras. The Application
* still owns construction order.
*
* v0.3.2.0 — initialises the [SecurityManager] lock state during
* `onCreate` so the first composition of the root Compose tree
@@ -0,0 +1,103 @@
package org.incido.compose.data.backup
import android.content.Context
import android.net.Uri
import java.io.IOException
import java.io.InputStream
import java.io.OutputStream
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.incido.domain.repository.NoteRepository
/**
* v0.3.2.0: orchestration layer for Backup / Import / Export.
*
* Phase 1 (M2 task 1): this class is now a **thin Storage Access
* Framework shim**. It converts the [Uri]s that
* `ActivityResultContracts.CreateDocument` / `OpenDocument` hand back
* into streams and delegates everything else — format, crypto,
* snapshotting — to [BackupManager]'s former body, now the platform-
* neutral [BackupBridge] in `:core:backup`. The desktop app (M2 task 2)
* calls [BackupBridge] directly with file streams.
*
* Public API is unchanged: [SettingsViewModel] and the backup screens
* compile exactly as before.
*/
class BackupManager(
private val context: Context,
private val repository: NoteRepository,
) {
/**
* Snapshot every note in [repository] and stream it to [uri] as a
* plain JSON file. Throws on I/O failure.
*
* Returns the number of notes exported.
*/
suspend fun exportPlain(
uri: Uri,
appVersion: String,
onProgress: (current: Int, total: Int) -> Unit = { _, _ -> },
): Int = withContext(Dispatchers.IO) {
BackupBridge.exportPlain(repository, openOutput(uri), appVersion, onProgress)
}
/**
* Snapshot every note and stream it to [uri] as a passphrase-
* encrypted envelope. [passphrase] is consumed (zeroed) inside
* [EncryptedBackupCodec.encrypt].
*/
suspend fun exportEncrypted(
uri: Uri,
passphrase: CharArray,
appVersion: String,
onProgress: (current: Int, total: Int) -> Unit = { _, _ -> },
): Int = withContext(Dispatchers.IO) {
BackupBridge.exportEncrypted(repository, openOutput(uri), passphrase, appVersion, onProgress)
}
/**
* Read [uri] and import every note it contains. Auto-detects
* plain vs encrypted via the magic header. For encrypted files,
* [passphrase] is required (caller validates with
* [PasswordPolicy]).
*
* [skipExisting] (default true) dedupes on the bridge's
* (createdAt, updatedAt, sha256(content)) key — see
* [BackupBridge.import]. Returns what was imported vs skipped.
*/
suspend fun import(
uri: Uri,
passphrase: CharArray? = null,
skipExisting: Boolean = true,
onProgress: (current: Int, total: Int) -> Unit = { _, _ -> },
): ImportSummary = withContext(Dispatchers.IO) {
BackupBridge.import(repository, openInput(uri), passphrase, skipExisting, onProgress)
}
/**
* Cheap metadata preview — used by the "Import from file…" flow
* to show the user how many notes / attachments they're about to
* bring in before they commit.
*
* Returns `null` if the file can't be read or the passphrase is
* wrong (so the UI can surface "wrong passphrase" cleanly).
*/
suspend fun preview(uri: Uri, passphrase: CharArray? = null): BackupPreview? =
withContext(Dispatchers.IO) {
val input: InputStream = try {
context.contentResolver.openInputStream(uri) ?: return@withContext null
} catch (_: IOException) {
return@withContext null
}
BackupBridge.preview(input, passphrase)
}
private fun openOutput(uri: Uri): OutputStream =
context.contentResolver.openOutputStream(uri, "wt")
?: throw IOException("Could not open output stream for $uri")
private fun openInput(uri: Uri): InputStream =
context.contentResolver.openInputStream(uri)
?: throw IOException("Could not open input stream for $uri")
}
@@ -0,0 +1,14 @@
package org.incido.compose.data.backup
import java.security.SecureRandom
/**
* M4.4a seam for [PassphraseGenerator] — identical two-liner actual on
* both targets (both targets ARE the JVM; commonMain just cannot spell
* `java.security`). Behaviour (CSPRNG backing, draw distribution) is
* exactly the pre-M4 `SecureRandom()` field it replaces.
*/
private val secureRandom = SecureRandom()
internal actual fun secureRandomInt(bound: Int): Int = secureRandom.nextInt(bound)
@@ -0,0 +1,22 @@
package org.incido.compose.data.settings
import android.content.Context
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.preferencesDataStore
/**
* Phase 1 (M3 task 1): the Android half of the settings seam.
*
* v0.3.2.0: Application-wide DataStore Preferences instance. Declared
* as a Context extension property so the same backing file is shared
* by every call site. Backed by `incido_settings.preferences_pb` in
* the app's `noBackupFiles` directory.
*
* Lives on the Android side now that [SettingsRepository] is platform
* neutral (it takes an injected DataStore); the desktop build creates the
* same-format store from a file path instead of a Context.
*/
val Context.settingsDataStore: DataStore<Preferences> by preferencesDataStore(
name = "incido_settings",
)
@@ -0,0 +1,21 @@
package org.incido.compose.di
import androidx.compose.runtime.Composable
import androidx.compose.runtime.compositionLocalOf
/**
* M4.3c — Android-only bridge beside [LocalAppGraph].
*
* `SettingsViewModel` still needs the concrete [AppContainer] (Security
* Manager, Keystore key provider, BackupManager, CarnetImporter — the
* Android services M4.3 deliberately did NOT widen the graph with). The
* screen reads this local until M4.4/4.5 ports or hides that surface;
* `IncidoApp` provides the SAME container instance through both locals.
*/
val LocalAndroidContainer = compositionLocalOf<AppContainer?> { null }
/** Read [LocalAndroidContainer] or throw with context — call at composition. */
@Composable
fun requireAndroidContainer(): AppContainer = checkNotNull(LocalAndroidContainer.current) {
"No AppContainer provided — IncidoApp provides it at the root."
}
@@ -5,18 +5,24 @@ import io.objectbox.BoxStore
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import org.incido.data.AndroidImageOrientationNormalizer
import org.incido.data.ObjectBoxStore
import org.incido.data.crypto.AesGcmFieldCipher
import org.incido.data.crypto.CipherHolder
import org.incido.data.crypto.EncryptionVerifier
import org.incido.data.crypto.NoteCryptoService
import org.incido.data.repository.NoteRepositoryImpl
import org.incido.domain.repository.NoteRepository
import org.incido.compose.data.backup.BackupManager
import org.incido.compose.data.backup.CarnetImporter
import org.incido.compose.data.security.AesGcmFieldCipher
import org.incido.compose.data.security.EncryptionVerifier
import org.incido.compose.data.security.ObjectBoxKeyProvider
import org.incido.compose.data.security.SecurityManager
import org.incido.compose.data.settings.SettingsRepository
import org.incido.compose.data.settings.settingsDataStore
import org.incido.compose.di.AppGraph
import org.incido.compose.di.EncryptionBadge
import org.incido.compose.di.LibraryVerification
import kotlinx.coroutines.flow.map
/**
* Hand-rolled DI container. Replaces Hilt/Dagger for v0.1 — keeps the
@@ -39,8 +45,14 @@ import org.incido.compose.data.settings.SettingsRepository
* After startup the [encryptionVerifier] re-checks every encrypted row
* by trial-decrypting it; only rows that pass earn the "Encrypted"
* badge on the note cards.
*
* Phase 1 (M4.3): implements [AppGraph] — the platform-neutral face the
* commonMain ViewModels consume. Android-only services (Keystore key
* provider, SecurityManager, BackupManager, CarnetImporter) stay on this
* concrete class; the graph is exactly what the desktop
* `DesktopContainer` can implement too.
*/
class AppContainer(context: Context) {
class AppContainer(context: Context) : AppGraph {
private val appContext: Context = context.applicationContext
@@ -48,7 +60,11 @@ class AppContainer(context: Context) {
* (verification sweeps, etc.). SupervisorJob isolates failures. */
val appScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
val settingsRepository: SettingsRepository = SettingsRepository(appContext)
// Phase 1 (M3 task 1): the store is injected — SettingsRepository moved
// to :core:settings so the desktop build can share it. Android supplies
// the Context-backed `incido_settings.preferences_pb` store here.
override val settingsRepository: SettingsRepository =
SettingsRepository(appContext.settingsDataStore)
val objectBoxKeyProvider: ObjectBoxKeyProvider = ObjectBoxKeyProvider(appContext)
@@ -71,11 +87,19 @@ class AppContainer(context: Context) {
init {
val s = settingsRepository.snapshot()
if (s.isEncryptionActive && objectBoxKeyProvider.hasKeyBlocking()) {
cipherHolder.cipher = AesGcmFieldCipher(objectBoxKeyProvider)
// M3 task 2 seam: the cipher only needs the key bytes; the
// Keystore-wrapped provider is passed as a plain function.
cipherHolder.cipher = AesGcmFieldCipher(objectBoxKeyProvider::getOrCreateKey)
}
}
val noteRepository: NoteRepository = NoteRepositoryImpl(boxStore, cipherHolder)
override val noteRepository: NoteRepository = NoteRepositoryImpl(
boxStore,
cipherHolder,
// Phase 1 (M1a) platform seam: EXIF rotation needs a bitmap decoder,
// which Android owns and the desktop build has yet to grow.
AndroidImageOrientationNormalizer(),
)
val backupManager: BackupManager = BackupManager(appContext, noteRepository)
@@ -89,6 +113,18 @@ class AppContainer(context: Context) {
/** Runs on every app open — feeds the verified-encryption badge. */
val encryptionVerifier = EncryptionVerifier(noteCryptoService, appScope)
/**
* M4.3c: [AppGraph]'s shared face over the concrete verifier — the
* 3-field copy is why `LibraryVerification` mirrors the data class
* (see EncryptionBadge.kt: :core:data is an androidLibrary, invisible
* to commonMain, and must stay that way per invariant §2.3).
*/
override val encryptionBadge: EncryptionBadge = object : EncryptionBadge {
override val verification = encryptionVerifier.verification.map { result ->
result?.let { LibraryVerification(it.verifiedNoteIds, it.failedNoteIds, it.checkedAt) }
}
}
/** Kick the startup verification off immediately. */
init {
encryptionVerifier.checkNow()
@@ -0,0 +1,6 @@
package org.incido.compose.di
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.Dispatchers
internal actual val ioDispatcher: CoroutineDispatcher = Dispatchers.IO
@@ -0,0 +1,312 @@
package org.incido.compose.ui.editor
import android.Manifest
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.net.Uri
import android.widget.Toast
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.core.content.ContextCompat
import androidx.core.content.FileProvider
import java.io.File
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.incido.domain.model.NoteAttachment
import org.incido.domain.repository.NoteRepository
/**
* M4.4c Android actual — the editor's Android intake code, moved from
* `NoteEditorScreen` essentially verbatim (camera + permission + file
* launchers, the FileProvider/ACTION_VIEW open path from
* `AttachmentThumbnail`, the Toasts, and the two private file helpers).
*
* The one spelling change: `securityManager?.beginExternalActivity()`
* is now the injected neutral `beginExternalActivity` lambda (the
* screen can no longer name the Android type in commonMain). Call sites
* (camera round-trip, picker, system viewer) are unchanged.
*/
@Composable
actual fun rememberEditorIntake(
onPickedBytes: suspend (bytes: ByteArray, mimeType: String, displayName: String) -> Unit,
onVoiceConvert: () -> Unit,
isVoiceMode: Boolean,
beginExternalActivity: (() -> Unit)?,
): EditorIntake {
val ctx = LocalContext.current
val scope = rememberCoroutineScope()
// v0.3.1.0: camera permission + capture. The camera launcher is
// declared FIRST so the permission callback (below) can forward to it
// without a Kotlin forward-reference error.
var pendingCameraUri by remember { mutableStateOf<Uri?>(null) }
val cameraLauncher = rememberLauncherForActivityResult(
ActivityResultContracts.TakePicture()
) { success ->
val uri = pendingCameraUri
if (success && uri != null) {
scope.launch {
val bytes = withContext(Dispatchers.IO) {
ctx.contentResolver.openInputStream(uri)?.use { it.readBytes() }
}
// Always delete the temp file — its bytes are now in the DB.
runCatching { uri.path?.let { File(it).delete() } }
pendingCameraUri = null
if (bytes != null) {
onPickedBytes(
bytes,
"image/jpeg",
"IMG_${System.currentTimeMillis()}.jpg",
)
} else {
Toast.makeText(ctx, "Couldn't read captured photo", Toast.LENGTH_SHORT).show()
}
}
} else {
pendingCameraUri = null
}
}
// Now declared AFTER cameraLauncher so it can forward to it.
val cameraPermissionLauncher = rememberLauncherForActivityResult(
ActivityResultContracts.RequestPermission()
) { granted ->
if (granted) {
pendingCameraUri?.let { uri ->
// v0.3.4.0 hotfix: the camera app takes us fully out of
// the process — with Auto-Lock = Immediate the return
// trip used to land on the lock screen (losing the
// unsaved note). Flag the round-trip so the re-lock is
// suppressed.
beginExternalActivity?.invoke()
cameraLauncher.launch(uri)
}
} else {
Toast.makeText(ctx, "Camera permission denied", Toast.LENGTH_SHORT).show()
}
}
val filePickerLauncher = rememberLauncherForActivityResult(
ActivityResultContracts.OpenDocument()
) { uri ->
if (uri == null) return@rememberLauncherForActivityResult
scope.launch {
val ctxForResolver = ctx
val (bytes, displayName, mime) = withContext(Dispatchers.IO) {
val resolver = ctxForResolver.contentResolver
val name = queryDisplayName(resolver, uri) ?: "Attachment_${System.currentTimeMillis()}"
val mimeType = resolver.getType(uri) ?: "application/octet-stream"
val data = resolver.openInputStream(uri)?.use { it.readBytes() }
Triple(data, name, mimeType)
}
if (bytes != null) {
onPickedBytes(bytes, mime, displayName)
} else {
Toast.makeText(ctx, "Couldn't read attachment", Toast.LENGTH_SHORT).show()
}
}
}
// v0.4.2.0 — voice notes. RECORD_AUDIO is requested the first time
// the user toggles the mic mode; on grant the note converts. The
// grant state is checked LIVE on every tap (a revoke from Settings
// mid-session must not slip through a cached flag).
val micPermissionLauncher = rememberLauncherForActivityResult(
ActivityResultContracts.RequestPermission()
) { granted ->
if (granted) {
onVoiceConvert()
} else {
Toast.makeText(ctx, "Microphone permission denied", Toast.LENGTH_SHORT).show()
}
}
fun micPermissionGranted(): Boolean =
ContextCompat.checkSelfPermission(
ctx,
Manifest.permission.RECORD_AUDIO,
) == PackageManager.PERMISSION_GRANTED
return object : EditorIntake {
override val supportsCamera = true
override val supportsVoice = true
override fun takePhoto() {
val (uri, _) = createTempCameraUri(ctx)
if (uri == null) {
Toast.makeText(ctx, "Couldn't prepare camera outbox", Toast.LENGTH_SHORT).show()
return
}
pendingCameraUri = uri
cameraPermissionLauncher.launch(Manifest.permission.CAMERA)
}
override fun pickFiles() {
// v0.3.4.0 hotfix: the SAF picker backgrounds the app; with
// Auto-Lock = Immediate the return used to lock the app and
// wipe the unsaved note.
beginExternalActivity?.invoke()
filePickerLauncher.launch(arrayOf("*/*"))
}
override fun toggleVoiceMode() {
if (isVoiceMode) {
// Toggling back needs no mic at all — the take survives as
// an ordinary attachment.
onVoiceConvert()
return
}
if (micPermissionGranted()) {
onVoiceConvert()
} else {
micPermissionLauncher.launch(Manifest.permission.RECORD_AUDIO)
}
}
override fun checkMicPermission(): Boolean = micPermissionGranted()
override fun requestMicPermission() {
micPermissionLauncher.launch(Manifest.permission.RECORD_AUDIO)
}
override fun notify(msg: String) {
Toast.makeText(ctx, msg, Toast.LENGTH_SHORT).show()
}
override fun openExternal(bytes: ByteArray, mimeType: String, displayName: String) {
// v0.3.1.2 path, verbatim from AttachmentThumbnail's tap
// handler: cache temp file → FileProvider Uri → ACTION_VIEW.
runCatching {
// Sanitise displayName for use as a filename —
// strip any path separators / chars the OS
// doesn't allow in filenames.
val safeName = displayName.replace(Regex("[/\\\\:*?\"<>|]"), "_")
// v0.3.1.3: write into a dedicated `open_outbox/`
// subdir under cacheDir so it falls inside the
// FileProvider's exposed path set (see
// app/src/main/res/xml/file_paths.xml). Previously
// this wrote straight to cacheDir which is NOT
// exposed, so FileProvider.getUriForFile threw
// IllegalArgumentException and the runCatching
// swallowed it as the misleading "No app can
// open …" toast.
val outbox = File(ctx.cacheDir, "open_outbox").apply { mkdirs() }
val tmp = File(
outbox,
"open_${System.currentTimeMillis()}_$safeName",
).apply { createNewFile() }
tmp.writeBytes(bytes)
val uri = FileProvider.getUriForFile(
ctx,
"${ctx.packageName}.fileprovider",
tmp,
)
val intent = Intent(Intent.ACTION_VIEW).apply {
setDataAndType(uri, mimeType)
addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
}
// v0.3.4.0 hotfix: opening an attachment in the system
// viewer also leaves the app — suppress the auto-lock on
// return.
beginExternalActivity?.invoke()
ctx.startActivity(intent)
}.onFailure { err ->
// v0.3.1.3: distinguish "no handler" from "couldn't
// open". ActivityNotFoundException means the OS has no
// app registered for this mime type (e.g. no PDF viewer
// installed); anything else (typically
// IllegalArgumentException from FileProvider when
// file_paths.xml is misconfigured, or IOException from
// the cache write) gets a generic message.
val msg = if (err is android.content.ActivityNotFoundException) {
"No app can open $displayName"
} else {
"Couldn't open $displayName"
}
Toast.makeText(ctx, msg, Toast.LENGTH_SHORT).show()
}
}
}
}
/**
* M4.4c Android actual: the voice recorder card — the same
* `VoiceNoteSection` the screen called directly, now reached through
* the common slot. The old `securityManager` argument becomes the
* neutral [beginExternalActivity] lambda (see VoiceNoteSection).
*/
@Composable
actual fun VoiceNoteSlot(
voicePending: PendingAttachment?,
voicePendingBytes: ByteArray?,
voicePersisted: NoteAttachment?,
repository: NoteRepository?,
hasMicPermission: () -> Boolean,
onRequestPermission: () -> Unit,
onTakeRecorded: (ByteArray, String) -> Unit,
onDeleteTake: () -> Unit,
beginExternalActivity: (() -> Unit)?,
modifier: Modifier,
) {
VoiceNoteSection(
voicePending = voicePending,
voicePendingBytes = voicePendingBytes,
voicePersisted = voicePersisted,
repository = repository,
hasMicPermission = hasMicPermission,
onRequestPermission = onRequestPermission,
onTakeRecorded = onTakeRecorded,
onDeleteTake = onDeleteTake,
beginExternalActivity = beginExternalActivity,
modifier = modifier,
)
}
// ---------------------------------------------------------------------
// helpers — moved verbatim from NoteEditorScreen.kt
// ---------------------------------------------------------------------
/**
* Create a temporary file in the app's cache and return a
* FileProvider-scoped Uri pointing at it. The camera app writes a JPEG
* there; we read the bytes and delete the temp file. Returns
* `(uri, file)` so the caller can clean up if reading fails.
*/
private fun createTempCameraUri(ctx: Context): Pair<Uri?, File?> {
return try {
val outbox = File(ctx.cacheDir, "camera_outbox").apply { mkdirs() }
val file = File(outbox, "cap_${System.currentTimeMillis()}.jpg")
file.createNewFile()
val authority = "${ctx.packageName}.fileprovider"
val uri = FileProvider.getUriForFile(ctx, authority, file)
uri to file
} catch (e: Exception) {
null to null
}
}
/**
* Read the Open Documents column DISPLAY_NAME for a content:// Uri,
* falling back to the last path segment. Returns null if neither
* works (which is fine — the caller uses a generated default).
*/
private fun queryDisplayName(resolver: android.content.ContentResolver, uri: Uri): String? {
return try {
resolver.query(uri, arrayOf(android.provider.OpenableColumns.DISPLAY_NAME), null, null, null)
?.use { cursor ->
if (cursor.moveToFirst()) {
val idx = cursor.getColumnIndex(android.provider.OpenableColumns.DISPLAY_NAME)
if (idx >= 0) cursor.getString(idx) else null
} else null
}
} catch (_: Exception) {
null
}
}
@@ -0,0 +1,538 @@
package org.incido.compose.ui.editor
import android.content.ContentValues
import android.content.Context
import android.content.Intent
import android.media.MediaPlayer
import android.os.Build
import android.os.Environment
import android.provider.MediaStore
import android.widget.Toast
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.Download
import androidx.compose.material.icons.filled.FiberManualRecord
import androidx.compose.material.icons.filled.Mic
import androidx.compose.material.icons.filled.Pause
import androidx.compose.material.icons.filled.PlayArrow
import androidx.compose.material.icons.filled.Stop
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Slider
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.produceState
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.core.content.FileProvider
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.withContext
import org.incido.domain.model.NoteAttachment
import org.incido.domain.repository.NoteRepository
import java.io.File
import java.util.Locale
/**
* v0.4.2.0 — the voice-note body section: sits at the very top of the
* note body (above the text field) whenever the editor is in
* [org.incido.domain.model.NoteType.VOICE_NOTE] mode.
*
* Three states:
* * **No take** — "tap to record" card.
* * **Recording** — live elapsed timer with stop / discard controls.
* * **Take ready** (pending *or* persisted) — media player bar with
* play/pause, seek, a **Download** action that copies the file to
* the system Downloads folder, and a delete action (re-record via
* the mic button — the ViewModel replaces the old take when a new
* recording lands).
*
* The take rides the existing attachment pipeline: while the note is
* unsaved it is a [PendingAttachment] whose bytes live in the UI
* state; after save it is an ordinary `audio/ogg` attachment row
* (encrypted at rest like every other attachment, backed up with the
* note, and still visible in the attachment strip below).
*/
@Composable
fun VoiceNoteSection(
/** Pending (unsaved) voice take, or null. */
voicePending: PendingAttachment?,
/** Bytes of the pending take (null while still unrecorded). */
voicePendingBytes: ByteArray?,
/** Persisted voice take of a saved note, or null. */
voicePersisted: NoteAttachment?,
/** Source of persisted bytes (lazy-loaded by the player). */
repository: NoteRepository?,
/** Checked on every record tap — reflects RECORD_AUDIO state. */
hasMicPermission: () -> Boolean,
/** Launches the RECORD_AUDIO permission request. */
onRequestPermission: () -> Unit,
/** A finished recording is ready to stage/persist (replaces any old take);
* second arg is the recorder's actual mime (`audio/ogg`, or `audio/mp4` on API 26–28). */
onTakeRecorded: (ByteArray, String) -> Unit,
/** Remove the current take (pending or persisted). */
onDeleteTake: () -> Unit,
/** Suppress auto-lock around the download share-sheet round-trip (API < 29). */
beginExternalActivity: (() -> Unit)?,
modifier: Modifier = Modifier,
) {
val ctx = LocalContext.current
val recorder = remember { VoiceRecorder() }
var isRecording by remember { mutableStateOf(false) }
var elapsedMs by remember { mutableStateOf(0L) }
// Abandon an in-flight take if the editor tears down mid-recording
// (back navigation, config change) — no orphan temp files.
DisposableEffect(Unit) {
onDispose { recorder.cancel() }
}
// Live tick for the recording timer.
LaunchedEffect(isRecording) {
if (!isRecording) return@LaunchedEffect
val startedAt = android.os.SystemClock.elapsedRealtime() - elapsedMs
while (isRecording) {
elapsedMs = android.os.SystemClock.elapsedRealtime() - startedAt
delay(100)
}
}
fun startRecording() {
if (!hasMicPermission()) {
onRequestPermission()
return
}
try {
recorder.start(ctx)
elapsedMs = 0L
isRecording = true
} catch (e: Exception) {
Toast.makeText(ctx, "Couldn't start recording", Toast.LENGTH_SHORT).show()
}
}
fun stopRecording() {
val bytes = recorder.stopAndReadBytes()
isRecording = false
if (bytes == null) {
Toast.makeText(ctx, "Recording failed", Toast.LENGTH_SHORT).show()
} else {
onTakeRecorded(bytes, recorder.recordedMimeType)
}
}
val hasTake = voicePending != null || voicePersisted != null
// Persisted bytes lazy-load on demand (same pattern as the
// attachment thumbnails) so the StateFlow never holds the blob.
val lazyPersistedBytes by produceState<ByteArray?>(
initialValue = null,
key1 = voicePersisted?.id,
) {
value = if (voicePersisted != null && repository != null) {
withContext(Dispatchers.IO) { repository.getAttachmentBytes(voicePersisted.id) }
} else {
null
}
}
val takeBytes: ByteArray? = if (voicePending != null) voicePendingBytes else lazyPersistedBytes
val takeName: String =
voicePending?.displayName ?: voicePersisted?.displayName ?: "voice_note.opus"
val takeMime: String =
voicePending?.mimeType ?: voicePersisted?.mimeType ?: "audio/ogg"
val takeKey: Long = voicePending?.tempId ?: voicePersisted?.id ?: 0L
Column(
modifier = modifier
.fillMaxWidth()
.padding(bottom = 8.dp)
.border(
1.dp,
MaterialTheme.colorScheme.outlineVariant,
RoundedCornerShape(12.dp),
)
.background(
MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.45f),
RoundedCornerShape(12.dp),
)
.padding(horizontal = 12.dp, vertical = 8.dp),
) {
when {
isRecording -> Row(
modifier = Modifier.fillMaxWidth(),
verticalAlignment = Alignment.CenterVertically,
) {
Icon(
Icons.Filled.FiberManualRecord,
contentDescription = null,
tint = Color(0xFFD32F2F),
modifier = Modifier.size(16.dp),
)
Spacer(Modifier.width(8.dp))
Text(
formatVoiceTime(elapsedMs),
style = MaterialTheme.typography.titleMedium,
)
Spacer(Modifier.weight(1f))
IconButton(onClick = { stopRecording() }) {
Icon(
Icons.Filled.Stop,
contentDescription = "Stop recording",
tint = MaterialTheme.colorScheme.primary,
)
}
IconButton(onClick = {
recorder.cancel()
isRecording = false
}) {
Icon(
Icons.Filled.Close,
contentDescription = "Discard recording",
tint = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
}
hasTake && takeBytes == null -> Row(
modifier = Modifier
.fillMaxWidth()
.height(48.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(10.dp),
) {
CircularProgressIndicator(modifier = Modifier.size(18.dp), strokeWidth = 2.dp)
Text(
"Loading audio\u2026",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
hasTake && takeBytes != null -> VoicePlayerBar(
bytes = takeBytes,
mimeType = takeMime,
sourceKey = takeKey,
takeName = takeName,
onDelete = onDeleteTake,
onDownload = { saveVoiceTakeToDevice(ctx, beginExternalActivity, takeName, takeMime, takeBytes) },
onRecordAgain = { startRecording() },
)
else -> Row(
modifier = Modifier
.fillMaxWidth()
.clickable { startRecording() }
.padding(vertical = 6.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(12.dp),
) {
Box(
modifier = Modifier
.size(40.dp)
.background(
MaterialTheme.colorScheme.primary.copy(alpha = 0.12f),
CircleShape,
),
contentAlignment = Alignment.Center,
) {
Icon(
Icons.Filled.Mic,
contentDescription = null,
tint = MaterialTheme.colorScheme.primary,
modifier = Modifier.size(22.dp),
)
}
Text(
"Tap to record a voice note",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
}
}
}
/**
* Media-player bar for a recorded take: play/pause + seek + elapsed /
* total, plus download, re-record and delete actions. Backed by the
* platform [MediaPlayer] — the bytes are written to a small cache file
* (`cacheDir/voice_play/`) because MediaPlayer plays paths, not
* in-memory blobs; the file is rewritten whenever a new take arrives
* and is disposable cache data.
*/
@Composable
private fun VoicePlayerBar(
bytes: ByteArray,
mimeType: String,
sourceKey: Long,
takeName: String,
onDelete: () -> Unit,
onDownload: () -> Unit,
onRecordAgain: () -> Unit,
) {
val ctx = LocalContext.current
// Materialise the take into a playable cache file.
val playPath by produceState<String?>(
initialValue = null,
key1 = sourceKey,
key2 = bytes,
) {
value = withContext(Dispatchers.IO) {
runCatching {
val dir = File(ctx.cacheDir, "voice_play").apply { mkdirs() }
val ext = if (mimeType == "audio/ogg") "opus" else "m4a"
val file = File(dir, "take_$sourceKey.$ext")
file.writeBytes(bytes)
file.absolutePath
}.getOrNull()
}
}
var player by remember(sourceKey) { mutableStateOf<MediaPlayer?>(null) }
var prepared by remember(sourceKey) { mutableStateOf(false) }
var isPlaying by remember(sourceKey) { mutableStateOf(false) }
var positionMs by remember(sourceKey) { mutableStateOf(0L) }
var durationMs by remember(sourceKey) { mutableStateOf(0L) }
var dragMs by remember(sourceKey) { mutableStateOf<Float?>(null) }
DisposableEffect(playPath) {
val path = playPath
if (path == null) {
onDispose { }
} else {
val mp = MediaPlayer()
player = mp
mp.setOnPreparedListener {
durationMs = it.duration.toLong()
prepared = true
}
mp.setOnCompletionListener {
isPlaying = false
positionMs = durationMs
}
mp.setOnErrorListener { _, _, _ -> true }
runCatching {
mp.setDataSource(path)
mp.prepareAsync()
}
onDispose {
runCatching { mp.release() }
player = null
}
}
}
// Keep the slider in step while playing.
LaunchedEffect(isPlaying, prepared) {
if (!isPlaying || !prepared) return@LaunchedEffect
while (isPlaying) {
player?.let { positionMs = it.currentPosition.toLong() }
delay(200)
}
}
Column(modifier = Modifier.fillMaxWidth()) {
Row(verticalAlignment = Alignment.CenterVertically) {
IconButton(
onClick = {
val mp = player ?: return@IconButton
if (!prepared) return@IconButton
if (mp.isPlaying) {
mp.pause()
isPlaying = false
} else {
if (positionMs >= durationMs && durationMs > 0) {
mp.seekTo(0)
positionMs = 0
}
mp.start()
isPlaying = true
}
},
enabled = prepared,
) {
Icon(
imageVector = if (isPlaying) Icons.Filled.Pause else Icons.Filled.PlayArrow,
contentDescription = if (isPlaying) "Pause" else "Play",
tint = MaterialTheme.colorScheme.primary,
)
}
Text(
text = formatVoiceTime((dragMs ?: positionMs.toFloat()).toLong()),
style = MaterialTheme.typography.labelMedium,
)
Slider(
value = (dragMs ?: positionMs.toFloat()).coerceIn(
0f,
durationMs.coerceAtLeast(1).toFloat(),
),
onValueChange = { dragMs = it },
onValueChangeFinished = {
val target = dragMs
if (target != null) {
dragMs = null
val seek = target.toInt()
player?.let { mp ->
if (prepared) {
mp.seekTo(seek)
positionMs = seek.toLong()
}
}
}
},
valueRange = 0f..durationMs.coerceAtLeast(1).toFloat(),
enabled = prepared,
modifier = Modifier
.weight(1f)
.padding(horizontal = 4.dp),
)
Text(
text = formatVoiceTime(durationMs),
style = MaterialTheme.typography.labelMedium,
)
// Download = save a copy to the system Downloads folder
// (pre-Q devices get the share sheet, which reaches the
// same destinations).
IconButton(onClick = onDownload) {
Icon(
Icons.Filled.Download,
contentDescription = "Download recording",
tint = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
IconButton(onClick = onRecordAgain) {
Icon(
Icons.Filled.Mic,
contentDescription = "Re-record (replaces current take)",
tint = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
IconButton(onClick = onDelete) {
Icon(
Icons.Filled.Delete,
contentDescription = "Delete recording",
tint = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
}
Text(
text = takeName,
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
}
}
/**
* Save the take to the system Downloads folder via MediaStore (API 29+,
* no storage permission needed). On API 26–28 — where MediaStore
* Downloads doesn't exist — fall back to the v0.3.1.3 FileProvider
* outbox + share sheet, which reaches the same destinations plus
* "Save to device" handlers.
*/
private fun saveVoiceTakeToDevice(
ctx: Context,
beginExternalActivity: (() -> Unit)?,
displayName: String,
mimeType: String,
bytes: ByteArray,
) {
val safeName = displayName
.replace(Regex("[/\\\\:*?\"<>|]"), "_")
.ifEmpty { "voice_note.opus" }
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
val saved = runCatching {
val values = ContentValues().apply {
put(MediaStore.Downloads.DISPLAY_NAME, safeName)
put(MediaStore.Downloads.MIME_TYPE, mimeType)
put(
MediaStore.Downloads.RELATIVE_PATH,
Environment.DIRECTORY_DOWNLOADS,
)
}
val uri = ctx.contentResolver.insert(
MediaStore.Downloads.EXTERNAL_CONTENT_URI,
values,
) ?: return@runCatching false
ctx.contentResolver.openOutputStream(uri)?.use { out ->
out.write(bytes)
} ?: return@runCatching false
true
}.getOrDefault(false)
if (saved) {
Toast.makeText(ctx, "Saved to Downloads", Toast.LENGTH_SHORT).show()
return
}
// MediaStore refused (provider hiccup) — fall through to the
// share sheet as the last resort.
}
runCatching {
val outbox = File(ctx.cacheDir, "open_outbox").apply { mkdirs() }
val tmp = File(outbox, "dl_${System.currentTimeMillis()}_$safeName")
tmp.writeBytes(bytes)
val uri = FileProvider.getUriForFile(ctx, "${ctx.packageName}.fileprovider", tmp)
val send = Intent(Intent.ACTION_SEND).apply {
type = mimeType
putExtra(Intent.EXTRA_STREAM, uri)
addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
}
// Auto-Lock = Immediate must not fire while the chooser is up
// (same v0.3.4.0 hotfix as the attachment viewer).
beginExternalActivity?.invoke()
ctx.startActivity(Intent.createChooser(send, "Save recording"))
}.onFailure {
Toast.makeText(ctx, "Couldn't save recording", Toast.LENGTH_SHORT).show()
}
}
/** ms → "m:ss" (or "h:mm:ss" past an hour). */
internal fun formatVoiceTime(ms: Long): String {
val totalSec = ms / 1000
val h = totalSec / 3600
val m = (totalSec % 3600) / 60
val s = totalSec % 60
return if (h > 0) {
String.format(Locale.US, "%d:%02d:%02d", h, m, s)
} else {
String.format(Locale.US, "%d:%02d", m, s)
}
}
@@ -0,0 +1,132 @@
package org.incido.compose.ui.editor
import android.content.Context
import android.media.MediaRecorder
import android.os.Build
import java.io.File
import java.io.IOException
/**
* v0.4.2.0 — thin MediaRecorder wrapper for voice notes.
*
* Records Opus audio in an Ogg container (`.opus`, mime `audio/ogg`)
* at 32 kbps, single channel, 48 kHz — tiny files, excellent speech
* quality, and produced by the platform MediaRecorder with no extra
* dependencies (the app stays dependency-light per Development Plan
* privacy/offline rules). Opus-in-Ogg output via MediaRecorder is
* public API only from API 29, so API 26–28 devices keep the previous
* AAC/MP4 path (`.m4a`, mime `audio/mp4`); [recordedMimeType] reports
* which container [start] actually used.
*
* Note: the MediaRecorder surface exposes no encoder knobs for Opus
* frame size or complexity, so both stay at platform defaults (Opus
* on Android encodes 20 ms frames); hitting 120 ms frames /
* complexity 10 would require bundling native libopus — deferred.
*
* The take lands in a temp file under `cacheDir/voice_rec/`; the
* caller reads it back as a [ByteArray] on [stopAndReadBytes] and the
* temp file is deleted immediately — the bytes then ride the ordinary
* attachment pipeline into ObjectBox (same lifecycle as the camera
* outbox from v0.3.1.0).
*
* Not thread-safe: drive it from the main thread only.
*/
class VoiceRecorder {
private var recorder: MediaRecorder? = null
private var outFile: File? = null
private var opus = false
/** True between a successful [start] and the matching stop/cancel. */
val isRecording: Boolean get() = recorder != null
/**
* Mime type of the container [start] actually used — `audio/ogg`
* (Opus) on API 29+, `audio/mp4` (AAC) on API 26–28. Valid after
* any successful [start]; callers use it to tag the finished take.
*/
val recordedMimeType: String get() = if (opus) "audio/ogg" else "audio/mp4"
/**
* Start capturing from the mic into a fresh temp file.
* Throws [IOException] / [RuntimeException] when the mic is busy,
* the permission was revoked mid-session, or the device has none —
* callers should catch and surface a snackbar.
*/
@Suppress("DEPRECATION")
fun start(context: Context) {
if (recorder != null) return
// Opus-in-Ogg via MediaRecorder is public API only from API 29
// (minSdk is 26), so older devices keep the AAC/MP4 path.
val useOpus = Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q
val dir = File(context.cacheDir, "voice_rec").apply { mkdirs() }
val file = File(
dir,
"take_${System.currentTimeMillis()}" + if (useOpus) ".opus" else ".m4a",
)
val rec = MediaRecorder()
try {
rec.apply {
setAudioSource(MediaRecorder.AudioSource.MIC)
if (useOpus) {
setOutputFormat(MediaRecorder.OutputFormat.OGG)
setAudioEncoder(MediaRecorder.AudioEncoder.OPUS)
setAudioEncodingBitRate(32_000) // 32 kbps
setAudioChannels(1) // single channel
setAudioSamplingRate(48_000) // Opus native rate
} else {
setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
setAudioEncodingBitRate(96_000)
setAudioSamplingRate(44_100)
}
setOutputFile(file.absolutePath)
prepare()
start()
}
recorder = rec
outFile = file
opus = useOpus
} catch (e: Exception) {
rec.release()
file.delete()
throw e
}
}
/**
* Stop the capture, read the recorded bytes, and delete the temp
* file. Returns `null` when nothing was recorded or the encoder
* failed. Always safe to call — a no-op while idle.
*/
fun stopAndReadBytes(): ByteArray? {
val rec = recorder ?: return null
recorder = null
val file = outFile
outFile = null
return try {
rec.stop()
val bytes = file?.readBytes()
bytes?.takeIf { it.isNotEmpty() }
} catch (e: RuntimeException) {
null
} finally {
rec.release()
file?.delete()
}
}
/**
* Abandon the in-flight take without reading it (the ✕ while
* recording). Always safe to call — a no-op while idle.
*/
fun cancel() {
val rec = recorder ?: return
recorder = null
val file = outFile
outFile = null
runCatching { rec.stop() } // stop() throws if nothing was captured
rec.release()
file?.delete()
}
}
@@ -52,6 +52,7 @@ import kotlinx.coroutines.launch
import org.incido.compose.data.backup.BackupPreview
import org.incido.compose.data.backup.EncryptedBackupCodec
import org.incido.compose.data.security.SecurityManager
import org.incido.compose.di.requireAndroidContainer
import org.incido.compose.data.settings.AutoLockTimeout
import org.incido.compose.data.settings.ThemeMode
@@ -93,7 +94,7 @@ fun SettingsScreen(
* suppression (the pre-0.3.4.0 behaviour).
*/
securityManager: SecurityManager? = null,
viewModel: SettingsViewModel = viewModel(factory = SettingsViewModel.Factory),
viewModel: SettingsViewModel = viewModel(factory = SettingsViewModel.factory(requireAndroidContainer())),
) {
val settings by viewModel.userSettings.collectAsStateWithLifecycle()
val migrationState by viewModel.migrationState.collectAsStateWithLifecycle()
@@ -410,6 +411,13 @@ fun SettingsScreen(
// the app.
pendingImportPassphrase = chars.copyOf()
if (importUri != null) {
// v0.4.2.1 hotfix: re-arm the URI slot that
// the shared preamble above just cleared.
// The preview-confirm dialog's Import button
// reads pendingImportUri; leaving it null
// made encrypted imports a silent no-op
// (dialog closed, nothing imported).
pendingImportUri = importUri
scope.launch {
// `chars` is consumed (zeroed) by the
// decrypt step; the retained copy survives.
@@ -659,55 +667,6 @@ private var pendingPassphraseMode: PassphraseDialogMode = PassphraseDialogMode.E
// ---------------------------------------------------------------------------
@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun AppearanceSection(
themeMode: ThemeMode,
dynamicColor: Boolean,
onThemeMode: (ThemeMode) -> Unit,
onDynamicColor: (Boolean) -> Unit,
) {
SettingsSection(title = "Appearance") {
Column(modifier = Modifier.padding(horizontal = 16.dp, vertical = 12.dp)) {
Text("Theme", style = MaterialTheme.typography.labelLarge)
Spacer(Modifier.padding(top = 6.dp))
SingleChoiceSegmentedButtonRow(modifier = Modifier.fillMaxWidth()) {
ThemeMode.values().forEachIndexed { index, mode ->
SegmentedButton(
selected = themeMode == mode,
onClick = { onThemeMode(mode) },
shape = SegmentedButtonDefaults.itemShape(
index = index,
count = ThemeMode.values().size,
),
label = {
Text(when (mode) {
ThemeMode.SYSTEM -> "System"
ThemeMode.LIGHT -> "Light"
ThemeMode.DARK -> "Dark"
})
},
)
}
}
Spacer(Modifier.padding(top = 12.dp))
Row(
modifier = Modifier.fillMaxWidth(),
verticalAlignment = Alignment.CenterVertically,
) {
Column(modifier = Modifier.weight(1f)) {
Text("Dynamic color", style = MaterialTheme.typography.bodyMedium)
Text(
"Use the system Material You palette on Android 12+.",
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
Switch(checked = dynamicColor, onCheckedChange = onDynamicColor)
}
}
}
}
/**
* v0.3.3.0: PIN and Biometric are mutually-exclusive toggles. When
* the master security switch is off, both are greyed. When one is
@@ -836,152 +795,6 @@ private fun SecuritySection(
}
}
@Composable
private fun BackupSection(
onExport: () -> Unit,
onImport: () -> Unit,
onImportCarnet: () -> Unit,
) {
SettingsSection(title = "Backup & Restore") {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 16.dp, vertical = 12.dp),
verticalArrangement = Arrangement.spacedBy(8.dp),
) {
Text(
"Export your notes to a JSON file (with optional passphrase " +
"encryption) or import a backup. Imports are additive — " +
"they don't replace your existing notes.",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
Button(onClick = onExport, modifier = Modifier.fillMaxWidth()) {
Text("Export to file…")
}
OutlinedButton(onClick = onImport, modifier = Modifier.fillMaxWidth()) {
Text("Import from file…")
}
OutlinedButton(onClick = onImportCarnet, modifier = Modifier.fillMaxWidth()) {
Text("Import 3rd Party Notes")
}
}
}
}
@Composable
private fun AboutSection(
version: String,
onVersionClick: () -> Unit,
) {
SettingsSection(title = "About") {
Column(modifier = Modifier.padding(horizontal = 16.dp, vertical = 12.dp)) {
Row(
modifier = Modifier
.fillMaxWidth()
.clickable(onClick = onVersionClick)
.padding(vertical = 6.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Column(modifier = Modifier.weight(1f)) {
Text("Incido", style = MaterialTheme.typography.titleMedium)
Text(
text = "Version $version",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.primary,
)
}
Text(
text = "Tap for release notes",
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
}
}
}
// ---------------------------------------------------------------------------
// Building blocks
// ---------------------------------------------------------------------------
@Composable
private fun SettingsSection(title: String, content: @Composable () -> Unit) {
Column {
Text(
text = title,
style = MaterialTheme.typography.labelLarge,
color = MaterialTheme.colorScheme.primary,
fontWeight = FontWeight.SemiBold,
modifier = Modifier.padding(start = 4.dp, top = 8.dp, bottom = 4.dp),
)
Card(modifier = Modifier.fillMaxWidth()) {
content()
}
}
}
/** v0.3.3.0: optionally renders a disabled (greyed) switch — used for
* the mutually-exclusive PIN / Biometric toggles. */
@Composable
private fun SettingsToggle(
title: String,
subtitle: String,
checked: Boolean,
onCheckedChange: (Boolean) -> Unit,
enabled: Boolean = true,
) {
val color = if (enabled) {
MaterialTheme.colorScheme.onSurface
} else {
MaterialTheme.colorScheme.onSurfaceVariant
}
val subColor = if (enabled) {
MaterialTheme.colorScheme.onSurfaceVariant
} else {
MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.5f)
}
Row(
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 4.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Column(modifier = Modifier.weight(1f)) {
Text(title, style = MaterialTheme.typography.bodyMedium, color = color)
Text(
subtitle,
style = MaterialTheme.typography.labelSmall,
color = subColor,
)
}
Switch(checked = checked, onCheckedChange = onCheckedChange, enabled = enabled)
}
}
@Composable
private fun SettingsRow(
title: String,
subtitle: String,
onClick: () -> Unit,
) {
Row(
modifier = Modifier
.fillMaxWidth()
.clickable(onClick = onClick)
.padding(vertical = 8.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Column(modifier = Modifier.weight(1f)) {
Text(title, style = MaterialTheme.typography.bodyMedium)
Text(
subtitle,
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.primary,
)
}
}
}
@Composable
private fun TimeoutDialog(
@@ -2,7 +2,6 @@ package org.incido.compose.ui.settings
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.Companion.APPLICATION_KEY
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
@@ -12,14 +11,14 @@ import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
import org.incido.compose.IncidoApplication
import org.incido.compose.di.AppContainer
import org.incido.compose.data.backup.BackupManager
import org.incido.compose.data.backup.CarnetImporter
import org.incido.compose.data.security.AesGcmFieldCipher
import org.incido.compose.data.security.EncryptionVerifier
import org.incido.compose.data.security.ObjectBoxKeyProvider
import org.incido.compose.data.security.SecurityManager
import org.incido.data.crypto.AesGcmFieldCipher
import org.incido.data.crypto.CipherHolder
import org.incido.data.crypto.EncryptionVerifier
import org.incido.data.crypto.NoteCryptoService
import org.incido.compose.data.settings.AutoLockTimeout
import org.incido.compose.data.settings.SettingsRepository
@@ -141,7 +140,8 @@ class SettingsViewModel(
if (enabled) {
// Key first (idempotent), cipher into the holder, sweep.
objectBoxKeyProvider.getOrCreateKey()
cipherHolder.cipher = AesGcmFieldCipher(objectBoxKeyProvider)
cipherHolder.cipher =
AesGcmFieldCipher(objectBoxKeyProvider::getOrCreateKey)
noteCryptoService.encryptAllInPlace { done, total ->
_migrationState.value = MigrationState.Running(
if (total == 0) 1f else done.toFloat() / total,
@@ -243,8 +243,12 @@ class SettingsViewModel(
backupManager.preview(uri, passphrase)
suspend fun import(uri: android.net.Uri, passphrase: CharArray? = null) {
val count = backupManager.import(uri, passphrase)
_snackbar.value = "Imported $count note(s)."
val result = backupManager.import(uri, passphrase)
_snackbar.value = if (result.skipped > 0) {
"Imported ${result.imported} note(s), skipped ${result.skipped} already imported."
} else {
"Imported ${result.imported} note(s)."
}
}
/**
@@ -316,7 +320,8 @@ class SettingsViewModel(
// Swap the live cipher to point at the freshly-installed key.
// We build a new wrapper that re-reads the (just-persisted)
// wrapped blob — no need to re-implement the unwrap here.
cipherHolder.cipher = AesGcmFieldCipher(objectBoxKeyProvider)
cipherHolder.cipher =
AesGcmFieldCipher(objectBoxKeyProvider::getOrCreateKey)
encryptionVerifier.checkNow()
_snackbar.value = if (overwroteExisting) {
"Recovery key installed. Previously-encrypted notes will appear as unverified."
@@ -354,12 +359,19 @@ class SettingsViewModel(
/** The version string baked into backup payloads and shown on
* the About card. Mirrors `app/build.gradle.kts` `versionName`
* — if you bump one, bump both. */
const val APP_VERSION = "0.4.0.0"
const val APP_VERSION = "0.4.2.0"
val Factory: ViewModelProvider.Factory = viewModelFactory {
/**
* M4.3c: graph-based factory — but this ViewModel genuinely needs
* the ANDROID services (SecurityManager, Keystore key provider,
* BackupManager's Uri IO, CarnetImporter), so it takes the
* concrete AppContainer, not just the AppGraph face. It stays in
* androidMain until those services gain desktop answers (or the
* UI hides them — plan §6.5).
*/
fun factory(container: AppContainer): ViewModelProvider.Factory = viewModelFactory {
initializer {
val app = this[APPLICATION_KEY] as IncidoApplication
val c = app.container
val c = container
SettingsViewModel(
settings = c.settingsRepository,
security = c.securityManager,
@@ -40,6 +40,7 @@ import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import kotlinx.coroutines.launch
import org.incido.compose.di.requireAndroidContainer
import org.incido.compose.ui.settings.SettingsViewModel
/**
@@ -57,7 +58,7 @@ import org.incido.compose.ui.settings.SettingsViewModel
* stored hash + salt. The screen pops on success and surfaces a
* "PIN updated." snackbar via the existing viewModel.snackbar flow.
*
* Reuses the existing [SettingsViewModel.Factory] — the new screen
* Reuses the existing [SettingsViewModel.factory] — the new screen
* doesn't need its own ViewModel because every operation goes through
* the existing security manager.
*/
@@ -66,7 +67,7 @@ import org.incido.compose.ui.settings.SettingsViewModel
fun PinChangeScreen(
onDone: () -> Unit,
onCancel: () -> Unit,
viewModel: SettingsViewModel = viewModel(factory = SettingsViewModel.Factory),
viewModel: SettingsViewModel = viewModel(factory = SettingsViewModel.factory(requireAndroidContainer())),
) {
val scope = rememberCoroutineScope()
var step by remember { mutableStateOf(Step.VerifyOld) }
@@ -36,6 +36,7 @@ import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import kotlinx.coroutines.launch
import org.incido.compose.di.requireAndroidContainer
import org.incido.compose.ui.settings.SettingsViewModel
/**
@@ -60,7 +61,7 @@ import org.incido.compose.ui.settings.SettingsViewModel
fun PinSetupScreen(
onDone: () -> Unit,
onCancel: () -> Unit,
viewModel: SettingsViewModel = viewModel(factory = SettingsViewModel.Factory),
viewModel: SettingsViewModel = viewModel(factory = SettingsViewModel.factory(requireAndroidContainer())),
) {
val scope = rememberCoroutineScope()
@@ -0,0 +1,18 @@
package org.incido.compose.ui.theme
import android.os.Build
import androidx.compose.material3.ColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.LocalContext
/** Android actual — the verbatim pre-M4 dynamic-colour branch: a real
* Material You scheme on API 31+ (S), null below that. */
@Composable
actual fun platformDynamicColorScheme(darkTheme: Boolean): ColorScheme? {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) return null
val context = LocalContext.current
return if (darkTheme) dynamicDarkColorScheme(context)
else dynamicLightColorScheme(context)
}
@@ -0,0 +1,13 @@
package org.incido.compose.util
import android.graphics.BitmapFactory
import androidx.compose.ui.graphics.ImageBitmap
import androidx.compose.ui.graphics.asImageBitmap
/**
* M4.4b Android actual — the verbatim pre-M4 decode
* (`BitmapFactory.decodeByteArray` returns null on undecodable bytes,
* exactly the contract [decodeImageBytes] keeps).
*/
actual fun decodeImageBytes(bytes: ByteArray): ImageBitmap? =
BitmapFactory.decodeByteArray(bytes, 0, bytes.size)?.asImageBitmap()
@@ -0,0 +1,9 @@
package org.incido.compose.util
import androidx.compose.runtime.Composable
/** M4.4c Android actual — the verbatim `activity-compose` back handler. */
@Composable
actual fun PlatformBackHandler(enabled: Boolean, onBack: () -> Unit) {
androidx.activity.compose.BackHandler(enabled = enabled, onBack = onBack)
}
@@ -0,0 +1,13 @@
package org.incido.compose.util
import android.text.format.DateUtils
/** Android actual — verbatim pre-M4 formatting: Android's own
* localised relative-time helper, unchanged. */
actual fun relativeTimestamp(epochMillis: Long, nowMillis: Long): String =
DateUtils.getRelativeTimeSpanString(
epochMillis,
nowMillis,
DateUtils.MINUTE_IN_MILLIS,
DateUtils.FORMAT_ABBREV_RELATIVE,
).toString()
@@ -1,7 +1,6 @@
package org.incido.compose.data.backup
import org.incido.compose.data.settings.PasswordPolicy
import java.security.SecureRandom
/**
* v0.3.2.0: SecureRandom-based passphrase generator for encrypted
@@ -15,6 +14,12 @@ import java.security.SecureRandom
* If a freshly-generated passphrase fails validation (rare — only if
* the random draw happens to miss both a digit and a special) we
* regenerate, so the return type is non-nullable.
*
* M4.4a: `java.security.SecureRandom` is not a commonMain declaration,
* so the draw goes through [secureRandomInt] — an internal expect/actual
* whose actuals are the same one-liner over a shared SecureRandom on
* both targets (same seam discipline as M4.3a's `blockingFirst`; both
* targets ARE JVM, this is spelling, not behaviour).
*/
object PassphraseGenerator {
@@ -33,8 +38,6 @@ object PassphraseGenerator {
PasswordPolicy.SPECIAL_CHARS
).toCharArray()
private val secureRandom = SecureRandom()
/**
* Generate a passphrase of [length] characters (clamped to the
* policy's [PasswordPolicy.MIN_LENGTH] / [PasswordPolicy.MAX_LENGTH]
@@ -50,14 +53,17 @@ object PassphraseGenerator {
// and a special in any draw of >= 12 chars. Fall back to a
// hand-crafted compliant value so we never throw from a UI
// button tap.
return "IncidoBackup!" + secureRandom.nextInt(10_000).toString().padStart(4, '0')
return "IncidoBackup!" + secureRandomInt(10_000).toString().padStart(4, '0')
}
private fun buildRandom(length: Int): String {
val out = StringBuilder(length)
repeat(length) { out.append(ALPHABET[secureRandom.nextInt(ALPHABET.size)]) }
repeat(length) { out.append(ALPHABET[secureRandomInt(ALPHABET.size)]) }
return out.toString()
}
private const val MAX_ATTEMPTS = 16
}
/** CSPRNG draw in `[0, bound)` — SecureRandom on every target. */
internal expect fun secureRandomInt(bound: Int): Int
@@ -0,0 +1,161 @@
package org.incido.compose.data.settings
/**
* One entry in the "What's New" dialog. Surfaced from the Settings
* screen when the user taps the version number.
*
* v0.3.2.0: the dialog shows the [RECENT] list (newest first) in a
* scrollable column. Each entry has a version, a release date, and a
* list of bullet points summarising what shipped in that release.
*
* Content is mirrored from `Incido Development Plan.txt` §10 so the
* in-app dialog and the repo's history of changes stay in lockstep
* (the plan file is the source of truth at release time).
*/
data class ReleaseNote(
val version: String,
val date: String,
val bullets: List<String>,
)
object ReleaseNotes {
/**
* The 5 most recent Incido releases, ordered newest → oldest.
* Append a new entry on top each release.
*/
val RECENT: List<ReleaseNote> = listOf(
ReleaseNote(
version = "0.4.2.0",
date = "2026-09-23",
bullets = listOf(
"Before you update: please make certain you have a " +
"current backup — Settings → Backup & Restore → " +
"Export (plus your encryption key under Settings → " +
"Security if encryption is on) — before installing " +
"this version. Every future release will remind " +
"you the same way.",
"Voice notes: the editor's bottom toolbar gained a mic " +
"button, right after the camera — the row is now " +
"Photo · Voice · Attach · Tasks · Shopping list, " +
"with the hashtag button moved to the far right. " +
"Tap it and the note grows a recording card " +
"at the top of its body — tap record, stop when " +
"you're done, and your take gets a media player with " +
"play / pause, a seek bar, and elapsed / total time.",
"Recordings are captured as compact Opus audio " +
"(.opus files \u2014 32 kbps, single channel): tiny " +
"files, clear speech. Phones on Android 8.x / 9 " +
"fall back to the old AAC format automatically.",
"Your recording is saved with the note like any other " +
"attachment — encrypted at rest when encryption " +
"is on, riding along in backups — and a download " +
"button copies it out to the system Downloads folder " +
"when you need the file itself.",
"Voice notes are still normal notes: title, text body, " +
"colours, tags, favourites, drafts, and search all " +
"work as before. Re-recording replaces the old take; " +
"converting back to a text note keeps the recording " +
"as an ordinary attachment.",
"Voice note cards carry a mic badge, and the microphone " +
"permission is only asked for on the first tap into " +
"voice mode — recordings never leave the device.",
),
),
ReleaseNote(
version = "0.4.1.1",
date = "2026-09-23",
bullets = listOf(
"Saved notes stay put: in v0.4.1.0 every note you " +
"saved ended up in Drafts instead of Home \u2014 " +
"the editor still believed it was a draft and " +
"quietly re-saved it as one when you left the " +
"screen. Saving now publishes properly: the note " +
"goes to Home and leaves Drafts for good.",
"Enter behaves in the price box: in a shopping list, " +
"Enter in a row's Price field used to jump the " +
"cursor back to the note title \u2014 it now works " +
"like Enter in the product field: a fresh row " +
"appears below, cursor ready in its Product box.",
),
),
ReleaseNote(
version = "0.4.1.0",
date = "2026-09-23",
bullets = listOf(
"Colour filters in the drawer: a strip of five swatches " +
"\u2014 Blue, Green, Amber, Red, Purple \u2014 sits " +
"right under Favorites. Tap one and the list shows " +
"ONLY notes of that colour; tap it again for Home.",
"Colour views follow the Favorites / Untagged rules: " +
"trashed notes never show, untagged ones do, and " +
"search narrows within the selected colour.",
"Auto-saved drafts: a new note saves itself while you " +
"type, so nothing is ever lost \u2014 an unfinished " +
"note waits in the new Drafts drawer row, and opening " +
"it again picks up exactly where you stopped.",
"An untitled draft names itself after its kind \u2014 " +
"\"Task List \u2014 (draft)\", \"Shopping List \u2014 " +
"(draft)\" \u2014 on its card and in the editor bar. " +
"Drafts survive encrypted backup and restore too.",
"Empty Trash: a one-tap button appears whenever the " +
"Trash holds notes \u2014 a confirmation dialog " +
"stands between that tap and permanently deleting " +
"every trashed note, attachments included.",
"Editor rows rebuilt: title, item and quantity fields " +
"share one even underlined height, long checklist " +
"labels wrap instead of stretching the row, and " +
"checkbox / +/- controls stay centred alongside.",
),
),
ReleaseNote(
version = "0.4.0.0",
date = "2026-09-18",
bullets = listOf(
"Import 3rd-party notes: Settings \u2192 Backup & Restore now " +
"has an \u201cImport 3rd Party Notes\u201d button that reads a " +
"Carnet / QuickNote .zip export (a single archive bundling " +
"one .sqd per note) and brings every note in \u2014 directly " +
"on-device, with no pre-conversion step.",
"Formatting is preserved as plain text: rich-text bodies are " +
"flattened, and note colours, keywords (imported as tags) " +
"and links carry over. To-do lists become native " +
"checklists you can tick off.",
"Images come across too \u2014 photo attachments inside each " +
"note are imported; auto-generated preview thumbnails are " +
"skipped, so you get one clean image per photo.",
"Import is additive: your existing notes are untouched and " +
"imported notes get fresh IDs, so you can safely pull in " +
"an archive at any time.",
),
),
ReleaseNote(
version = "0.3.8.0",
date = "2026-09-16",
bullets = listOf(
"Task lists: a checklist button next to the # button in the " +
"editor turns any note into an editable task list — add, " +
"remove, and tick off items with real checkboxes.",
"Shopping lists with a running total: each row gets a " +
"quantity dropdown (1\u20139) and a supermarket-style " +
"price field \u2014 every digit you tap on the number pad " +
"is a cent, so entering 199 means $1.99 (the price box " +
"shows your raw entry beside its $ sign; the running " +
"total speaks real dollars). Tick an " +
"item once it's in your basket and the always-visible " +
"total at the top adds quantity \u00d7 price. Product, " +
"quantity, and price are strictly separate fields, so a " +
"product called \"Battery AA 3\" can never mess up your " +
"money maths.",
"Tapping the active list button again returns the note to " +
"plain text — nothing is lost, the items just become " +
"\"- [ ]\" lines you can also edit by hand.",
"Add-tag sheet fixed: existing hashtags now appear as a " +
"selectable suggestion list again, narrowing to matches " +
"live as you type (the suggestion pipeline was frozen, so " +
"only \"+ Create\\u2026\" ever showed).",
),
),
// v0.4.2.0 push drops v0.3.7.1 off the "5 most recent" tail.
)
}
@@ -0,0 +1,52 @@
package org.incido.compose.di
import androidx.compose.runtime.Composable
import androidx.compose.runtime.compositionLocalOf
import org.incido.compose.data.settings.SettingsRepository
import org.incido.domain.repository.NoteRepository
/**
* Phase 1 (M4.3) — the platform-neutral face of the DI container.
*
* The seam that lets the ViewModels leave `IncidoApplication` /
* `AndroidViewModelFactory.APPLICATION_KEY` behind: they receive an
* [AppGraph] (via the screen's `viewModel(factory = …)` construction site)
* instead of digging the Application out of CreationExtras. Android's
* `AppContainer` and the desktop `DesktopContainer` implement the same
* face — that is the M4.3 exit proof.
*
* Scope discipline (§9, no silently widened seams): only what BOTH
* platforms can honestly serve lives here — the note store and the
* settings stream. Android-only services (Keystore key provider,
* SecurityManager lock state, BackupManager's Uri IO, CarnetImporter)
* stay on `AppContainer`; the cipher services reach the shared ViewModels
* through [EncryptionBadge] instead of the concrete `EncryptionVerifier`.
* ViewModels that genuinely need the Android extras (SettingsViewModel
* today) stay in androidMain and take the concrete `AppContainer`.
*/
interface AppGraph {
val noteRepository: NoteRepository
val settingsRepository: SettingsRepository
/**
* M4.3c: the encryption-badge feed (verified/unverified note ids from
* the trial-decrypt sweep). Both platforms genuinely run
* `EncryptionVerifier` on their own store, so this is a shared face,
* not an Android concept — see EncryptionBadge.kt for the mapping.
*/
val encryptionBadge: EncryptionBadge
}
/**
* Where the screens find the graph: provided at the root composable of
* each platform (`IncidoApp` on Android; the desktop window in M4.5), read
* at composition time to build ViewModel factories. Nullable so a screen
* rendered outside a provider (preview/test) fails at the factory call
* with a clear message instead of a CompositionLocal-absent crash.
*/
val LocalAppGraph = compositionLocalOf<AppGraph?> { null }
/** Read [LocalAppGraph] or throw with the M4.3 context — call at composition. */
@Composable
fun requireAppGraph(): AppGraph = checkNotNull(LocalAppGraph.current) {
"No AppGraph provided — wrap the screen in CompositionLocalProvider(LocalAppGraph provides …)."
}
@@ -0,0 +1,34 @@
package org.incido.compose.di
import kotlinx.coroutines.flow.Flow
/**
* Phase 1 (M4.3c) — the commonMain mirror of `EncryptionVerification`
* (`org.incido.data.crypto`, :core:data shared sources).
*
* Why a mirror instead of the real type: :core:data is an androidLibrary —
* its classes are invisible to a KMP commonMain, and it can never become
* multiplatform without colliding with invariant §2.3
* (objectbox-android and objectbox-java may never share a classpath).
* A ViewModel only ever READS the verification result, so the graph
* exposes this read-only view; both containers map the real class into it
* with a 3-field copy at the seam.
*/
data class LibraryVerification(
val verifiedNoteIds: Set<Long>,
val failedNoteIds: Set<Long>,
/** [System.currentTimeMillis] when the check ran (set by the platform). */
val checkedAt: Long,
) {
val allOk: Boolean get() = failedNoteIds.isEmpty()
}
/**
* The encryption-badge feed the note list binds to: `null` until the
* first verification sweep completes; empty sets when the library is
* unencrypted. `EncryptionVerifier`'s common face (see [LibraryVerification]
* for why the concrete class can't cross the seam).
*/
interface EncryptionBadge {
val verification: Flow<LibraryVerification?>
}
@@ -0,0 +1,12 @@
package org.incido.compose.di
import kotlinx.coroutines.CoroutineDispatcher
/**
* Phase 1 (M4.3c): `Dispatchers.IO` has no commonMain declaration
* (coroutines 1.9 keeps it JVM-only). NoteEditorViewModel swaps its four
* `withContext(Dispatchers.IO)` sites for this seam — both actuals are
* literally `Dispatchers.IO`, so the Android behaviour is unchanged
* (invariant §2.1), it is merely spelled through an expect/actual.
*/
internal expect val ioDispatcher: CoroutineDispatcher
@@ -2,14 +2,13 @@ package org.incido.compose.ui.drawer
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.Companion.APPLICATION_KEY
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.stateIn
import org.incido.compose.IncidoApplication
import org.incido.compose.di.AppGraph
import org.incido.domain.model.HashtagUsage
import org.incido.domain.repository.NoteRepository
@@ -18,6 +17,12 @@ import org.incido.domain.repository.NoteRepository
* tags" list. Kept separate from [NoteListViewModel] because the
* drawer may render even before the list screen is created (and
* vice-versa).
*
* Phase 1 (M4.3b): first ViewModel in commonMain — the §6.4 probe. It
* compiles for both targets with its `androidx.lifecycle.*` imports
* unchanged (the org.jetbrains.androidx.lifecycle offline set keeps the
* androidx FQCNs), and takes the [AppGraph] instead of digging
* `IncidoApplication` out of CreationExtras via APPLICATION_KEY.
*/
class DrawerViewModel(
repository: NoteRepository,
@@ -32,11 +37,8 @@ class DrawerViewModel(
)
companion object {
val Factory: ViewModelProvider.Factory = viewModelFactory {
initializer {
val app = this[APPLICATION_KEY] as IncidoApplication
DrawerViewModel(app.container.noteRepository)
}
fun factory(graph: AppGraph): ViewModelProvider.Factory = viewModelFactory {
initializer { DrawerViewModel(graph.noteRepository) }
}
}
}
@@ -1,8 +1,15 @@
package org.incido.compose.ui.drawer
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
@@ -11,7 +18,9 @@ import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Home
import androidx.compose.material.icons.filled.LabelOff
import androidx.compose.material.icons.filled.Check
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.Drafts
import androidx.compose.material.icons.filled.Settings
import androidx.compose.material.icons.filled.Star
import androidx.compose.material.icons.filled.Tag
@@ -25,17 +34,25 @@ import androidx.compose.material3.NavigationDrawerItemDefaults
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.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel
import org.incido.compose.di.requireAppGraph
import org.incido.compose.ui.theme.AllNoteColors
import org.incido.compose.ui.theme.toComposeColor
import org.incido.domain.model.HashtagUsage
import org.incido.domain.model.NoteColor
import org.incido.domain.model.NoteFilter
/**
* Left-side navigation drawer. Top section has five fixed entries
* (Home / Favorites / Untagged / Trash / Settings); a `HorizontalDivider`; then
* Left-side navigation drawer. Top section has the fixed entries
* (Home / Favorites / the colour-swatch strip / Drafts / Untagged /
* Trash / Settings); a `HorizontalDivider`; then
* a live scrollable list of the user's most-recently-used hashtags.
*
* Tapping a filter entry calls [onSelectFilter]; tapping Settings
@@ -44,6 +61,16 @@ import org.incido.domain.model.NoteFilter
*
* v0.3.2.0 — Settings is a new entry directly underneath "Untagged"
* with its own divider for visual separation.
*
* Colour filters sit between "Favorites" and "Drafts" as one
* horizontal strip of swatches — the colours are self-explanatory, so
* there are no labels. Selecting one shows ONLY active notes of that
* colour — trashed notes never appear, untagged ones do (see
* NoteFilter.ByColor); tapping the selected swatch again returns to
* Home.
*
* "Drafts" lists auto-saved new notes (see Note.isDraft) — a new note
* is persisted automatically while it is being written.
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
@@ -52,7 +79,7 @@ fun IncidoDrawer(
onSelectFilter: (NoteFilter) -> Unit,
onOpenSettings: () -> Unit,
modifier: Modifier = Modifier,
viewModel: DrawerViewModel = viewModel(factory = DrawerViewModel.Factory),
viewModel: DrawerViewModel = viewModel(factory = DrawerViewModel.factory(requireAppGraph())),
) {
val recent by viewModel.recentHashtags.collectAsStateWithLifecycle()
@@ -82,6 +109,64 @@ fun IncidoDrawer(
onClick = { onSelectFilter(NoteFilter.Favorites) },
icon = { Icon(Icons.Filled.Star, contentDescription = null) },
)
// Colour filters: one horizontal strip of swatches under
// Favorites (NONE is not offered; the colours are
// self-explanatory, so there are no labels). Each shows
// ONLY active notes of that colour — trashed notes never
// appear, untagged ones do. Tapping the selected swatch
// again returns to Home.
Row(
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 6.dp),
horizontalArrangement = Arrangement.spacedBy(
space = 14.dp,
alignment = Alignment.CenterHorizontally,
),
) {
AllNoteColors.filter { it != NoteColor.NONE }.forEach { color ->
val selected = currentFilter == NoteFilter.ByColor(color)
Box(
modifier = Modifier
.size(30.dp)
.clip(CircleShape)
.background(color.toComposeColor())
.then(
if (selected) {
Modifier.border(
width = 3.dp,
color = MaterialTheme.colorScheme.onSurface,
shape = CircleShape,
)
} else {
Modifier
},
)
.clickable {
onSelectFilter(
if (selected) NoteFilter.Home
else NoteFilter.ByColor(color),
)
},
contentAlignment = Alignment.Center,
) {
if (selected) {
Icon(
Icons.Filled.Check,
contentDescription = "${color.label} filter selected",
modifier = Modifier.size(16.dp),
tint = Color.White,
)
}
}
}
}
NavigationDrawerItem(
label = { Text("Drafts") },
selected = currentFilter == NoteFilter.Drafts,
onClick = { onSelectFilter(NoteFilter.Drafts) },
icon = { Icon(Icons.Filled.Drafts, contentDescription = null) },
)
NavigationDrawerItem(
label = { Text("Untagged") },
selected = currentFilter == NoteFilter.Untagged,
@@ -0,0 +1,90 @@
package org.incido.compose.ui.editor
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import org.incido.domain.model.NoteAttachment
import org.incido.domain.repository.NoteRepository
/**
* Phase 1 (M4.4c) — the §6.3 file-intake seam for the editor.
*
* Everything the editor reaches outside Compose — camera capture, file
* picker, mic-permission dance, "open this attachment in another app"
* — lives behind this interface, provided per platform by
* [rememberEditorIntake]. Android's actual keeps the pre-M4 code
* (Activity result launchers, FileProvider, Toasts) verbatim; the JVM
* actual answers with AWT dialogs (file picker = `FileDialog`, the same
* mechanism M2's desktop Import/Export menu uses) and reports
* `supportsCamera = supportsVoice = false` so the editor HIDES those
* affordances rather than stubbing them (§6.5).
*
* `beginExternalActivity` is the neutral replacement for the editor's
* old `SecurityManager?` parameter: Android passes
* `{ securityManager?.beginExternalActivity() }` (auto-lock suppression
* around every round-trip that backgrounds the app), desktop passes
* null — there is no auto-lock on desktop (M3 decision).
*/
interface EditorIntake {
/** Camera capture available (Android yes, desktop no — §6.5). */
val supportsCamera: Boolean
/** Voice-note recording available (Android yes, desktop no — §6.5). */
val supportsVoice: Boolean
/** Permission-checked camera round-trip ending in `onPickedBytes`. */
fun takePhoto()
/** File picker ending in `onPickedBytes`. */
fun pickFiles()
/** Voice-mode toggle including the first-tap mic-permission ask. */
fun toggleVoiceMode()
/** Live-checked (never cached) RECORD_AUDIO state. */
fun checkMicPermission(): Boolean
/** Ask for RECORD_AUDIO; grants feed back into [toggleVoiceMode]. */
fun requestMicPermission()
/** Hand bytes to the platform's "open with" mechanism. */
fun openExternal(bytes: ByteArray, mimeType: String, displayName: String)
/**
* One-shot user nudge (the thumbnail "Loading…" hint that used to be
* a Toast on the tap path). Android actual = Toast (verbatim
* behaviour); JVM actual = no-op — a desktop window has no Toast
* surface and the hint concerns a transient lazy-load state.
*/
fun notify(msg: String)
}
/** Construction-time provider for [EditorIntake] (launchers are composables). */
@Composable
expect fun rememberEditorIntake(
onPickedBytes: suspend (bytes: ByteArray, mimeType: String, displayName: String) -> Unit,
onVoiceConvert: () -> Unit,
/** Whether the note is currently in voice mode — the mic toggle
* converts BACK without a permission ask (verbatim pre-M4 rule). */
isVoiceMode: Boolean,
beginExternalActivity: (() -> Unit)?,
): EditorIntake
/**
* The editor's voice-recorder card. Android actual renders
* `VoiceNoteSection` (MediaStore recorder, MediaPlayer); the JVM actual
* renders NOTHING (§6.5 — hidden, not stubbed: voice notes imported
* from a phone keep their audio attachment, there is just no desktop
* recorder UI).
*/
@Composable
expect fun VoiceNoteSlot(
voicePending: PendingAttachment?,
voicePendingBytes: ByteArray?,
voicePersisted: NoteAttachment?,
repository: NoteRepository?,
hasMicPermission: () -> Boolean,
onRequestPermission: () -> Unit,
onTakeRecorded: (ByteArray, String) -> Unit,
onDeleteTake: () -> Unit,
beginExternalActivity: (() -> Unit)?,
modifier: Modifier = Modifier,
)
@@ -26,7 +26,7 @@ import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.graphics.ImageBitmap
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.layout.ContentScale
@@ -34,9 +34,9 @@ import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Dialog
import androidx.compose.ui.window.DialogProperties
import android.graphics.BitmapFactory
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.incido.compose.di.ioDispatcher
import org.incido.compose.util.decodeImageBytes
import org.incido.domain.repository.NoteRepository
/**
@@ -91,10 +91,10 @@ fun ImageViewerScreen(
// Decode the image (or display an error message when the
// bytes can't be loaded / decoded).
var loadFailed by remember { mutableStateOf(false) }
val bitmap by produceState<android.graphics.Bitmap?>(initialValue = null, key1 = attachmentId) {
val bitmap by produceState<ImageBitmap?>(initialValue = null, key1 = attachmentId) {
loadFailed = false
val bytes: ByteArray? = when (attachmentId) {
is ViewerAttachmentId.Persisted -> withContext(Dispatchers.IO) {
is ViewerAttachmentId.Persisted -> withContext(ioDispatcher) {
repository.getAttachmentBytes(attachmentId.id)
}
is ViewerAttachmentId.Pending -> pendingBytes
@@ -103,8 +103,8 @@ fun ImageViewerScreen(
loadFailed = true
return@produceState
}
val decoded = withContext(Dispatchers.IO) {
BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
val decoded = withContext(ioDispatcher) {
decodeImageBytes(bytes)
}
value = decoded
if (decoded == null) loadFailed = true
@@ -112,7 +112,7 @@ fun ImageViewerScreen(
if (bitmap != null) {
Image(
bitmap = bitmap!!.asImageBitmap(),
bitmap = bitmap!!,
contentDescription = null,
contentScale = ContentScale.Fit,
modifier = Modifier
@@ -1,13 +1,5 @@
package org.incido.compose.ui.editor
import android.Manifest
import android.content.Context
import android.content.Intent
import android.graphics.BitmapFactory
import android.net.Uri
import android.widget.Toast
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.border
@@ -24,7 +16,6 @@ import androidx.compose.foundation.layout.WindowInsets
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.heightIn
import androidx.compose.foundation.layout.ime
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
@@ -37,6 +28,8 @@ import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.BasicTextField
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack
@@ -49,6 +42,7 @@ import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.Description
import androidx.compose.material.icons.filled.Done
import androidx.compose.material.icons.filled.MoreVert
import androidx.compose.material.icons.filled.Mic
import androidx.compose.material.icons.filled.ShoppingBasket
import androidx.compose.material.icons.filled.Star
import androidx.compose.material.icons.filled.Tag
@@ -71,12 +65,11 @@ import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.SuggestionChip
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.material3.TextFieldDefaults
import androidx.compose.material3.TextButton
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.rememberModalBottomSheetState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
@@ -88,14 +81,16 @@ import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.draw.drawBehind
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.focus.onFocusEvent
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.graphics.painter.BitmapPainter
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.input.KeyboardCapitalization
import androidx.compose.ui.text.input.KeyboardType
@@ -103,13 +98,14 @@ import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.core.content.FileProvider
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.incido.compose.data.security.SecurityManager
import org.incido.compose.di.ioDispatcher
import org.incido.compose.di.requireAppGraph
import org.incido.compose.util.PlatformBackHandler
import org.incido.compose.util.decodeImageBytes
import org.incido.compose.ui.theme.AllNoteColors
import org.incido.compose.ui.theme.swatchBorderColor
import org.incido.compose.ui.theme.toComposeColor
@@ -118,7 +114,6 @@ import org.incido.domain.model.Hashtag
import org.incido.domain.model.Note
import org.incido.domain.model.NoteColor
import org.incido.domain.model.NoteType
import java.io.File
@OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
@Composable
@@ -139,10 +134,16 @@ fun NoteEditorScreen(
* inside an external activity we launched (file picker, camera,
* system attachment viewer). Null disables the suppression (the
* pre-0.3.4.0 behaviour).
*
* M4.4c: was `securityManager: SecurityManager?` — the Android type
* cannot be named in commonMain and the editor only ever used
* beginExternalActivity(), so the parameter became this neutral
* lambda; App.kt passes `{ securityManager?.beginExternalActivity() }`.
*/
securityManager: SecurityManager? = null,
beginExternalActivity: (() -> Unit)? = null,
viewModel: NoteEditorViewModel = viewModel(
factory = NoteEditorViewModel.factory(
graph = requireAppGraph(),
noteId = noteId,
initialSharedText = initialSharedText,
initialSharedImages = initialSharedImages,
@@ -157,90 +158,19 @@ fun NoteEditorScreen(
var showDiscardDialog by rememberSaveable { mutableStateOf(false) }
val snackbarHost = remember { SnackbarHostState() }
val scope = rememberCoroutineScope()
val ctx = LocalContext.current
// v0.3.1.0: camera permission + capture. The camera launcher is
// declared FIRST so the permission callback (below) can forward to it
// without a Kotlin forward-reference error.
var pendingCameraUri by remember { mutableStateOf<Uri?>(null) }
val cameraLauncher = rememberLauncherForActivityResult(
ActivityResultContracts.TakePicture()
) { success ->
val uri = pendingCameraUri
if (success && uri != null) {
scope.launch {
val bytes = withContext(Dispatchers.IO) {
ctx.contentResolver.openInputStream(uri)?.use { it.readBytes() }
}
// Always delete the temp file — its bytes are now in the DB.
runCatching { uri.path?.let { File(it).delete() } }
pendingCameraUri = null
if (bytes != null) {
viewModel.importAttachmentBytes(
bytes = bytes,
mimeType = "image/jpeg",
displayName = "IMG_${System.currentTimeMillis()}.jpg",
)
} else {
Toast.makeText(ctx, "Couldn't read captured photo", Toast.LENGTH_SHORT).show()
}
}
} else {
pendingCameraUri = null
}
}
// Now declared AFTER cameraLauncher so it can forward to it.
val cameraPermissionLauncher = rememberLauncherForActivityResult(
ActivityResultContracts.RequestPermission()
) { granted ->
if (granted) {
pendingCameraUri?.let { uri ->
// v0.3.4.0 hotfix: the camera app takes us fully out of
// the process — with Auto-Lock = Immediate the return
// trip used to land on the lock screen (losing the
// unsaved note). Flag the round-trip so the re-lock is
// suppressed.
securityManager?.beginExternalActivity()
cameraLauncher.launch(uri)
}
} else {
Toast.makeText(ctx, "Camera permission denied", Toast.LENGTH_SHORT).show()
}
}
val filePickerLauncher = rememberLauncherForActivityResult(
ActivityResultContracts.OpenDocument()
) { uri ->
if (uri == null) return@rememberLauncherForActivityResult
scope.launch {
val ctxForResolver = ctx
val (bytes, displayName, mime) = withContext(Dispatchers.IO) {
val resolver = ctxForResolver.contentResolver
val name = queryDisplayName(resolver, uri) ?: "Attachment_${System.currentTimeMillis()}"
val mimeType = resolver.getType(uri) ?: "application/octet-stream"
val data = resolver.openInputStream(uri)?.use { it.readBytes() }
Triple(data, name, mimeType)
}
if (bytes != null) {
viewModel.importAttachmentBytes(
bytes = bytes,
mimeType = mime,
displayName = displayName,
)
} else {
Toast.makeText(ctx, "Couldn't read attachment", Toast.LENGTH_SHORT).show()
}
}
}
fun launchCamera() {
val (uri, _) = createTempCameraUri(ctx)
if (uri == null) {
Toast.makeText(ctx, "Couldn't prepare camera outbox", Toast.LENGTH_SHORT).show()
return
}
pendingCameraUri = uri
cameraPermissionLauncher.launch(Manifest.permission.CAMERA)
}
// M4.4c: camera capture, file picking, the mic-permission dance and
// open-this-attachment-elsewhere now live behind the intake seam —
// the Android actual is the verbatim launcher code that used to sit
// here, the JVM actual answers with AWT dialogs and hides
// camera/voice (S6.5). See EditorIntake.kt.
val intake = rememberEditorIntake(
onPickedBytes = { bytes, mimeType, displayName ->
viewModel.importAttachmentBytes(bytes, mimeType, displayName)
},
onVoiceConvert = { viewModel.convertTo(NoteType.VOICE_NOTE) },
isVoiceMode = state.type == NoteType.VOICE_NOTE,
beginExternalActivity = beginExternalActivity,
)
LaunchedEffect(state.isLoading) {
if (!state.isLoading && state.existing != null) {
@@ -271,11 +201,25 @@ fun NoteEditorScreen(
}
fun tryClose() {
// Drafts (new notes and draft editing) autosave every edit, so
// leaving is always lossless: flush any in-flight change and pop
// — no "Discard changes?" prompt.
if (viewModel.isDraftFlow) {
viewModel.flushDraft()
onClose()
return
}
if (isDirty()) showDiscardDialog = true else onClose()
}
BackHandler(enabled = true) { tryClose() }
// Any other exit path (rotation, nav teardown) also flushes pending
// draft edits immediately.
DisposableEffect(viewModel) {
onDispose { viewModel.flushDraft() }
}
if (showDiscardDialog) {
AlertDialog(
onDismissRequest = { showDiscardDialog = false },
@@ -308,7 +252,11 @@ fun NoteEditorScreen(
TopAppBar(
title = {
Text(
text = if (state.isEditing) "Edit note" else "New note",
text = when {
state.isDraft -> draftBarTitle(state)
state.isEditing -> "Edit note"
else -> "New note"
},
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
@@ -392,7 +340,33 @@ fun NoteEditorScreen(
// field whenever the note is a task / shopping list; the
// rows live in NoteEditorUiState.items and the view-model
// keeps `content` synchronised with their serialisation.
if (state.type == NoteType.TEXT) {
// v0.4.2.0 — voice recorder / media-player card pinned at
// the very top of the note body, directly above the text
// field (which keeps working exactly like the plain-text
// editor: title = first line).
if (state.type == NoteType.VOICE_NOTE) {
val voicePending = state.pendingAttachments
.lastOrNull { it.mimeType.startsWith("audio/") }
val voicePersisted = state.attachments.lastOrNull { it.isAudio }
VoiceNoteSlot(
voicePending = voicePending,
voicePendingBytes = voicePending?.let {
state.pendingAttachmentBytes[it.tempId]
},
voicePersisted = voicePersisted,
repository = repository,
hasMicPermission = { intake.checkMicPermission() },
onRequestPermission = { intake.requestMicPermission() },
onTakeRecorded = viewModel::setVoiceRecording,
onDeleteTake = {
voicePending?.let { viewModel.removePendingAttachment(it.tempId) }
?: voicePersisted?.let { viewModel.deletePersistedAttachment(it.id) }
},
beginExternalActivity = beginExternalActivity,
modifier = Modifier.padding(horizontal = 16.dp),
)
}
if (state.type == NoteType.TEXT || state.type == NoteType.VOICE_NOTE) {
OutlinedTextField(
value = state.content,
onValueChange = viewModel::onContentChange,
@@ -428,6 +402,7 @@ fun NoteEditorScreen(
onItemCostChange = viewModel::setItemCost,
onRemoveItem = viewModel::removeListItem,
onAddItem = viewModel::addListItem,
onAddItemAfter = viewModel::addListItemAfter,
)
}
@@ -451,7 +426,7 @@ fun NoteEditorScreen(
// v0.3.4.0 hotfix: needed by the non-image tap
// handler so the system-viewer round-trip doesn't
// trigger an immediate re-lock.
securityManager = securityManager,
intake = intake,
)
}
@@ -465,7 +440,9 @@ fun NoteEditorScreen(
// into this bottom action row so the top bar always fits
// (the six-action cluster used to crowd the title on narrow
// screens). Keep-style placement, above the nav bar /
// keyboard.
// keyboard. Order: Photo · Voice · Attach · Tasks · Shopping
// list, then the hashtag button sits flush right — a
// weighted spacer separates it from the action cluster.
HorizontalDivider()
Row(
modifier = Modifier
@@ -473,19 +450,36 @@ fun NoteEditorScreen(
.padding(horizontal = 8.dp, vertical = 4.dp),
verticalAlignment = Alignment.CenterVertically,
) {
IconButton(onClick = { launchCamera() }) {
Icon(
Icons.Filled.CameraAlt,
contentDescription = "Take photo",
tint = MaterialTheme.colorScheme.onSurfaceVariant,
)
// M4.4c §6.5: camera + voice affordances are HIDDEN where
// the platform has no capture stack (desktop), not stubbed.
if (intake.supportsCamera) {
IconButton(onClick = { intake.takePhoto() }) {
Icon(
Icons.Filled.CameraAlt,
contentDescription = "Take photo",
tint = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
}
// v0.4.2.0 — voice-note toggle, first after Photo:
// converts the note to / from voice mode (mic permission
// is requested on the first tap into the mode).
if (intake.supportsVoice) {
IconButton(onClick = { intake.toggleVoiceMode() }) {
Icon(
Icons.Filled.Mic,
contentDescription = "Voice note",
tint = if (state.type == NoteType.VOICE_NOTE)
MaterialTheme.colorScheme.primary
else MaterialTheme.colorScheme.onSurfaceVariant,
)
}
}
IconButton(onClick = {
// v0.3.4.0 hotfix: the SAF picker backgrounds
// the app; with Auto-Lock = Immediate the return
// used to lock the app and wipe the unsaved note.
securityManager?.beginExternalActivity()
filePickerLauncher.launch(arrayOf("*/*"))
// v0.3.4.0 hotfix kept: the picker round-trip's
// auto-lock suppression now happens inside
// intake.pickFiles() (Android actual).
intake.pickFiles()
}) {
Icon(
Icons.Filled.AttachFile,
@@ -493,21 +487,9 @@ fun NoteEditorScreen(
tint = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
IconButton(
onClick = { viewModel.openAddTagSheet() },
enabled = state.canAddMoreTags,
) {
Icon(
Icons.Filled.Tag,
contentDescription = "Add tag",
tint = if (state.canAddMoreTags)
MaterialTheme.colorScheme.onSurfaceVariant
else MaterialTheme.colorScheme.outlineVariant,
)
}
// v0.3.8.0 — task-list toggle next to the # button.
// Converts the body into editable checklist rows (and
// back); the active mode tints with the primary colour.
// v0.3.8.0 — task-list toggle: converts the body into
// editable checklist rows (and back); the active mode
// tints with the primary colour.
IconButton(onClick = { viewModel.convertTo(NoteType.TASK_LIST) }) {
Icon(
Icons.Filled.Checklist,
@@ -529,6 +511,21 @@ fun NoteEditorScreen(
else MaterialTheme.colorScheme.onSurfaceVariant,
)
}
// Push the hashtag button to the far right, visually
// separated from the action cluster above.
Spacer(Modifier.weight(1f))
IconButton(
onClick = { viewModel.openAddTagSheet() },
enabled = state.canAddMoreTags,
) {
Icon(
Icons.Filled.Tag,
contentDescription = "Add tag",
tint = if (state.canAddMoreTags)
MaterialTheme.colorScheme.onSurfaceVariant
else MaterialTheme.colorScheme.outlineVariant,
)
}
}
}
}
@@ -594,9 +591,9 @@ private fun AttachmentStrip(
pendingOpen: (Long) -> Unit,
pendingDelete: (Long) -> Unit,
repository: org.incido.domain.repository.NoteRepository?,
/** v0.3.4.0 hotfix: forwarded to [AttachmentThumbnail] for the
* system-viewer auto-lock suppression. */
securityManager: SecurityManager?,
/** M4.4c: forwarded to [AttachmentThumbnail] — replaces the old
* SecurityManager parameter (open-external + auto-lock suppression). */
intake: EditorIntake,
) {
LazyRow(
modifier = Modifier
@@ -615,7 +612,7 @@ private fun AttachmentStrip(
// non-image taps launch a system viewer internally.
onOpenImage = { persistedOpen(persistedViewerIds[att.id] ?: ViewerAttachmentId.Persisted(att.id)) },
onRemove = { persistedDelete(att.id) },
securityManager = securityManager,
intake = intake,
)
}
items(pending, key = { it.tempId }) { p ->
@@ -627,7 +624,7 @@ private fun AttachmentStrip(
repository = repository,
onOpenImage = { pendingOpen(p.tempId) },
onRemove = { pendingDelete(p.tempId) },
securityManager = securityManager,
intake = intake,
)
}
}
@@ -649,12 +646,11 @@ private fun AttachmentThumbnail(
* into the bitmap decode path that would silently fail. */
onOpenImage: () -> Unit,
onRemove: () -> Unit,
/** v0.3.4.0 hotfix: suppress auto-lock around the external
* "open in system viewer" intent. */
securityManager: SecurityManager?,
/** M4.4c: platform intake — replaces the old SecurityManager
* parameter (open-external + auto-lock suppression + nudges). */
intake: EditorIntake,
) {
val isImage = mimeType.startsWith("image/")
val ctx = LocalContext.current
// v0.3.1.1: lazy-load bytes from DB for persisted image attachments
// so the editor strip shows a thumbnail even after the note is
@@ -668,7 +664,7 @@ private fun AttachmentThumbnail(
// handler to bail with a misleading "Loading…" Toast forever.
val lazyBytes by produceState<ByteArray?>(initialValue = null, key1 = attachmentId) {
if (pendingBytes == null && attachmentId != null && repository != null) {
value = withContext(Dispatchers.IO) {
value = withContext(ioDispatcher) {
repository.getAttachmentBytes(attachmentId)
}
}
@@ -682,11 +678,11 @@ private fun AttachmentThumbnail(
.border(1.dp, MaterialTheme.colorScheme.outlineVariant, RoundedCornerShape(8.dp))
// v0.3.1.2: branch on isImage — image taps open the
// in-app viewer; non-image taps (PDF / MP3 / video / etc.)
// write the bytes to a cache temp file and launch the
// system viewer via FileProvider + ACTION_VIEW. The
// hand the bytes to the platform's open-with mechanism
// (M4.4c: EditorIntake.openExternal — FileProvider +
// ACTION_VIEW on Android, Desktop.open on JVM). The
// previous unconditional viewer path silently failed for
// non-image mime types (BitmapFactory.decodeByteArray
// returns null and the viewer just shows "Loading…").
// non-image mime types.
.clickable {
if (isImage) {
onOpenImage()
@@ -696,57 +692,9 @@ private fun AttachmentThumbnail(
// Lazy load still in flight for a persisted
// attachment — nudge the user instead of
// silently doing nothing.
Toast.makeText(ctx, "Loading\u2026", Toast.LENGTH_SHORT).show()
return@clickable
}
runCatching {
// Sanitise displayName for use as a filename —
// strip any path separators / chars the OS
// doesn't allow in filenames.
val safeName = displayName.replace(Regex("[/\\\\:*?\"<>|]"), "_")
// v0.3.1.3: write into a dedicated `open_outbox/`
// subdir under cacheDir so it falls inside the
// FileProvider's exposed path set (see
// app/src/main/res/xml/file_paths.xml). Previously
// this wrote straight to cacheDir which is NOT
// exposed, so FileProvider.getUriForFile threw
// IllegalArgumentException and the runCatching
// swallowed it as the misleading "No app can
// open …" toast.
val outbox = File(ctx.cacheDir, "open_outbox").apply { mkdirs() }
val tmp = File(
outbox,
"open_${System.currentTimeMillis()}_$safeName",
).apply { createNewFile() }
tmp.writeBytes(bytes)
val uri = FileProvider.getUriForFile(
ctx,
"${ctx.packageName}.fileprovider",
tmp,
)
val intent = Intent(Intent.ACTION_VIEW).apply {
setDataAndType(uri, mimeType)
addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
}
// v0.3.4.0 hotfix: opening an attachment in the
// system viewer also leaves the app — suppress
// the auto-lock on return.
securityManager?.beginExternalActivity()
ctx.startActivity(intent)
}.onFailure { err ->
// v0.3.1.3: distinguish "no handler" from "couldn't
// open". ActivityNotFoundException means the OS has
// no app registered for this mime type (e.g. no
// PDF viewer installed); anything else (typically
// IllegalArgumentException from FileProvider when
// file_paths.xml is misconfigured, or IOException
// from the cache write) gets a generic message.
val msg = if (err is android.content.ActivityNotFoundException) {
"No app can open $displayName"
} else {
"Couldn't open $displayName"
}
Toast.makeText(ctx, msg, Toast.LENGTH_SHORT).show()
intake.notify("Loading…")
} else {
intake.openExternal(bytes, mimeType, displayName)
}
}
}
@@ -755,11 +703,11 @@ private fun AttachmentThumbnail(
// Image preview OR file-type fallback.
if (isImage && effectiveBytes != null) {
val bitmap = remember(effectiveBytes.contentHashCode()) {
BitmapFactory.decodeByteArray(effectiveBytes, 0, effectiveBytes.size)
decodeImageBytes(effectiveBytes)
}
if (bitmap != null) {
Image(
bitmap = bitmap.asImageBitmap(),
bitmap = bitmap!!,
contentDescription = displayName,
contentScale = ContentScale.Crop,
modifier = Modifier.fillMaxSize(),
@@ -996,7 +944,12 @@ private fun ChecklistEditorBody(
onItemCostChange: (Int, String) -> Unit,
onRemoveItem: (Int) -> Unit,
onAddItem: () -> Unit,
onAddItemAfter: (Int) -> Unit,
) {
// Enter/Return in a task/product row inserts the next row and moves
// the cursor into it. The nonce re-fires the new row's focus effect
// even when the same index is targeted repeatedly.
var focusTarget by remember { mutableStateOf(-1 to 0L) }
LazyColumn(modifier = modifier.fillMaxWidth()) {
item {
// Title / preamble. Kept as plain lines above the checkbox
@@ -1015,10 +968,19 @@ private fun ChecklistEditorBody(
.padding(horizontal = 16.dp, vertical = 4.dp),
)
}
if (isShopping) {
item { ShoppingColumnHeader() }
}
itemsIndexed(items) { index, item ->
ChecklistItemRow(
item = item,
isShopping = isShopping,
focusOnCompose = focusTarget.first == index,
focusNonce = focusTarget.second,
onAddAfter = {
onAddItemAfter(index)
focusTarget = (index + 1) to focusTarget.second + 1
},
onToggle = { checked -> onToggleItem(index, checked) },
onTextChange = { text -> onItemTextChange(index, text) },
onQuantityChange = { qty -> onItemQuantityChange(index, qty) },
@@ -1040,21 +1002,80 @@ private fun ChecklistEditorBody(
}
}
/** One row: `[ ]` · Product · Qty picker · per-item price · remove. */
/**
* Small "Product / Amnt. / Price" label line above the shopping rows.
* Mirrors [ChecklistItemRow]'s column geometry (checkbox spacer +
* weighted product + fixed qty/price widths) so the labels sit over
* their columns and the fields themselves stay uncluttered.
*/
@Composable
private fun ShoppingColumnHeader() {
val labelStyle = MaterialTheme.typography.labelSmall
val labelColor = MaterialTheme.colorScheme.onSurfaceVariant
Row(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 8.dp),
) {
Spacer(Modifier.size(48.dp)) // checkbox column
Text(
"Product",
style = labelStyle,
color = labelColor,
modifier = Modifier
.weight(1f)
.padding(start = 16.dp, top = 16.dp),
)
Spacer(Modifier.size(6.dp))
Text(
"Amnt.",
style = labelStyle,
color = labelColor,
modifier = Modifier
.width(44.dp)
.padding(start = 4.dp, top = 16.dp),
)
Spacer(Modifier.size(6.dp))
Text(
"Price",
style = labelStyle,
color = labelColor,
modifier = Modifier
.width(56.dp)
.padding(start = 4.dp, top = 16.dp),
)
Spacer(Modifier.size(48.dp)) // remove-button column
}
}
/** One row: `[ ]` · Product (grows multi-line) · Qty · price · remove. */
@Composable
private fun ChecklistItemRow(
item: ChecklistItem,
isShopping: Boolean,
focusOnCompose: Boolean,
focusNonce: Long,
onAddAfter: () -> Unit,
onToggle: (Boolean) -> Unit,
onTextChange: (String) -> Unit,
onQuantityChange: (String) -> Unit,
onCostChange: (String) -> Unit,
onRemove: () -> Unit,
) {
// Enter on the row above lands the cursor here (see [focusOnCompose]
// in ChecklistEditorBody — the target is always a freshly inserted
// row, so focusing on first composition is enough).
val textFocus = remember { FocusRequester() }
LaunchedEffect(focusNonce) {
if (focusOnCompose) textFocus.requestFocus()
}
Row(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 8.dp),
// Controls hug the field's vertical centre, so the checkbox,
// quantity / price columns and the remove ✕ travel with the
// row as a long entry wraps onto extra lines.
verticalAlignment = Alignment.CenterVertically,
) {
Checkbox(checked = item.checked, onCheckedChange = onToggle)
@@ -1065,24 +1086,32 @@ private fun ChecklistItemRow(
EditorLineField(
value = item.text,
onValueChange = onTextChange,
placeholder = if (isShopping) "Product" else "Task",
// Shopping rows are labelled by the ShoppingColumnHeader
// above, so the fields stay empty-clean; plain task rows keep
// their single "Task" hint.
placeholder = if (isShopping) "" else "Task",
keyboardOptions = KeyboardOptions(
capitalization = KeyboardCapitalization.Sentences,
imeAction = ImeAction.Next,
),
// Enter/Return (IME "Next") creates the following row and
// moves the cursor there instead of tabbing sideways.
keyboardActions = KeyboardActions(onNext = { onAddAfter() }),
// Long text wraps onto more lines (field grows downward)
// instead of scrolling sideways out of view.
singleLine = false,
maxLines = 6,
fieldModifier = Modifier.focusRequester(textFocus),
modifier = Modifier.weight(1f),
)
if (isShopping) {
Spacer(Modifier.size(6.dp))
// Free-text quantity line (replaced the 1–9 dropdown, whose
// digit never fit its box). Blank means quantity 1: while
// focused an empty line shows the "Quan." hint; on focus
// Free-text quantity line. Blank means quantity 1: on focus
// loss it settles on "1" — display-only, storage keeps the
// blank default so {q1} never enters the saved text.
EditorLineField(
value = item.quantity,
onValueChange = onQuantityChange,
placeholder = "Quan.",
keyboardOptions = KeyboardOptions(
keyboardType = KeyboardType.Number,
imeAction = ImeAction.Next,
@@ -1090,7 +1119,8 @@ private fun ChecklistItemRow(
formatUnfocused = { digits ->
if (digits.isEmpty()) "1" else digits
},
modifier = Modifier.width(72.dp),
compact = true,
modifier = Modifier.width(44.dp),
)
Spacer(Modifier.size(6.dp))
// Supermarket-style cents entry: while focused the line shows
@@ -1100,15 +1130,23 @@ private fun ChecklistItemRow(
EditorLineField(
value = item.cost,
onValueChange = onCostChange,
placeholder = "Price",
keyboardOptions = KeyboardOptions(
keyboardType = KeyboardType.Number,
imeAction = ImeAction.Next,
),
// v0.4.x FIX: Enter/Return on Price now behaves exactly
// like Enter on the product field — a fresh row appears
// below and the cursor lands directly in its Product
// field. (A bare ImeAction.Next with no handler fell
// through to system focus traversal, which — the price
// being the row's last field inside a LazyColumn —
// wrapped the cursor all the way back to the Title.)
keyboardActions = KeyboardActions(onNext = { onAddAfter() }),
formatUnfocused = { digits ->
if (digits.isEmpty()) "" else "$" + Note.amountFromPriceDigits(digits)
},
modifier = Modifier.width(110.dp),
compact = true,
modifier = Modifier.width(56.dp),
)
}
IconButton(onClick = onRemove) {
@@ -1130,6 +1168,24 @@ private fun ChecklistItemRow(
private fun editorFieldStyle(): TextStyle =
MaterialTheme.typography.bodyMedium.copy(fontSize = 13.sp, lineHeight = 18.sp)
/**
* Top-bar label while a draft session is live. A draft that already
* carries a title just says "Draft"; one with NO title names itself
* after its kind — "Task List - (draft)", "Shopping List - (draft)" —
* mirroring the Drafts card title so both surfaces agree. (TEXT drafts
* take their title from the first content line, so they always land in
* the "Draft" branch.)
*/
private fun draftBarTitle(state: NoteEditorUiState): String {
// v0.4.2.0: voice notes keep the plain content field (title = first
// line), so they read their title from `content` like TEXT does.
val titleSource =
if (state.type == NoteType.TEXT || state.type == NoteType.VOICE_NOTE) state.content
else state.listHeader
val hasTitle = titleSource.lineSequence().any { it.isNotBlank() }
return if (hasTitle) "Draft" else "${state.type.displayName} - (draft)"
}
/**
* v0.3.8.0 — one plain underlined editing line, shared by every editable
* field in the editor (title, task/product, quantity, price). Replaces
@@ -1147,7 +1203,11 @@ private fun EditorLineField(
onValueChange: (String) -> Unit,
placeholder: String = "",
keyboardOptions: KeyboardOptions = KeyboardOptions.Default,
keyboardActions: KeyboardActions = KeyboardActions.Default,
formatUnfocused: ((String) -> String)? = null,
singleLine: Boolean = true,
maxLines: Int = 1,
compact: Boolean = false,
fieldModifier: Modifier = Modifier,
modifier: Modifier = Modifier,
) {
@@ -1156,43 +1216,65 @@ private fun EditorLineField(
var focused by remember { mutableStateOf(false) }
val displayed =
if (focused || formatUnfocused == null) value else formatUnfocused(value)
Row(
modifier = modifier.heightIn(min = 44.dp),
verticalAlignment = Alignment.CenterVertically,
) {
// Material 3 filled TextField with fully transparent containers:
// what remains visible is just the text line and the 2 dp bottom
// indicator — exactly the "one line per field" look, for free.
TextField(
value = displayed,
onValueChange = onValueChange,
singleLine = true,
placeholder = {
Text(
text = placeholder,
style = fieldStyle,
color = hintColor,
maxLines = 1,
)
},
textStyle = fieldStyle.copy(
color = MaterialTheme.colorScheme.onSurface,
),
keyboardOptions = keyboardOptions,
colors = TextFieldDefaults.colors(
focusedContainerColor = Color.Transparent,
unfocusedContainerColor = Color.Transparent,
disabledContainerColor = Color.Transparent,
errorContainerColor = Color.Transparent,
focusedIndicatorColor = MaterialTheme.colorScheme.primary,
unfocusedIndicatorColor = MaterialTheme.colorScheme.outlineVariant,
cursorColor = MaterialTheme.colorScheme.primary,
),
modifier = fieldModifier
.weight(1f)
.onFocusEvent { focused = it.isFocused },
)
// v0.4.x: EVERY field — product/task text, quantity, price, header —
// is one content-hugging BasicTextField with a hand-drawn 2 dp
// bottom rule (the [compact] flag no longer changes rendering). The
// Material 3 TextField's baked-in 56 dp minimum container made even
// an empty field look double-height and pinned the row's checkbox /
// price controls to the top edge; now a single line of text is a
// single line of field, and singleLine = false fields grow
// line-by-line up to [maxLines] as the entry wraps.
val indicatorColor = if (focused) {
MaterialTheme.colorScheme.primary
} else {
MaterialTheme.colorScheme.outlineVariant
}
BasicTextField(
value = displayed,
onValueChange = onValueChange,
singleLine = singleLine,
maxLines = maxLines,
textStyle = fieldStyle.copy(color = MaterialTheme.colorScheme.onSurface),
keyboardOptions = keyboardOptions,
keyboardActions = keyboardActions,
cursorBrush = SolidColor(MaterialTheme.colorScheme.primary),
decorationBox = { innerTextField ->
// The 10 / 4 dp block gives a slim underlined line a comfy
// tap target; the rule below lands on the block's bottom
// edge, so it always sits 4 dp under the LAST text line —
// one line or six.
Box(
modifier = Modifier.padding(top = 10.dp, bottom = 4.dp),
contentAlignment = Alignment.CenterStart,
) {
if (displayed.isEmpty() && placeholder.isNotEmpty()) {
Text(
text = placeholder,
style = fieldStyle,
color = hintColor,
maxLines = 1,
)
}
innerTextField()
}
},
// NOTE: the caller's [modifier] (weight(1f) for the product
// column, fixed 44/56.dp for quantity/price) MUST stay in the
// chain — dropping it lets fillMaxWidth() win the Row and
// swallow the neighbouring columns.
modifier = fieldModifier
.then(modifier)
.fillMaxWidth()
.padding(bottom = 2.dp)
.drawBehind {
drawRect(
color = indicatorColor,
topLeft = Offset(0f, size.height - 2.dp.toPx()),
size = Size(size.width, 2.dp.toPx()),
)
}
.onFocusEvent { focused = it.isFocused },
)
}
// ---------------------------------------------------------------------
@@ -1200,49 +1282,12 @@ private fun EditorLineField(
// ---------------------------------------------------------------------
/**
* Create a temporary file in the app's cache and return a
* FileProvider-scoped Uri pointing at it. The camera app writes a JPEG
* there; we read the bytes and delete the temp file. Returns
* `(uri, file)` so the caller can clean up if reading fails.
*/
private fun createTempCameraUri(ctx: Context): Pair<Uri?, File?> {
return try {
val outbox = File(ctx.cacheDir, "camera_outbox").apply { mkdirs() }
val file = File(outbox, "cap_${System.currentTimeMillis()}.jpg")
file.createNewFile()
val authority = "${ctx.packageName}.fileprovider"
val uri = FileProvider.getUriForFile(ctx, authority, file)
uri to file
} catch (e: Exception) {
null to null
}
}
/**
* Read the Open Documents column DISPLAY_NAME for a content:// Uri,
* falling back to the last path segment. Returns null if neither
* works (which is fine — the caller uses a generated default).
*/
private fun queryDisplayName(resolver: android.content.ContentResolver, uri: Uri): String? {
return try {
resolver.query(uri, arrayOf(android.provider.OpenableColumns.DISPLAY_NAME), null, null, null)
?.use { cursor ->
if (cursor.moveToFirst()) {
val idx = cursor.getColumnIndex(android.provider.OpenableColumns.DISPLAY_NAME)
if (idx >= 0) cursor.getString(idx) else null
} else null
}
} catch (_: Exception) {
null
}
}
/**
* Lightweight [BackHandler] wrapper to avoid pulling activity-compose
* into the editor file for a single symbol. The platform back press
* closes the editor or prompts for discard confirmation.
* Lightweight [BackHandler] wrapper — M4.4c: delegates to the
* [PlatformBackHandler] seam (activity-compose on Android, no-op on
* desktop). The platform back press closes the editor or prompts for
* discard confirmation.
*/
@Composable
private fun BackHandler(enabled: Boolean, onBack: () -> Unit) {
androidx.activity.compose.BackHandler(enabled = enabled, onBack = onBack)
PlatformBackHandler(enabled = enabled, onBack = onBack)
}
@@ -2,22 +2,25 @@ package org.incido.compose.ui.editor
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.Companion.APPLICATION_KEY
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.FlowPreview
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.debounce
import kotlinx.coroutines.flow.distinctUntilChanged
import kotlinx.coroutines.flow.flatMapLatest
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.incido.compose.IncidoApplication
import org.incido.compose.di.AppGraph
import org.incido.compose.di.ioDispatcher
import org.incido.compose.share.LinkedShareComposer
import org.incido.domain.model.ChecklistItem
import org.incido.domain.model.Hashtag
@@ -89,12 +92,29 @@ data class NoteEditorUiState(
*/
val fullScreenAttachmentId: ViewerAttachmentId? = null,
) {
/** `true` while content is non-blank and not in the middle of saving. */
val canSave: Boolean get() = content.isNotBlank() && !isSaving
/** `true` when editing an existing note (existing != null). */
val isEditing: Boolean get() = existing != null
/**
* v0.4.2.0 — `true` once a voice take exists (staged pending or
* already persisted as an attachment).
*/
val hasVoiceTake: Boolean get() =
pendingAttachments.any { it.mimeType.startsWith("audio/") } ||
attachments.any { it.mimeType.startsWith("audio/") }
/**
* `true` while content is non-blank and not in the middle of
* saving. v0.4.2.0: a VOICE_NOTE may also save on the strength of
* its recording alone — the take IS the note's content.
*/
val canSave: Boolean get() =
(content.isNotBlank() || (type == NoteType.VOICE_NOTE && hasVoiceTake)) &&
!isSaving
/** `true` while this note is an auto-saved draft (see Note.isDraft). */
val isDraft: Boolean get() = existing?.isDraft == true
/** `true` when there's still room to add another tag. */
val canAddMoreTags: Boolean get() = hashtags.size < MAX_TAGS
@@ -145,7 +165,7 @@ data class PendingAttachment(
val isImage: Boolean get() = mimeType.startsWith("image/")
}
@OptIn(ExperimentalCoroutinesApi::class)
@OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class)
class NoteEditorViewModel(
private val repository: NoteRepository,
private val noteId: Long?,
@@ -209,6 +229,36 @@ class NoteEditorViewModel(
*/
private var nextPendingTempId: Long = -System.currentTimeMillis()
/**
* Draft autosave. A NEW note (or one still flagged as a draft) is
* persisted automatically: every edit lands in the DB ~400 ms after
* the last keystroke (coalesced so typing doesn't write per char),
* and [flushDraft] forces an immediate write whenever the editor
* closes or disposes. A crash can therefore only ever lose the last
* few keystrokes — never a whole draft.
*/
private val draftAutosave = noteId == null || noteId == 0L
/** True while this session autosaves: brand-new notes and draft editing. */
val isDraftFlow: Boolean
get() = draftAutosave || _state.value.isDraft
private var draftPersistInProgress = false
init {
// Signature-driven debounced autosave: whenever anything a draft
// persists changes, write the draft row shortly after.
viewModelScope.launch {
_state
.map { s ->
listOf(s.content, s.isFavorite, s.color, s.type, s.hashtags)
}
.distinctUntilChanged()
.debounce(DRAFT_AUTOSAVE_DEBOUNCE_MS)
.collect { persistDraftNow() }
}
}
init {
// Tag autocomplete — re-query on every keystroke (debounced upstream
// would be nice but ObjectBox is plenty fast for this size).
@@ -294,6 +344,10 @@ class NoteEditorViewModel(
initialHashtags = note.hashtags
initialType = note.type
}
// Draft echoes: emissions caused by our own autosave
// must not clobber in-progress edits mid-typing —
// the local state is authoritative while drafting.
if (note != null && note.isDraft && !firstLoad) return@collect
// Parse list rows once on first load; later DB
// emissions must not clobber in-progress edits.
val listSeed: Pair<String, List<ChecklistItem>>? =
@@ -409,13 +463,28 @@ class NoteEditorViewModel(
fun convertTo(target: NoteType) {
_state.update { s ->
val next = if (s.type == target) NoteType.TEXT else target
if (next == NoteType.TEXT) {
if (next == NoteType.VOICE_NOTE) {
// v0.4.2.0 — voice mode keeps the plain text field
// (title = first line) exactly like TEXT; a list body
// folds back to its plain form first. The recording is
// NOT body content — it's an ordinary audio attachment,
// so it also survives converting back to plain text.
val source =
if (s.type == NoteType.TEXT || s.type == NoteType.VOICE_NOTE) s.content
else Note.serializeListContent(s.listHeader, s.items, NoteType.TEXT)
s.copy(
type = next,
listHeader = "",
items = emptyList(),
content = source,
)
} else if (next == NoteType.TEXT) {
// Content already holds the serialised `- [ ]` rows;
// just drop out of the structured editor (the inline
// GFM checklist rendering from v0.2.0.0 still applies).
s.copy(type = NoteType.TEXT, listHeader = "", items = emptyList())
} else {
val source = if (s.type == NoteType.TEXT) {
val source = if (s.type == NoteType.TEXT || s.type == NoteType.VOICE_NOTE) {
s.content
} else {
// Serialise through the FOLDED legacy form (plain
@@ -442,6 +511,7 @@ class NoteEditorViewModel(
snackbar = when (it.type) {
NoteType.TASK_LIST -> "Task list mode — first line stays the title."
NoteType.SHOPPING_LIST -> "Shopping list mode — check an item once it's in your basket."
NoteType.VOICE_NOTE -> "Voice note mode — record with the mic card above the text."
else -> "Back to plain text."
},
)
@@ -459,6 +529,20 @@ class NoteEditorViewModel(
}
}
/**
* Insert a blank row right after [index] (or append it on the last
* row). Driven by Enter/Return in the task/product field so the
* writer flows downward into a fresh row instead of tabbing sideways.
*/
fun addListItemAfter(index: Int) {
_state.update { s ->
if (s.type == NoteType.TEXT) return@update s
if (index !in s.items.indices) return@update s
val updated = s.items.toMutableList().also { it.add(index + 1, ChecklistItem("")) }
s.withListEdits(items = updated)
}
}
fun removeListItem(index: Int) {
_state.update { s ->
if (index !in s.items.indices) return@update s
@@ -529,7 +613,7 @@ class NoteEditorViewModel(
val existingId = _state.value.existing?.id
if (existingId != null && existingId > 0L) {
// Persist straight to the DB; observeAttachments will surface it.
withContext(Dispatchers.IO) {
withContext(ioDispatcher) {
repository.addAttachment(
noteId = existingId,
bytes = bytes,
@@ -571,7 +655,47 @@ class NoteEditorViewModel(
/** Delete a persisted attachment by id (used by the ✕ on the thumbnail strip). */
fun deletePersistedAttachment(id: Long) {
viewModelScope.launch {
withContext(Dispatchers.IO) { repository.removeAttachment(id) }
withContext(ioDispatcher) { repository.removeAttachment(id) }
}
}
/**
* v0.4.2.0 — stage/persist the finished take of a voice note.
* One take per note: any previous take (pending or already
* persisted) is discarded first. The bytes then ride the ordinary
* attachment pipeline — staged as a [PendingAttachment] while the
* note is unsaved, written straight to the DB afterwards — so
* encryption, backup/restore, and the trash cascade all apply
* without any voice-specific storage.
*
* [mimeType] is the container the recorder actually produced —
* `audio/ogg` (Opus, 32 kbps mono) on API 29+, `audio/mp4` (AAC)
* on API 26–28; the display-name extension follows suit.
*/
fun setVoiceRecording(bytes: ByteArray, mimeType: String = "audio/ogg") {
if (bytes.size < 2048) {
_state.update { it.copy(snackbar = "Recording too short \u2014 try again.") }
return
}
viewModelScope.launch {
_state.value.pendingAttachments
.filter { it.mimeType.startsWith("audio/") }
.forEach { removePendingAttachment(it.tempId) }
val stalePersisted = _state.value.attachments
.filter { it.mimeType.startsWith("audio/") }
if (stalePersisted.isNotEmpty()) {
withContext(ioDispatcher) {
stalePersisted.forEach { repository.removeAttachment(it.id) }
}
}
val stamp = java.text.SimpleDateFormat("yyyyMMdd_HHmmss", java.util.Locale.US)
.format(java.util.Date())
val ext = if (mimeType == "audio/mp4") "m4a" else "opus"
importAttachmentBytes(
bytes = bytes,
mimeType = mimeType,
displayName = "Voice_$stamp.$ext",
)
}
}
@@ -587,17 +711,74 @@ class NoteEditorViewModel(
// ---- save ----
/**
* Force-write the current draft state to the DB right now — used
* when the editor closes / disposes so pending edits never sit in
* the debounce window. No-op for non-draft sessions and blank
* content (see [persistDraftNow]).
*/
fun flushDraft() {
viewModelScope.launch { persistDraftNow() }
}
/** Write the draft row if this session is in the draft lifecycle. */
private suspend fun persistDraftNow() {
val current = _state.value
if (current.isLoading || current.isSaving) return
if (draftPersistInProgress) return
val baseNote = current.existing
if (baseNote != null && !baseNote.isDraft) return // already published
if (!draftAutosave && baseNote?.isDraft != true) return
if (current.content.isBlank()) return
draftPersistInProgress = true
try {
val now = System.currentTimeMillis()
val draft = baseNote?.copy(
content = current.content,
isFavorite = current.isFavorite,
color = current.color,
type = current.type,
isDraft = true,
) ?: Note(
content = current.content,
createdAt = now,
updatedAt = now,
isFavorite = current.isFavorite,
color = current.color,
type = current.type,
isDraft = true,
)
val previous = baseNote?.hashtags.orEmpty().toSet()
val currentSet = current.hashtags.toSet()
val saved = repository.saveNoteWithHashtags(
note = draft,
hashtagsToAdd = currentSet - previous,
hashtagsToRemove = previous - currentSet,
)
// Adopt the persisted row so every later write updates the
// SAME note — one draft per editing session.
_state.update {
it.copy(existing = saved.copy(isDraft = true, hashtags = current.hashtags))
}
} finally {
draftPersistInProgress = false
}
}
fun save(onDone: () -> Unit) {
val current = _state.value
if (!current.canSave) return
_state.update { it.copy(isSaving = true) }
viewModelScope.launch {
val baseNote = current.existing
// An explicit Save PUBLISHES the note: a draft row loses
// its flag here and joins the normal views for good.
val toPersist = baseNote?.copy(
content = current.content,
isFavorite = current.isFavorite,
color = current.color,
type = current.type,
isDraft = false,
) ?: Note(
content = current.content,
createdAt = System.currentTimeMillis(),
@@ -617,7 +798,7 @@ class NoteEditorViewModel(
current.pendingAttachments.forEach { pending ->
val bytes = current.pendingAttachmentBytes[pending.tempId]
if (bytes != null) {
withContext(Dispatchers.IO) {
withContext(ioDispatcher) {
repository.addAttachment(
noteId = saved.id,
bytes = bytes,
@@ -627,7 +808,25 @@ class NoteEditorViewModel(
}
}
}
_state.update { it.copy(isSaving = false, pendingAttachments = emptyList(), pendingAttachmentBytes = emptyMap()) }
_state.update {
it.copy(
// v0.4.x FIX: adopt the PUBLISHED row into the UI
// state. Without this the state still reported
// isDraft = true, and the flushDraft() fired by the
// editor's disposal immediately re-persisted the
// note as a draft — every confirmed note landed in
// Drafts. With the published row adopted, the
// already-published guard in persistDraftNow() turns
// that flush into a no-op.
existing = saved.copy(
isDraft = false,
hashtags = current.hashtags,
),
isSaving = false,
pendingAttachments = emptyList(),
pendingAttachmentBytes = emptyMap(),
)
}
onDone()
}
}
@@ -643,7 +842,11 @@ class NoteEditorViewModel(
}
companion object {
/** Typing-pause before a draft autosave fires (ms). */
const val DRAFT_AUTOSAVE_DEBOUNCE_MS = 400L
fun factory(
graph: AppGraph,
noteId: Long?,
initialSharedText: String? = null,
initialSharedImages: List<SharedImage> = emptyList(),
@@ -655,9 +858,8 @@ class NoteEditorViewModel(
initialSharedSubject: String? = null,
): ViewModelProvider.Factory = viewModelFactory {
initializer {
val app = this[APPLICATION_KEY] as IncidoApplication
NoteEditorViewModel(
repository = app.container.noteRepository,
repository = graph.noteRepository,
noteId = noteId,
initialSharedText = initialSharedText,
initialSharedImages = initialSharedImages,
@@ -1,6 +1,5 @@
package org.incido.compose.ui.notelist
import android.graphics.BitmapFactory
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.combinedClickable
@@ -29,8 +28,10 @@ import androidx.compose.material.icons.filled.AttachFile
import androidx.compose.material.icons.filled.CheckBox
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.DeleteForever
import androidx.compose.material.icons.filled.Lock
import androidx.compose.material.icons.filled.Menu
import androidx.compose.material.icons.filled.Mic
import androidx.compose.material.icons.filled.MoreVert
import androidx.compose.material.icons.filled.PhotoCamera
import androidx.compose.material.icons.filled.Restore
@@ -38,6 +39,7 @@ import androidx.compose.material.icons.filled.Search
import androidx.compose.material.icons.filled.ShoppingBasket
import androidx.compose.material.icons.filled.Star
import androidx.compose.material.icons.outlined.StarOutline
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.CenterAlignedTopAppBar
@@ -51,6 +53,7 @@ import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
@@ -64,14 +67,17 @@ import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.graphics.ImageBitmap
import androidx.compose.ui.graphics.lerp
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel
import org.incido.compose.di.ioDispatcher
import org.incido.compose.di.requireAppGraph
import org.incido.compose.ui.theme.toComposeColor
import org.incido.compose.util.decodeImageBytes
import org.incido.compose.util.rememberRelativeTimestamp
import org.incido.domain.model.Note
import org.incido.domain.model.NoteAttachment
@@ -123,10 +129,11 @@ fun NoteListScreen(
onOpenEditor: (Long?) -> Unit,
/** v0.3.1.0 — used to fetch image bytes for card thumbnails. */
repository: NoteRepository? = null,
viewModel: NoteListViewModel = viewModel(factory = NoteListViewModel.Factory),
viewModel: NoteListViewModel = viewModel(factory = NoteListViewModel.factory(requireAppGraph())),
) {
val state by viewModel.uiState.collectAsStateWithLifecycle()
var localQuery by remember { mutableStateOf("") }
var showEmptyTrashDialog by remember { mutableStateOf(false) }
val searchFocusRequester = remember { FocusRequester() }
LaunchedEffect(filterMode) { viewModel.setFilter(filterMode) }
@@ -139,6 +146,36 @@ fun NoteListScreen(
}
}
// "Empty Trash" confirmation. The whole trash goes, attachments
// included — say so plainly before the one tap that does it.
if (showEmptyTrashDialog) {
AlertDialog(
onDismissRequest = { showEmptyTrashDialog = false },
title = { Text("Empty Trash?") },
text = {
Text(
"Every note in the Trash, including attachments, will be " +
"permanently deleted. This cannot be undone.",
)
},
confirmButton = {
TextButton(
onClick = {
showEmptyTrashDialog = false
viewModel.emptyTrash()
},
) {
Text("Empty Trash", color = MaterialTheme.colorScheme.error)
}
},
dismissButton = {
TextButton(onClick = { showEmptyTrashDialog = false }) {
Text("Cancel")
}
},
)
}
Scaffold(
topBar = {
CenterAlignedTopAppBar(
@@ -162,6 +199,17 @@ fun NoteListScreen(
Icon(Icons.Default.Search, contentDescription = "Search notes")
}
}
// Trash view gains an "Empty Trash" button whenever it
// holds something; the destructive action is confirmed
// through a dialog before anything is touched.
if (filterMode == NoteFilter.Trash && state.notes.isNotEmpty()) {
IconButton(onClick = { showEmptyTrashDialog = true }) {
Icon(
Icons.Default.DeleteForever,
contentDescription = "Empty trash",
)
}
}
},
)
},
@@ -234,8 +282,10 @@ private fun screenTitle(filter: NoteFilter): String = when (filter) {
NoteFilter.Home -> "Incido"
NoteFilter.Favorites -> "Favorites"
NoteFilter.Untagged -> "Untagged"
NoteFilter.Drafts -> "Drafts"
NoteFilter.Trash -> "Trash"
is NoteFilter.ByTag -> "#${filter.hashtag}"
is NoteFilter.ByColor -> filter.color.label
}
@Composable
@@ -244,8 +294,10 @@ private fun EmptyState(filterMode: NoteFilter) {
NoteFilter.Home -> "No notes yet. Tap + to start."
NoteFilter.Favorites -> "No favourites yet. Tap ⭐ on a card to add one."
NoteFilter.Untagged -> "All notes are tagged. 🎉"
NoteFilter.Drafts -> "No drafts yet. Start typing a new note and it lands here."
NoteFilter.Trash -> "Trash is empty."
is NoteFilter.ByTag -> "No notes tagged #${filterMode.hashtag} yet."
is NoteFilter.ByColor -> "No " + filterMode.color.label.lowercase() + " notes yet. Pick a colour in the editor."
}
Box(
modifier = Modifier
@@ -265,7 +317,9 @@ private fun EmptyState(filterMode: NoteFilter) {
private fun NoResultsState(filterMode: NoteFilter) {
val message = when (filterMode) {
NoteFilter.Home -> "No matching notes."
NoteFilter.Drafts -> "No drafts match your search."
NoteFilter.Trash -> "No notes in Trash match your search."
is NoteFilter.ByColor -> "No matching notes of this colour."
else -> "Nothing here."
}
Box(
@@ -393,8 +447,21 @@ private fun NoteCard(
// v0.3.8.0: task / shopping lists render marker-free on cards —
// header line becomes the title, items show as clean "Name ×qty @$X"
// text. The checkbox state lives in the summary row below instead.
val (title, body) = if (note.type == NoteType.TEXT) Note.titleAndBody(note.content)
else Note.cardPresentation(note.content, note.type)
// v0.4.2.0: voice notes carry a plain prose body (title = first
// line), so they split like TEXT — the cardPresentation list parser
// would mangle their content.
val (title, body) =
if (note.type == NoteType.TEXT || note.type == NoteType.VOICE_NOTE)
Note.titleAndBody(note.content)
else Note.cardPresentation(note.content, note.type)
// Drafts with no title introduce themselves by kind — "Shopping
// List - (draft)" beats a bare "Untitled" in the Drafts view. The
// stored content is untouched; this is display-only, so typing a
// real title (or publishing) reverts the card to normal instantly.
val displayTitle =
if (note.isDraft && title == Note.UNTITLED)
"${note.type.displayName} - (draft)"
else title
val bodyPreview = Note.bodyPreview(body)
val checklistSummary = Note.checklistSummary(note.content)
val noteColor = note.color
@@ -405,13 +472,13 @@ private fun NoteCard(
// a downsampled bitmap for the card background. The produceState
// scopes the work to the card's lifetime, so off-screen cards
// don't keep their bitmaps alive.
val thumbnailBitmap by produceState<android.graphics.Bitmap?>(initialValue = null, key1 = firstImage?.id) {
val thumbnailBitmap by produceState<ImageBitmap?>(initialValue = null, key1 = firstImage?.id) {
if (firstImage == null || repository == null) {
value = null
} else {
value = withContext(kotlinx.coroutines.Dispatchers.IO) {
value = withContext(ioDispatcher) {
val bytes = repository.getAttachmentBytes(firstImage.id) ?: return@withContext null
BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
decodeImageBytes(bytes)
}
}
}
@@ -471,7 +538,7 @@ private fun NoteCard(
// Card's opaque containerColor was drawn on top of them).
if (thumbnailBitmap != null) {
Image(
bitmap = thumbnailBitmap!!.asImageBitmap(),
bitmap = thumbnailBitmap!!,
contentDescription = null,
contentScale = ContentScale.Crop,
modifier = Modifier.matchParentSize(),
@@ -508,7 +575,7 @@ private fun NoteCard(
verticalAlignment = Alignment.CenterVertically,
) {
Text(
text = title,
text = displayTitle,
style = MaterialTheme.typography.titleMedium,
color = titleColor,
maxLines = 1,
@@ -547,6 +614,27 @@ private fun NoteCard(
)
}
}
if (note.type == NoteType.VOICE_NOTE) {
// v0.4.2.0: voice notes carry a mic badge so the
// kind is recognisable on the card even when the
// body is empty (the take itself is an audio
// attachment, not visible as a thumbnail).
Spacer(modifier = Modifier.padding(top = 4.dp))
Row(verticalAlignment = Alignment.CenterVertically) {
Icon(
Icons.Default.Mic,
contentDescription = null,
modifier = Modifier.size(14.dp),
tint = secondaryColor,
)
Spacer(Modifier.size(6.dp))
Text(
text = note.type.displayName,
style = MaterialTheme.typography.labelSmall,
color = secondaryColor,
)
}
}
if (note.hashtags.isNotEmpty()) {
Spacer(modifier = Modifier.padding(top = 4.dp))
HashtagRow(
@@ -2,7 +2,6 @@ package org.incido.compose.ui.notelist
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.Companion.APPLICATION_KEY
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
@@ -16,7 +15,8 @@ import kotlinx.coroutines.flow.debounce
import kotlinx.coroutines.flow.flatMapLatest
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
import org.incido.compose.IncidoApplication
import org.incido.compose.di.AppGraph
import org.incido.compose.di.EncryptionBadge
import org.incido.domain.model.HashtagUsage
import org.incido.domain.model.Note
import org.incido.domain.model.NoteFilter
@@ -44,15 +44,19 @@ data class NoteListUiState(
) {
val isEmpty: Boolean
get() = !isLoading && notes.isEmpty() && !isSearchActive &&
(filter == NoteFilter.Home || filter == NoteFilter.Trash)
(filter == NoteFilter.Home || filter == NoteFilter.Trash ||
filter == NoteFilter.Drafts)
val noResults: Boolean get() = !isLoading && notes.isEmpty() && !isEmpty
}
@OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class)
class NoteListViewModel(
private val repository: NoteRepository,
/** v0.3.5.0 — source of the verified-encryption badge set. */
private val encryptionVerifier: org.incido.compose.data.security.EncryptionVerifier? = null,
/** v0.3.5.0 — source of the verified-encryption badge set.
* M4.3c: the concrete `EncryptionVerifier` (androidLibrary sources)
* becomes the commonMain [EncryptionBadge] face — same StateFlow
* contents, mapped 1:1 by each container. */
private val encryptionBadge: EncryptionBadge? = null,
) : ViewModel() {
private val filterMode = MutableStateFlow<NoteFilter>(NoteFilter.Home)
@@ -73,8 +77,11 @@ class NoteListViewModel(
NoteFilter.Home -> if (q.isBlank()) repository.observeAll() else repository.search(q)
NoteFilter.Favorites -> if (q.isBlank()) repository.observeFavorites() else repository.searchFavorites(q)
NoteFilter.Untagged -> if (q.isBlank()) repository.observeUntagged() else repository.searchUntagged(q)
NoteFilter.Drafts -> if (q.isBlank()) repository.observeDrafts() else repository.searchDrafts(q)
NoteFilter.Trash -> if (q.isBlank()) repository.observeTrashed() else repository.searchTrashed(q)
is NoteFilter.ByTag -> repository.observeNotesForHashtag(f.hashtag)
is NoteFilter.ByColor ->
if (q.isBlank()) repository.observeByColor(f.color) else repository.searchByColor(q, f.color)
}
}
@@ -108,7 +115,7 @@ class NoteListViewModel(
*/
val uiState: StateFlow<NoteListUiState> = combine(
baseUiState,
encryptionVerifier?.verification
encryptionBadge?.verification
?: kotlinx.coroutines.flow.flowOf(null),
) { state, verification ->
state.copy(
@@ -156,6 +163,11 @@ class NoteListViewModel(
viewModelScope.launch { repository.delete(id) }
}
/** "Empty Trash": permanently destroy every note in the Trash. */
fun emptyTrash() {
viewModelScope.launch { repository.deleteAllTrashed() }
}
/** Restore a note from Trash. */
fun restore(id: Long) {
viewModelScope.launch { repository.restore(id) }
@@ -166,12 +178,11 @@ class NoteListViewModel(
}
companion object {
val Factory: ViewModelProvider.Factory = viewModelFactory {
fun factory(graph: AppGraph): ViewModelProvider.Factory = viewModelFactory {
initializer {
val app = this[APPLICATION_KEY] as IncidoApplication
NoteListViewModel(
repository = app.container.noteRepository,
encryptionVerifier = app.container.encryptionVerifier,
repository = graph.noteRepository,
encryptionBadge = graph.encryptionBadge,
)
}
}
@@ -1,8 +1,5 @@
package org.incido.compose.ui.settings
import android.content.ClipData
import android.content.ClipboardManager
import android.content.Context
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
@@ -27,7 +24,9 @@ import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.ClipboardManager
import androidx.compose.ui.platform.LocalClipboardManager
import androidx.compose.ui.text.AnnotatedString
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.input.VisualTransformation
@@ -61,13 +60,23 @@ import org.incido.compose.data.settings.PasswordPolicy
* truth for "is this passphrase correct", surfaced as
* "Incorrect passphrase." via snackbar on mismatch.
*/
@Suppress("DEPRECATION") // LocalClipboardManager: see body comment — 1.8 API swap
@Composable
fun PassphraseDialog(
onConfirm: (CharArray) -> Unit,
onDismiss: () -> Unit,
mode: PassphraseDialogMode = PassphraseDialogMode.EXPORT,
) {
val context = LocalContext.current
// M4.4a clipboard migration: the §6.3 note (`LocalClipboardManager` →
// `LocalClipboard` + `ClipEntry`) describes the Compose UI **1.8** API —
// on this stack (1.7.3) `ClipEntry` has no public constructor and
// `LocalClipboard` does not exist yet (paid for while compiling).
// LocalClipboardManager is the SAME API on both targets in 1.7.x — the
// Android side keeps its ClipboardManager write verbatim by delegation,
// desktop goes through AWT (the spike's Q5 clipboard PASS used exactly
// this). Re-swap to LocalClipboard + ClipEntry when the stack moves to
// Compose 1.8 (recorded for M5+).
val clipboard: ClipboardManager = LocalClipboardManager.current
// v0.3.6.0: use the enum helper so RECOVERY_EXPORT shares the
// EXPORT chrome (policy check, Generate/Copy, Confirm field).
val isExport = mode.isExport
@@ -178,8 +187,10 @@ fun PassphraseDialog(
Icon(Icons.Filled.Refresh, contentDescription = "Generate")
}
IconButton(onClick = {
copyToClipboard(context, passphrase)
copied = true
if (passphrase.isNotEmpty()) {
clipboard.setText(AnnotatedString(passphrase))
copied = true
}
}) {
Icon(Icons.Filled.ContentCopy, contentDescription = "Copy")
}
@@ -269,10 +280,4 @@ enum class PassphraseDialogMode {
* password-policy check). Import variants skip those because
* an existing passphrase may predate the current policy. */
val isExport: Boolean get() = this == EXPORT || this == RECOVERY_EXPORT
}
private fun copyToClipboard(context: Context, value: String) {
if (value.isEmpty()) return
val cm = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
cm.setPrimaryClip(ClipData.newPlainText("Incido backup passphrase", value))
}
@@ -0,0 +1,240 @@
package org.incido.compose.ui.settings
import androidx.compose.foundation.clickable
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.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.SegmentedButton
import androidx.compose.material3.SegmentedButtonDefaults
import androidx.compose.material3.SingleChoiceSegmentedButtonRow
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import org.incido.compose.data.settings.ThemeMode
// ---------------------------------------------------------------------------
// M4.4d — the platform-neutral settings sections, lifted verbatim from
// SettingsScreen.kt (which keeps the Android-only Security section, the
// SAF wiring, and the screen chrome). The desktop settings screen (M4.5)
// composes exactly these three.
//
// Two callbacks became nullable so a platform can HIDE a row it cannot
// serve (dynamic color is Android-12 Material You; the Carnet importer is
// Android-side) — Android passes non-null everywhere, so its rendering
// is pixel-identical to pre-M4.
// ---------------------------------------------------------------------------
@Composable
fun AppearanceSection(
themeMode: ThemeMode,
dynamicColor: Boolean,
onThemeMode: (ThemeMode) -> Unit,
/** Null hides the Dynamic-color row (desktop has no Material You). */
onDynamicColor: ((Boolean) -> Unit)?,
) {
SettingsSection(title = "Appearance") {
Column(modifier = Modifier.padding(horizontal = 16.dp, vertical = 12.dp)) {
Text("Theme", style = MaterialTheme.typography.labelLarge)
Spacer(Modifier.padding(top = 6.dp))
SingleChoiceSegmentedButtonRow(modifier = Modifier.fillMaxWidth()) {
ThemeMode.values().forEachIndexed { index, mode ->
SegmentedButton(
selected = themeMode == mode,
onClick = { onThemeMode(mode) },
shape = SegmentedButtonDefaults.itemShape(
index = index,
count = ThemeMode.values().size,
),
label = {
Text(when (mode) {
ThemeMode.SYSTEM -> "System"
ThemeMode.LIGHT -> "Light"
ThemeMode.DARK -> "Dark"
})
},
)
}
}
if (onDynamicColor != null) {
Spacer(Modifier.padding(top = 12.dp))
Row(
modifier = Modifier.fillMaxWidth(),
verticalAlignment = Alignment.CenterVertically,
) {
Column(modifier = Modifier.weight(1f)) {
Text("Dynamic color", style = MaterialTheme.typography.bodyMedium)
Text(
"Use the system Material You palette on Android 12+.",
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
Switch(checked = dynamicColor, onCheckedChange = onDynamicColor)
}
}
}
}
}
@Composable
fun BackupSection(
onExport: () -> Unit,
onImport: () -> Unit,
/** Null hides the Carnet row — its importer lives in androidMain. */
onImportCarnet: (() -> Unit)?,
) {
SettingsSection(title = "Backup & Restore") {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 16.dp, vertical = 12.dp),
verticalArrangement = Arrangement.spacedBy(8.dp),
) {
Text(
"Export your notes to a JSON file (with optional passphrase " +
"encryption) or import a backup. Imports are additive — " +
"they don't replace your existing notes.",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
Button(onClick = onExport, modifier = Modifier.fillMaxWidth()) {
Text("Export to file…")
}
OutlinedButton(onClick = onImport, modifier = Modifier.fillMaxWidth()) {
Text("Import from file…")
}
if (onImportCarnet != null) {
OutlinedButton(onClick = onImportCarnet, modifier = Modifier.fillMaxWidth()) {
Text("Import 3rd Party Notes")
}
}
}
}
}
@Composable
fun AboutSection(
version: String,
onVersionClick: () -> Unit,
) {
SettingsSection(title = "About") {
Column(modifier = Modifier.padding(horizontal = 16.dp, vertical = 12.dp)) {
Row(
modifier = Modifier
.fillMaxWidth()
.clickable(onClick = onVersionClick)
.padding(vertical = 6.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Column(modifier = Modifier.weight(1f)) {
Text("Incido", style = MaterialTheme.typography.titleMedium)
Text(
text = "Version $version",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.primary,
)
}
Text(
text = "Tap for release notes",
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
}
}
}
// ---------------------------------------------------------------------------
// Building blocks — M4.4d: shared vocabulary for SettingsScreen
// (androidMain) and DesktopSettingsScreen. M4.5 note: public, not
// internal — desktopApp is a separate Gradle module.
// ---------------------------------------------------------------------------
@Composable
fun SettingsSection(title: String, content: @Composable () -> Unit) {
Column {
Text(
text = title,
style = MaterialTheme.typography.labelLarge,
color = MaterialTheme.colorScheme.primary,
fontWeight = FontWeight.SemiBold,
modifier = Modifier.padding(start = 4.dp, top = 8.dp, bottom = 4.dp),
)
Card(modifier = Modifier.fillMaxWidth()) {
content()
}
}
}
/** v0.3.3.0: optionally renders a disabled (greyed) switch — used for
* the mutually-exclusive PIN / Biometric toggles. */
@Composable
fun SettingsToggle(
title: String,
subtitle: String,
checked: Boolean,
onCheckedChange: (Boolean) -> Unit,
enabled: Boolean = true,
) {
val color = if (enabled) {
MaterialTheme.colorScheme.onSurface
} else {
MaterialTheme.colorScheme.onSurfaceVariant
}
val subColor = if (enabled) {
MaterialTheme.colorScheme.onSurfaceVariant
} else {
MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.5f)
}
Row(
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 4.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Column(modifier = Modifier.weight(1f)) {
Text(title, style = MaterialTheme.typography.bodyMedium, color = color)
Text(
subtitle,
style = MaterialTheme.typography.labelSmall,
color = subColor,
)
}
Switch(checked = checked, onCheckedChange = onCheckedChange, enabled = enabled)
}
}
@Composable
fun SettingsRow(
title: String,
subtitle: String,
onClick: () -> Unit,
) {
Row(
modifier = Modifier
.fillMaxWidth()
.clickable(onClick = onClick)
.padding(vertical = 8.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Column(modifier = Modifier.weight(1f)) {
Text(title, style = MaterialTheme.typography.bodyMedium)
Text(
subtitle,
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.primary,
)
}
}
}
@@ -1,14 +1,23 @@
package org.incido.compose.ui.theme
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.ColorScheme
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.ui.platform.LocalContext
/**
* Phase 1 (M4.1) platform seam for Material You dynamic color.
*
* Android returns a real scheme on API 31+ (the pre-M4 behaviour, kept
* verbatim in `androidMain`); every other platform returns null and the
* brand palette below applies. Desktop deliberately has no dynamic
* colour — same decision as M3 ("desktop hides the four Android-only
* security/appearance features").
*/
@Composable
expect fun platformDynamicColorScheme(darkTheme: Boolean): ColorScheme?
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
@@ -34,11 +43,8 @@ fun IncidoTheme(
content: @Composable () -> Unit,
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context)
else dynamicLightColorScheme(context)
}
dynamicColor -> platformDynamicColorScheme(darkTheme)
?: if (darkTheme) DarkColorScheme else LightColorScheme
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
@@ -0,0 +1,15 @@
package org.incido.compose.util
import androidx.compose.ui.graphics.ImageBitmap
/**
* Phase 1 (M4.4b) — the §6.3 image-decode seam.
*
* The single decode call the UI layer needs (attachment thumbnails +
* the full-screen viewer). Android actual = the verbatim
* `BitmapFactory.decodeByteArray` (+ `asImageBitmap`); JVM actual =
* `org.jetbrains.skia.Image.makeFromEncoded(bytes).toComposeImageBitmap()`
* — both wrapped so undecodable bytes return null, which is how the
* pre-M4 screens already treat a failed `BitmapFactory` decode.
*/
expect fun decodeImageBytes(bytes: ByteArray): ImageBitmap?
@@ -0,0 +1,15 @@
package org.incido.compose.util
import androidx.compose.runtime.Composable
/**
* Phase 1 (M4.4c) — platform back-press seam (was a private one-liner
* wrapper around `activity-compose` inside the editor file).
*
* Android actual = `androidx.activity.compose.BackHandler`, verbatim
* behaviour. The JVM actual (M5.1) registers into the desktop window's
* [PlatformBackStack], which the window drains on Esc — so the editor's
* discard-prompt chain works on both platforms through this one seam.
*/
@Composable
expect fun PlatformBackHandler(enabled: Boolean, onBack: () -> Unit)
@@ -0,0 +1,22 @@
package org.incido.compose.util
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
/**
* Returns a localised "X ago" style timestamp for the given epoch millis.
*
* Phase 1 (M4.1) platform seam: Android formats via
* [android.text.format.DateUtils.getRelativeTimeSpanString] (verbatim
* pre-M4 behaviour, kept in `androidMain`); the JVM target formats with
* `java.time` (see `RelativeTime.jvm.kt`).
*/
@Composable
fun rememberRelativeTimestamp(epochMillis: Long): String {
val now = remember { System.currentTimeMillis() }
return remember(epochMillis) { relativeTimestamp(epochMillis, now) }
}
/** Formats [epochMillis] relative to [nowMillis] — "23 min. ago" /
* "Today" / "Yesterday" / "3 days ago" / absolute date beyond that. */
expect fun relativeTimestamp(epochMillis: Long, nowMillis: Long): String
@@ -0,0 +1,14 @@
package org.incido.compose.data.backup
import java.security.SecureRandom
/**
* M4.4a seam for [PassphraseGenerator] — identical two-liner actual on
* both targets (both targets ARE the JVM; commonMain just cannot spell
* `java.security`). Behaviour (CSPRNG backing, draw distribution) is
* exactly the pre-M4 `SecureRandom()` field it replaces.
*/
private val secureRandom = SecureRandom()
internal actual fun secureRandomInt(bound: Int): Int = secureRandom.nextInt(bound)
@@ -0,0 +1,6 @@
package org.incido.compose.di
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.Dispatchers
internal actual val ioDispatcher: CoroutineDispatcher = Dispatchers.IO
@@ -0,0 +1,126 @@
package org.incido.compose.ui.editor
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.ui.Modifier
import java.awt.Desktop
import java.io.File
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.incido.domain.model.NoteAttachment
import org.incido.domain.repository.NoteRepository
/**
* M4.4c JVM actual — desktop file intake per §6.3: AWT `FileDialog`
* (the native GTK dialog M2's Import/Export menu already proved out)
* instead of SAF, "open with" via `java.awt.Desktop` (falling back to
* `xdg-open`), and camera/voice HIDDEN (§6.5 — the editor asks
* `supportsCamera`/`supportsVoice` and does not render those buttons).
*/
@Composable
actual fun rememberEditorIntake(
onPickedBytes: suspend (bytes: ByteArray, mimeType: String, displayName: String) -> Unit,
onVoiceConvert: () -> Unit,
isVoiceMode: Boolean,
beginExternalActivity: (() -> Unit)?,
): EditorIntake {
val scope = rememberCoroutineScope()
return remember(scope) {
object : EditorIntake {
override val supportsCamera = false
override val supportsVoice = false
override fun takePhoto() = Unit // hidden: supportsCamera is false
override fun pickFiles() {
scope.launch {
val picked = withContext(Dispatchers.IO) {
val dialog = java.awt.FileDialog(null as java.awt.Frame?, "Attach file").apply {
mode = java.awt.FileDialog.LOAD
file = null // start with no preselected name
}
dialog.show()
val dir = dialog.directory ?: return@withContext null
val name = dialog.file ?: return@withContext null
val file = File(dir, name)
runCatching { file.readBytes() }.getOrNull()
?.let { it to file.name }
}
val (bytes, name) = picked ?: return@launch
onPickedBytes(bytes, guessMimeType(name), name)
}
}
override fun toggleVoiceMode() = Unit // hidden: supportsVoice is false
override fun checkMicPermission(): Boolean = false
override fun requestMicPermission() = Unit
override fun notify(msg: String) {
// No Toast surface on desktop; the lazy-load "Loading…"
// nudge is a no-op (the thumbnail resolves in ms locally).
}
override fun openExternal(bytes: ByteArray, mimeType: String, displayName: String) {
scope.launch {
withContext(Dispatchers.IO) {
runCatching {
val safeName = displayName.replace(Regex("[^A-Za-z0-9._-]"), "_")
val outbox = File(System.getProperty("java.io.tmpdir"), "incido-open-outbox")
.apply { mkdirs() }
val tmp = File(outbox, "open_${'$'}{System.currentTimeMillis()}_$safeName")
tmp.writeBytes(bytes)
if (Desktop.isDesktopSupported() && Desktop.getDesktop().isSupported(Desktop.Action.OPEN)) {
Desktop.getDesktop().open(tmp)
} else {
ProcessBuilder("xdg-open", tmp.absolutePath).start()
}
}
}
}
}
}
}
}
/** Best-effort mime guess from the extension (the mime only labels the
* attachment row; the desktop open path dispatches on the file). */
private fun guessMimeType(name: String): String = when (name.substringAfterLast('.', "").lowercase()) {
"png" -> "image/png"
"jpg", "jpeg" -> "image/jpeg"
"gif" -> "image/gif"
"webp" -> "image/webp"
"svg" -> "image/svg+xml"
"txt", "md" -> "text/plain"
"pdf" -> "application/pdf"
"ogg", "oga" -> "audio/ogg"
"opus" -> "audio/opus"
"mp3" -> "audio/mpeg"
"m4a" -> "audio/mp4"
"wav" -> "audio/wav"
"zip" -> "application/zip"
else -> "application/octet-stream"
}
/**
* M4.4c JVM actual: the voice recorder card renders NOTHING (§6.5
* hide-don't-stub). Audio imported from a phone survives as a plain
* attachment row; there is simply no desktop recorder UI.
*/
@Composable
actual fun VoiceNoteSlot(
voicePending: PendingAttachment?,
voicePendingBytes: ByteArray?,
voicePersisted: NoteAttachment?,
repository: NoteRepository?,
hasMicPermission: () -> Boolean,
onRequestPermission: () -> Unit,
onTakeRecorded: (ByteArray, String) -> Unit,
onDeleteTake: () -> Unit,
beginExternalActivity: (() -> Unit)?,
modifier: Modifier,
) = Unit
@@ -0,0 +1,10 @@
package org.incido.compose.ui.theme
import androidx.compose.runtime.Composable
import androidx.compose.material3.ColorScheme
/** JVM actual — desktop has no Material You (hidden, not faked; same
* posture as M3's four hidden Android-only features). Always null, so
* [IncidoTheme] falls through to the brand palette. */
@Composable
actual fun platformDynamicColorScheme(darkTheme: Boolean): ColorScheme? = null
@@ -0,0 +1,15 @@
package org.incido.compose.util
import androidx.compose.ui.graphics.ImageBitmap
import androidx.compose.ui.graphics.toComposeImageBitmap
import org.jetbrains.skia.Image
/**
* M4.4b JVM actual — the §6.3 recipe:
* `Image.makeFromEncoded(bytes).toComposeImageBitmap()`. skia THROWS on
* undecodable bytes where BitmapFactory returns null, so the
* runCatching keeps the seam's null-on-failure contract (empty/partial
* attachment bytes must show the placeholder, not crash the strip).
*/
actual fun decodeImageBytes(bytes: ByteArray): ImageBitmap? =
runCatching { Image.makeFromEncoded(bytes).toComposeImageBitmap() }.getOrNull()
@@ -0,0 +1,66 @@
package org.incido.compose.util
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.compositionLocalOf
import androidx.compose.runtime.remember
/**
* M5.1 — the M4.4c no-op made real: a desktop back stack.
*
* A desktop window has no system back gesture, so the desktop window
* translates Esc (`Window(onPreviewKeyEvent)`) into [dispatchBack] on the
* [PlatformBackStack] provided through [LocalPlatformBackStack]. Every live
* `PlatformBackHandler` becomes an entry here, so the editor's existing
* tryClose/discard-prompt chain behaves exactly like Android's BackHandler
* stack: the topmost enabled entry wins.
*
* Entries keep their stack position across recompositions: the registration
* object is remembered and its callback slot refreshed per composition.
* Re-registering on every `onBack` lambda change would let a lower handler's
* recomposition jump above an editor or dialog stacked on top of it.
*/
class PlatformBackStack {
internal class Entry(var enabled: Boolean = false, var onBack: () -> Unit = {})
private val entries = ArrayDeque<Entry>()
internal fun push(entry: Entry) {
entries.addLast(entry)
}
internal fun remove(entry: Entry) {
entries.remove(entry)
}
/**
* Runs the topmost enabled handler. Returns true when consumed — the
* window uses that to decide whether Esc falls through to content.
*/
fun dispatchBack(): Boolean {
val top = entries.lastOrNull { it.enabled } ?: return false
top.onBack()
return true
}
}
/** Provided by the desktop host window (see `:desktopApp` Main.kt, M5.1). */
val LocalPlatformBackStack = compositionLocalOf<PlatformBackStack?> { null }
/**
* M4.4c/M5.1 JVM actual — registers into [LocalPlatformBackStack]. No-op
* when the host provides no stack (headless tests, embeds).
*/
@Composable
actual fun PlatformBackHandler(enabled: Boolean, onBack: () -> Unit) {
val stack = LocalPlatformBackStack.current
val entry = remember { PlatformBackStack.Entry() }
entry.enabled = enabled
entry.onBack = onBack
if (stack != null) {
DisposableEffect(stack) {
stack.push(entry)
onDispose { stack.remove(entry) }
}
}
}
@@ -0,0 +1,40 @@
package org.incido.compose.util
import java.time.Instant
import java.time.LocalDate
import java.time.ZoneId
import java.time.format.DateTimeFormatter
import java.time.temporal.ChronoUnit
/**
* JVM actual — a `java.time` port of the Android `DateUtils` abbreviated
* relative format ("23 min. ago" / "Today" / "Yesterday" / "3 days
* ago" / absolute date beyond a week).
*
* English-only for now (desktop has no UI locale switch yet); matching
* Android's localisation exactly is M4 follow-up work — the Android
* actual above remains the reference behaviour.
*/
actual fun relativeTimestamp(epochMillis: Long, nowMillis: Long): String {
val zone = ZoneId.systemDefault()
val then = Instant.ofEpochMilli(epochMillis).atZone(zone).toLocalDate()
val now = Instant.ofEpochMilli(nowMillis).atZone(zone).toLocalDate()
val days = ChronoUnit.DAYS.between(then, now)
val deltaMillis = nowMillis - epochMillis
// Same-day (and future / sub-minute) timestamps: relative clock time.
if (days <= 0L) {
if (deltaMillis < 60_000L) return "Just now"
val minutes = deltaMillis / 60_000L
if (minutes < 60L) return "$minutes min. ago"
val hours = minutes / 60L
return if (hours < 24L) "$hours hr. ago" else "Today"
}
if (days == 1L) return "Yesterday"
if (days < 7L) return "$days days ago"
// Beyond a week: absolute date, year shown only when it differs —
// DateUtils' "Oct 5" / "Oct 5, 2025" shape.
val pattern = if (then.year == now.year) "MMM d" else "MMM d, yyyy"
return then.format(DateTimeFormatter.ofPattern(pattern))
}
@@ -1,263 +0,0 @@
package org.incido.compose
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.DrawerValue
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.ModalNavigationDrawer
import androidx.compose.material3.rememberDrawerState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.runtime.snapshots.SnapshotStateList
import androidx.compose.runtime.toMutableStateList
import androidx.compose.ui.platform.LocalContext
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.compose.LocalLifecycleOwner
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.navigation.NavType
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.currentBackStackEntryAsState
import androidx.navigation.compose.rememberNavController
import androidx.navigation.navArgument
import kotlinx.coroutines.launch
import org.incido.compose.data.security.SecurityManager
import org.incido.compose.data.settings.SettingsRepository
import org.incido.compose.share.SharedIntentBuffer
import org.incido.compose.ui.drawer.IncidoDrawer
import org.incido.compose.ui.editor.NoteEditorScreen
import org.incido.compose.ui.editor.SharedImage
import org.incido.compose.ui.notelist.NoteListScreen
import org.incido.compose.ui.settings.SettingsScreen
import org.incido.compose.ui.settings.auth.PinChangeScreen
import org.incido.compose.ui.settings.auth.PinEntryScreen
import org.incido.compose.ui.settings.auth.PinSetupScreen
import org.incido.compose.ui.theme.IncidoTheme
import org.incido.domain.model.NoteFilter
import org.incido.domain.repository.NoteRepository
/** Top-level navigation destinations. */
private object Routes {
const val LIST = "list"
const val EDITOR = "editor/{noteId}"
const val SETTINGS = "settings"
const val PIN_SETUP = "pin_setup"
/** v0.3.3.0: three-step "Reset PIN" flow. */
const val PIN_CHANGE = "pin_change"
fun editor(noteId: Long?): String = "editor/${noteId ?: -1L}"
}
/** Stable serialisation for [NoteFilter] so `rememberSaveable` works. */
private fun NoteFilter.toSaveableKey(): String = key()
private fun String.toNoteFilter(): NoteFilter = when {
this == "home" -> NoteFilter.Home
this == "favorites" -> NoteFilter.Favorites
this == "untagged" -> NoteFilter.Untagged
this == "trash" -> NoteFilter.Trash
startsWith("tag:") -> NoteFilter.ByTag(this.removePrefix("tag:"))
else -> NoteFilter.Home
}
/**
* v0.3.1.0: Holds the share-into payload (text + pre-loaded image
* bytes) so the [NoteEditorScreen] can read it on first composition.
* Cleared as soon as the editor is created.
*
* v0.3.6.0: also carries [subject] (`Intent.EXTRA_SUBJECT`) so the
* editor can put the page title on the note's first line for URL
* shares — still offline-only, no network fetch.
*/
private class ShareIntoHolder {
var text: String? = null
var images: List<SharedImage> = emptyList()
var subject: String? = null
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun IncidoApp(
repository: NoteRepository? = null,
securityManager: SecurityManager? = null,
settingsRepository: SettingsRepository? = null,
) {
val context = LocalContext.current
val app = context.applicationContext as IncidoApplication
// v0.3.2.0: prefer explicit params, fall back to the application
// container. Both hosts (`MainActivity` + tests) supply them in
// production — the fallback is just a robustness net.
val resolvedSecurity = securityManager ?: app.container.securityManager
val resolvedSettings = settingsRepository ?: app.container.settingsRepository
// v0.3.2.0: collect user settings to drive theme + the auth gate.
val settings by resolvedSettings.userSettingsFlow.collectAsStateWithLifecycle(
initialValue = org.incido.compose.data.settings.UserSettings(),
)
val lockState by resolvedSecurity.lockState.collectAsStateWithLifecycle()
IncidoTheme(
darkTheme = settings.themeMode.resolveDark(isSystemInDarkTheme()),
dynamicColor = settings.dynamicColor,
) {
// v0.3.2.0: hard lock gate. If the app is locked we render
// the PIN entry screen in place of the regular UI.
if (lockState is SecurityManager.LockState.Locked) {
PinEntryScreen()
return@IncidoTheme
}
val navController = rememberNavController()
val drawerState = rememberDrawerState(initialValue = DrawerValue.Closed)
val scope = rememberCoroutineScope()
var filterMode by rememberSaveable(
stateSaver = androidx.compose.runtime.saveable.Saver(
save = { it.toSaveableKey() },
restore = { it.toNoteFilter() },
),
) { mutableStateOf<NoteFilter>(NoteFilter.Home) }
// v0.3.1.0: consume any inbound share-into payload once at
// composition. The buffer is single-shot — first composition
// wins. If a payload is present, we open a fresh editor with
// the shared content pre-filled.
val shareHolder = remember { ShareIntoHolder() }
LaunchedEffect(Unit) {
val payload = SharedIntentBuffer.consume()
if (payload != null && !payload.isEmpty) {
shareHolder.text = payload.text
shareHolder.images = payload.images
shareHolder.subject = payload.subject
navController.navigate(Routes.editor(null)) {
popUpTo(Routes.LIST)
}
}
}
val currentBackStack by navController.currentBackStackEntryAsState()
val currentRoute = currentBackStack?.destination?.route?.substringBefore("/")
// Disable the drawer on the editor so back arrow / gesture do
// exactly what the user expects there.
val isListRoute = currentRoute == Routes.LIST
LaunchedEffect(currentRoute) {
// If we land on the editor via deep link without a list in
// the back stack, snap the drawer closed.
if (!isListRoute && drawerState.isOpen) drawerState.close()
}
// v0.3.2.0: forward app foreground/background transitions to
// the SecurityManager so it can re-lock when the timeout
// elapses. LifecycleEventObserver wires ON_RESUME / ON_STOP
// automatically.
val lifecycleOwner = LocalLifecycleOwner.current
DisposableEffect(lifecycleOwner) {
val observer = LifecycleEventObserver { _, event ->
when (event) {
Lifecycle.Event.ON_RESUME -> resolvedSecurity.onAppForegrounded()
Lifecycle.Event.ON_STOP -> resolvedSecurity.onAppBackgrounded()
else -> Unit
}
}
lifecycleOwner.lifecycle.addObserver(observer)
onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }
}
ModalNavigationDrawer(
drawerState = drawerState,
gesturesEnabled = isListRoute,
drawerContent = {
IncidoDrawer(
currentFilter = filterMode,
onSelectFilter = { picked ->
filterMode = picked
scope.launch { drawerState.close() }
},
onOpenSettings = {
scope.launch { drawerState.close() }
navController.navigate(Routes.SETTINGS)
},
)
},
) {
NavHost(navController = navController, startDestination = Routes.LIST) {
composable(Routes.LIST) {
NoteListScreen(
filterMode = filterMode,
onOpenDrawer = { scope.launch { drawerState.open() } },
onOpenEditor = { id -> navController.navigate(Routes.editor(id)) },
// v0.3.1.0: thread the NoteRepository through so the
// card thumbnail composables can fetch image bytes.
repository = repository,
)
}
composable(
route = Routes.EDITOR,
arguments = listOf(
navArgument("noteId") {
type = NavType.LongType
defaultValue = -1L
},
),
) { entry ->
val raw = entry.arguments?.getLong("noteId") ?: -1L
val id = if (raw <= 0L) null else raw
// Read the share payload ONCE (consume) so back-then-reopen
// doesn't re-route us into the editor with stale data.
val sharedText = shareHolder.text.also { shareHolder.text = null }
val sharedImages = shareHolder.images.also { shareHolder.images = emptyList() }
// v0.3.6.0: also drain the page-title subject from the
// share intent so the editor can format the note
// with title on the first line.
val sharedSubject = shareHolder.subject.also { shareHolder.subject = null }
NoteEditorScreen(
noteId = id,
onClose = { navController.popBackStack() },
initialSharedText = sharedText,
initialSharedImages = sharedImages,
initialSharedSubject = sharedSubject,
repository = repository,
// v0.3.4.0 hotfix: suppress auto-lock around
// the editor's picker / camera / system-viewer
// round-trips.
securityManager = resolvedSecurity,
)
}
composable(Routes.SETTINGS) {
SettingsScreen(
onBack = { navController.popBackStack() },
onRequestPinSetup = { navController.navigate(Routes.PIN_SETUP) },
// v0.3.3.0: "Reset PIN" row navigates here.
onRequestPinChange = { navController.navigate(Routes.PIN_CHANGE) },
// v0.3.4.0 hotfix: suppress auto-lock around
// the backup export/import SAF pickers.
securityManager = resolvedSecurity,
)
}
composable(Routes.PIN_SETUP) {
PinSetupScreen(
onDone = { navController.popBackStack() },
onCancel = { navController.popBackStack() },
)
}
composable(Routes.PIN_CHANGE) {
PinChangeScreen(
onDone = { navController.popBackStack() },
onCancel = { navController.popBackStack() },
)
}
}
}
}
}
// Suppress unused-import lint for the snapshots helper that may be
// re-introduced in future filter-state extensions.
@Suppress("unused")
private fun <T> List<T>.toSnapshotStateList(): SnapshotStateList<T> = toMutableStateList<T>()
@@ -1,167 +0,0 @@
package org.incido.compose.data.backup
import android.content.Context
import android.net.Uri
import java.io.InputStream
import java.io.OutputStream
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.incido.domain.repository.NoteRepository
/**
* v0.3.2.0: orchestration layer for Backup / Import / Export.
*
* Reads / writes go through the Storage Access Framework — the
* Activity hands in [Uri]s from
* `ActivityResultContracts.CreateDocument` / `OpenDocument` and the
* manager streams bytes in / out via ContentResolver. No fixed-path
* writes, no extra permissions.
*
* Encrypt-on-export and decrypt-on-import are selected by the caller;
* the codecs themselves ([BackupCodec], [EncryptedBackupCodec]) hold
* the format / cipher details.
*/
class BackupManager(
private val context: Context,
private val repository: NoteRepository,
) {
/**
* Snapshot every note in [repository] and stream it to [uri] as a
* plain JSON file. Throws on I/O failure.
*
* Returns the number of notes exported.
*/
suspend fun exportPlain(
uri: Uri,
appVersion: String,
onProgress: (current: Int, total: Int) -> Unit = { _, _ -> },
): Int = withContext(Dispatchers.IO) {
val file = BackupCodec.exportSnapshot(repository, appVersion)
val json = BackupCodec.encode(file)
context.contentResolver.openOutputStream(uri, "wt")?.use { out: OutputStream ->
out.write(json.toByteArray(Charsets.UTF_8))
out.flush()
} ?: throw java.io.IOException("Could not open output stream for $uri")
onProgress(file.notes.size, file.notes.size)
file.notes.size
}
/**
* Snapshot every note and stream it to [uri] as a passphrase-
* encrypted envelope. [passphrase] is consumed (zeroed) inside
* [EncryptedBackupCodec.encrypt].
*/
suspend fun exportEncrypted(
uri: Uri,
passphrase: CharArray,
appVersion: String,
onProgress: (current: Int, total: Int) -> Unit = { _, _ -> },
): Int = withContext(Dispatchers.IO) {
val file = BackupCodec.exportSnapshot(repository, appVersion)
val json = BackupCodec.encode(file)
val payload = EncryptedBackupCodec.encrypt(json, passphrase)
context.contentResolver.openOutputStream(uri, "wt")?.use { out ->
out.write(payload)
out.flush()
} ?: throw java.io.IOException("Could not open output stream for $uri")
onProgress(file.notes.size, file.notes.size)
file.notes.size
}
/**
* Read [uri] and import every note it contains. Auto-detects
* plain vs encrypted via the magic header. For encrypted files,
* [passphrase] is required (caller validates with
* [PasswordPolicy]).
*
* Returns the number of notes imported.
*/
suspend fun import(
uri: Uri,
passphrase: CharArray? = null,
onProgress: (current: Int, total: Int) -> Unit = { _, _ -> },
): Int = withContext(Dispatchers.IO) {
val bytes = context.contentResolver.openInputStream(uri)?.use { it.readBytes() }
?: throw java.io.IOException("Could not open input stream for $uri")
val json: String = if (EncryptedBackupCodec.isEncrypted(bytes)) {
val pass = passphrase
?: throw IllegalArgumentException("Encrypted backup requires a passphrase")
EncryptedBackupCodec.decrypt(bytes, pass)
} else {
String(bytes, Charsets.UTF_8)
}
val file = BackupCodec.decode(json)
BackupCodec.importSnapshot(file, repository) { cur, tot -> onProgress(cur, tot) }
file.notes.size
}
/**
* Cheap metadata preview — used by the "Import from file…" flow
* to show the user how many notes / attachments they're about to
* bring in before they commit.
*
* Returns `null` if the file can't be read or the passphrase is
* wrong (so the UI can surface "wrong passphrase" cleanly).
*/
suspend fun preview(uri: Uri, passphrase: CharArray? = null): BackupPreview? =
withContext(Dispatchers.IO) {
val bytes: ByteArray = try {
context.contentResolver.openInputStream(uri)?.use(InputStream::readBytes)
?: return@withContext null
} catch (_: java.io.IOException) {
return@withContext null
}
val json: String = if (EncryptedBackupCodec.isEncrypted(bytes)) {
val pass = passphrase ?: return@withContext null
try {
EncryptedBackupCodec.decrypt(bytes, pass)
} catch (_: javax.crypto.AEADBadTagException) {
return@withContext null
} catch (_: javax.crypto.BadPaddingException) {
return@withContext null
} catch (_: IllegalArgumentException) {
// v0.3.3.3 hotfix: a truncated / corrupt envelope
// fails the require(...) size checks inside
// decrypt() with an IllegalArgumentException.
// Previously that escaped preview() and crashed the
// coroutine; treat it the same as a bad passphrase.
return@withContext null
} catch (_: java.security.GeneralSecurityException) {
// Catch-all for any other cipher-layer failure.
return@withContext null
}
} else {
try {
String(bytes, Charsets.UTF_8)
} catch (_: java.io.IOException) {
return@withContext null
}
}
val file: BackupFile = try {
BackupCodec.decode(json)
} catch (_: kotlinx.serialization.SerializationException) {
return@withContext null
} catch (_: Exception) {
// v0.3.3.3 hotfix: any other decode failure (e.g. the
// payload wasn't JSON after all) must not escape.
return@withContext null
}
BackupPreview(
noteCount = file.notes.size,
attachmentCount = file.notes.sumOf { it.attachments.size },
appVersion = file.appVersion,
exportedAt = file.exportedAt,
)
}
}
/** Lightweight DTO shown in the import confirmation dialog. */
data class BackupPreview(
val noteCount: Int,
val attachmentCount: Int,
val appVersion: String,
val exportedAt: Long,
)
@@ -1,131 +0,0 @@
package org.incido.compose.data.settings
/**
* One entry in the "What's New" dialog. Surfaced from the Settings
* screen when the user taps the version number.
*
* v0.3.2.0: the dialog shows the [RECENT] list (newest first) in a
* scrollable column. Each entry has a version, a release date, and a
* list of bullet points summarising what shipped in that release.
*
* Content is mirrored from `Incido Development Plan.txt` §10 so the
* in-app dialog and the repo's history of changes stay in lockstep
* (the plan file is the source of truth at release time).
*/
data class ReleaseNote(
val version: String,
val date: String,
val bullets: List<String>,
)
object ReleaseNotes {
/**
* The 5 most recent Incido releases, ordered newest → oldest.
* Append a new entry on top each release.
*/
val RECENT: List<ReleaseNote> = listOf(
ReleaseNote(
version = "0.4.0.0",
date = "2026-09-18",
bullets = listOf(
"Import 3rd-party notes: Settings \u2192 Backup & Restore now " +
"has an \u201cImport 3rd Party Notes\u201d button that reads a " +
"Carnet / QuickNote .zip export (a single archive bundling " +
"one .sqd per note) and brings every note in \u2014 directly " +
"on-device, with no pre-conversion step.",
"Formatting is preserved as plain text: rich-text bodies are " +
"flattened, and note colours, keywords (imported as tags) " +
"and links carry over. To-do lists become native " +
"checklists you can tick off.",
"Images come across too \u2014 photo attachments inside each " +
"note are imported; auto-generated preview thumbnails are " +
"skipped, so you get one clean image per photo.",
"Import is additive: your existing notes are untouched and " +
"imported notes get fresh IDs, so you can safely pull in " +
"an archive at any time.",
),
),
ReleaseNote(
version = "0.3.8.1",
date = "2026-09-17",
bullets = listOf(
"Read this first \u2014 reinstall required. This build is signed " +
"with a new CI key (the previous key lived in the old build " +
"runner's cache and wasn't carried over), so Android refuses " +
"to install it over an existing Incido: it reports a " +
"signature conflict.",
"Export a backup BEFORE uninstalling: Settings \u2192 Backup " +
"\u2192 Export, plus Settings \u2192 Security \u2192 Export " +
"encryption key if you use encryption. Incido doesn't use " +
"Android's automatic backup, so uninstalling deletes your " +
"notes. Then install this APK and restore from that backup.",
"Nothing else changed: v0.3.8.1 is a re-release of v0.3.8.0 " +
"with the same task lists, shopping lists with the running " +
"total, and add-tag suggestions fix. The rebuild exists " +
"because the release pipeline had been failing to publish " +
"builds reliably; staying on v0.3.8.0 is perfectly fine.",
),
),
ReleaseNote(
version = "0.3.8.0",
date = "2026-09-16",
bullets = listOf(
"Task lists: a checklist button next to the # button in the " +
"editor turns any note into an editable task list — add, " +
"remove, and tick off items with real checkboxes.",
"Shopping lists with a running total: each row gets a " +
"quantity dropdown (1\u20139) and a supermarket-style " +
"price field \u2014 every digit you tap on the number pad " +
"is a cent, so entering 199 means $1.99 (the price box " +
"shows your raw entry beside its $ sign; the running " +
"total speaks real dollars). Tick an " +
"item once it's in your basket and the always-visible " +
"total at the top adds quantity \u00d7 price. Product, " +
"quantity, and price are strictly separate fields, so a " +
"product called \"Battery AA 3\" can never mess up your " +
"money maths.",
"Tapping the active list button again returns the note to " +
"plain text — nothing is lost, the items just become " +
"\"- [ ]\" lines you can also edit by hand.",
"Add-tag sheet fixed: existing hashtags now appear as a " +
"selectable suggestion list again, narrowing to matches " +
"live as you type (the suggestion pipeline was frozen, so " +
"only \"+ Create\\u2026\" ever showed).",
),
),
ReleaseNote(
version = "0.3.7.1",
date = "2026-08-30",
bullets = listOf(
"Cleaner Add / Edit screen: camera, attach-file, and " +
"add-tag moved out of the crowded title bar into a " +
"bottom action row — the title and remaining buttons " +
"now fit comfortably on every screen.",
"Fixed a false error message that flashed whenever you " +
"opened a saved image in the full-screen viewer.",
"Search now focuses automatically when opened and shows " +
"a clear (✕) button while you type.",
"Long tag lists in the navigation drawer now scroll " +
"instead of being cut off at the bottom.",
"The add-tag sheet opens with the keyboard already up.",
"New app icon: a flatter, cleaner take on the shield " +
"and pen-nib artwork.",
),
),
ReleaseNote(
version = "0.3.7.0",
date = "2026-08-20",
bullets = listOf(
"Trash / soft delete. Deleting a note now moves it to a new " +
"Trash section in the navigation drawer instead of " +
"destroying it immediately \u2014 it disappears from Home, " +
"Favorites, Untagged, tag views, and ordinary search.",
"Inside Trash, each note's menu offers Restore (puts it back " +
"where it was) or Delete permanently (destroys it for " +
"good, including attachments).",
),
),
// v0.4.0.0 push drops v0.3.6.0 off the "5 most recent" tail.
)
}
@@ -1,22 +0,0 @@
package org.incido.compose.util
import android.text.format.DateUtils
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
/**
* Returns a localised "X ago" style timestamp for the given epoch millis.
* Uses Android's [DateUtils.getRelativeTimeSpanString] which handles all
* the edge cases (Today / Yesterday / N days ago / N weeks ago / …) and
* is automatically localised to the device language.
*/
@Composable
fun rememberRelativeTimestamp(epochMillis: Long): String {
val now = remember { System.currentTimeMillis() }
return DateUtils.getRelativeTimeSpanString(
epochMillis,
now,
DateUtils.MINUTE_IN_MILLIS,
DateUtils.FORMAT_ABBREV_RELATIVE,
).toString()
}
+34
View File
@@ -0,0 +1,34 @@
// core/backup — Phase 1 (M2 task 1): the backup bridge, extracted from
// :composeApp so the desktop build can speak the phone's file format.
//
// Everything here is pure JVM/kotlinx (verified by reading the code in the
// Phase-0 spike: zero android.* imports in the codecs). The package name
// stays org.incido.compose.data.backup so the Android diff is file moves
// only — no import churn in composeApp.
//
// Shape follows :core:domain (plain kotlin("jvm"), consumed by both the
// Android app and the desktop app). No ObjectBox here: the codec talks to
// the app only through the NoteRepository interface from :core:domain.
plugins {
alias(libs.plugins.kotlinJvm)
// @Serializable DTOs (BackupFile / BackupNote / BackupAttachment) live in
// BackupCodec.kt — the plugin generates their serializers here.
alias(libs.plugins.kotlinSerialization)
}
java {
sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17
}
kotlin {
jvmToolchain(17)
}
dependencies {
// Public API speaks domain types (Note, NoteRepository) — api, not impl.
api(project(":core:domain"))
implementation(libs.kotlinx.coroutines.core)
implementation(libs.kotlinx.serialization.json)
}
@@ -0,0 +1,204 @@
package org.incido.compose.data.backup
import java.io.IOException
import java.io.InputStream
import java.io.OutputStream
import java.security.GeneralSecurityException
import javax.crypto.AEADBadTagException
import javax.crypto.BadPaddingException
import kotlinx.coroutines.flow.first
import org.incido.domain.repository.NoteRepository
/**
* Phase 1 (M2 task 1): platform-neutral orchestration for Backup /
* Import / Export, extracted from `BackupManager` so the desktop build
* can speak the exact same file format as the phone.
*
* The only difference from the old `BackupManager` internals is the I/O
* boundary: streams in, streams out — no `Uri`, no `ContentResolver`, no
* `Context`. Android keeps a thin `Uri → stream` shim around this object;
* desktop will hand it `FileInputStream` / `FileOutputStream` (task 2).
*
* Format / cipher details stay in [BackupCodec] and
* [EncryptedBackupCodec]; this class only sequences them. Like the codecs,
* these functions are **not** dispatcher-wrapped — the caller decides
* (Android's shim uses `withContext(Dispatchers.IO)`).
*/
object BackupBridge {
/**
* Snapshot every note in [repository] and write it to [output] as
* plain JSON. Closes [output]. Throws on I/O failure.
*
* Returns the number of notes exported.
*/
suspend fun exportPlain(
repository: NoteRepository,
output: OutputStream,
appVersion: String,
onProgress: (current: Int, total: Int) -> Unit = { _, _ -> },
): Int {
val file = BackupCodec.exportSnapshot(repository, appVersion)
val json = BackupCodec.encode(file)
output.use { out ->
out.write(json.toByteArray(Charsets.UTF_8))
out.flush()
}
onProgress(file.notes.size, file.notes.size)
return file.notes.size
}
/**
* Snapshot every note and write it to [output] as a passphrase-
* encrypted envelope. Closes [output]. [passphrase] is consumed
* (zeroed) inside [EncryptedBackupCodec.encrypt].
*
* Returns the number of notes exported.
*/
suspend fun exportEncrypted(
repository: NoteRepository,
output: OutputStream,
passphrase: CharArray,
appVersion: String,
onProgress: (current: Int, total: Int) -> Unit = { _, _ -> },
): Int {
val file = BackupCodec.exportSnapshot(repository, appVersion)
val json = BackupCodec.encode(file)
val payload = EncryptedBackupCodec.encrypt(json, passphrase)
output.use { out ->
out.write(payload)
out.flush()
}
onProgress(file.notes.size, file.notes.size)
return file.notes.size
}
/**
* Read [input] and import every note it contains. Closes [input].
* Auto-detects plain vs encrypted via the magic header. For
* encrypted files, [passphrase] is required (caller validates with
* `PasswordPolicy`).
*
* **Dedupe (M2 task 3):** with [skipExisting] (the default) a note is
* skipped when the library already holds a note with the same
* `(createdAt, updatedAt, sha256(content))` key — the triple the
* export preserves verbatim on both platforms (sound only since the
* M2 import-timestamp fix). The existing keys are snapshotted BEFORE
* this call, so a file containing two genuinely identical notes still
* imports both into a fresh library; only a *second import* of the
* same file adds nothing. Pass `skipExisting = false` to force the
* old additive behaviour.
*
* Errors surface as thrown exceptions, same as the old
* `BackupManager.import`: missing passphrase →
* [IllegalArgumentException]; bad passphrase / corrupt envelope →
* `GeneralSecurityException` family.
*/
suspend fun import(
repository: NoteRepository,
input: InputStream,
passphrase: CharArray? = null,
skipExisting: Boolean = true,
onProgress: (current: Int, total: Int) -> Unit = { _, _ -> },
): ImportSummary {
val bytes = input.use(InputStream::readBytes)
val json = payloadJson(bytes, passphrase)
val file = BackupCodec.decode(json)
val toImport = if (!skipExisting) {
file.notes
} else {
val existing = repository.observeAllIncludingTrashed().first()
.map { keyFor(it.createdAt, it.updatedAt, it.content) }
.toSet()
file.notes.filterNot { keyFor(it.createdAt, it.updatedAt, it.content) in existing }
}
val skipped = file.notes.size - toImport.size
BackupCodec.importSnapshot(file.copy(notes = toImport), repository) { cur, tot ->
onProgress(cur, tot)
}
return ImportSummary(imported = toImport.size, skipped = skipped)
}
/**
* Cheap metadata preview — used by the "Import from file…" flow
* to show the user how many notes / attachments they're about to
* bring in before they commit. Closes [input].
*
* Returns `null` if the file can't be read or the passphrase is
* wrong (so the UI can surface "wrong passphrase" cleanly).
*/
fun preview(input: InputStream, passphrase: CharArray? = null): BackupPreview? {
val bytes: ByteArray = try {
input.use(InputStream::readBytes)
} catch (_: IOException) {
return null
}
val json: String = try {
payloadJson(bytes, passphrase)
} catch (_: AEADBadTagException) {
return null
} catch (_: BadPaddingException) {
return null
} catch (_: IllegalArgumentException) {
// v0.3.3.3 hotfix (kept from BackupManager.preview): a
// truncated / corrupt envelope fails the require(...) size
// checks inside decrypt(); treat it like a bad passphrase
// instead of letting it escape and crash the coroutine.
return null
} catch (_: GeneralSecurityException) {
// Catch-all for any other cipher-layer failure.
return null
}
val file: BackupFile = try {
BackupCodec.decode(json)
} catch (_: kotlinx.serialization.SerializationException) {
return null
} catch (_: Exception) {
// v0.3.3.3 hotfix: any other decode failure (e.g. the
// payload wasn't JSON after all) must not escape.
return null
}
return BackupPreview(
noteCount = file.notes.size,
attachmentCount = file.notes.sumOf { it.attachments.size },
appVersion = file.appVersion,
exportedAt = file.exportedAt,
)
}
/** Decrypt-if-encrypted / pass-through-if-plain, shared by import + preview. */
private fun payloadJson(bytes: ByteArray, passphrase: CharArray?): String {
if (!EncryptedBackupCodec.isEncrypted(bytes)) return String(bytes, Charsets.UTF_8)
val pass = passphrase
?: throw IllegalArgumentException("Encrypted backup requires a passphrase")
return EncryptedBackupCodec.decrypt(bytes, pass)
}
/**
* M2 task 3 dedupe key: `(createdAt, updatedAt, sha256(content))`.
* Every component survives export/import on both platforms, and the
* timestamps are only trustworthy for dedupe because the repository
* now honours caller-supplied values (M2 import-timestamp fix).
* NUL-separated so distinct field splits can never collide; the
* content rides as a SHA-256 digest to keep the compared set cheap.
*/
private fun keyFor(createdAt: Long, updatedAt: Long, content: String): String {
val digest = java.security.MessageDigest.getInstance("SHA-256")
.digest(content.toByteArray(Charsets.UTF_8))
val hex = digest.joinToString("") { "%02x".format(it) }
return "$createdAt\u0000$updatedAt\u0000$hex"
}
}
/** Outcome of [BackupBridge.import] — what a duplicate-safe import did. */
data class ImportSummary(val imported: Int, val skipped: Int)
/** Lightweight DTO shown in the import confirmation dialog. */
data class BackupPreview(
val noteCount: Int,
val attachmentCount: Int,
val appVersion: String,
val exportedAt: Long,
)
@@ -93,6 +93,9 @@ object BackupCodec {
bytes = decodeBase64(ba.bytesBase64),
mimeType = ba.mimeType,
displayName = ba.displayName,
// Restore the phone's attachment timestamp (M2:
// everything import claims to preserve must survive).
createdAt = ba.createdAt,
)
}
onProgress(idx + 1, total)
@@ -126,10 +129,12 @@ data class BackupNote(
val attachments: List<BackupAttachment> = emptyList(),
/** Preserve soft-delete state; defaults to false for older backups. */
val isTrashed: Boolean = false,
/** Preserve draft state; defaults to false for older backups. */
val isDraft: Boolean = false,
/**
* v0.3.8.0 — serialised as the [org.incido.domain.model.NoteType]
* enum name ("TEXT" / "TASK_LIST" / "SHOPPING_LIST"). Defaulted so
* pre-v0.3.8.0 backup files import as plain-text notes.
* enum name ("TEXT" / "TASK_LIST" / "SHOPPING_LIST" / "VOICE_NOTE").
* Defaulted so pre-v0.3.8.0 backup files import as plain-text notes.
*/
val noteType: String = "TEXT",
)
@@ -163,6 +168,7 @@ private suspend fun Note.toBackup(repository: NoteRepository): BackupNote {
isFavorite = isFavorite,
color = color.name,
isTrashed = isTrashed,
isDraft = isDraft,
noteType = type.name,
hashtags = hashtags,
attachments = backups,
@@ -180,6 +186,7 @@ private fun Note.toBackup(): BackupNote = BackupNote(
isFavorite = isFavorite,
color = color.name,
isTrashed = isTrashed,
isDraft = isDraft,
noteType = type.name,
hashtags = hashtags,
attachments = emptyList(),
@@ -193,6 +200,7 @@ private fun BackupNote.toDomain(): Note = Note(
isFavorite = isFavorite,
color = runCatching { NoteColor.valueOf(color) }.getOrDefault(NoteColor.NONE),
isTrashed = isTrashed,
isDraft = isDraft,
type = runCatching { NoteType.valueOf(noteType) }.getOrDefault(NoteType.TEXT),
hashtags = hashtags,
// Attachments are inserted separately by importSnapshot so they
+143
View File
@@ -0,0 +1,143 @@
// core/data-jvm — the DESKTOP build of the same data layer the Android app
// compiles (Development Plan §6, Phase 1 milestone M1a).
//
// Shape: sibling JVM module sharing :core:data's platform-neutral sources,
// NOT one multiplatform module. Two reasons, both proven in the Phase-0
// spike (tools/DESKTOP_FEASIBILITY.md):
// 1. ObjectBox's generator cannot read Kotlin common code, so entities have
// to be compiled per-target anyway.
// 2. objectbox-android and objectbox-java ship the same io.objectbox.*
// classes; keeping them in separate modules is what stops a duplicate
// classpath clash. Each module runs its own codegen and gets its own
// MyObjectBox.
// The shared model file is copied to objectbox-models/, and regenerating in a
// second module reports "ID model file unchanged" — no UID churn.
// The ObjectBox Gradle plugin publishes no plugin marker (same reason
// :core/data/build.gradle.kts wires it through a buildscript classpath).
buildscript {
repositories {
google()
mavenCentral()
}
dependencies {
classpath("io.objectbox:objectbox-gradle-plugin:${libs.versions.objectbox.get()}")
}
}
plugins {
alias(libs.plugins.kotlinJvm)
}
// SPIKE FINDING: `alias(libs.plugins.kotlinKapt)` fails here ("plugin is
// already on the classpath with an unknown version") because the root build
// already loads the Kotlin Gradle Plugin, which ships kapt. Applying by id
// reuses that copy.
apply(plugin = "org.jetbrains.kotlin.kapt")
apply(plugin = "io.objectbox")
java {
sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17
}
kotlin {
jvmToolchain(17)
}
sourceSets {
main {
kotlin.setSrcDirs(
listOf(
"build/generated/source/objectbox",
"src/main/kotlin",
// The platform-neutral data layer, compiled from :core:data's
// directory. Nothing in here may import android.*.
"../data/src/main/kotlin",
),
)
}
}
dependencies {
api(project(":core:domain"))
implementation(libs.kotlinx.coroutines.core)
// Phase 1 (M2): the backup bridge, for the backupSmoke round-trip probe.
// No classpath risk here — :core:backup carries no ObjectBox at all.
implementation(project(":core:backup"))
implementation(libs.kotlinx.serialization.json)
// Phase 1 (M4.4e): EXIF orientation for the JVM normalizer — the
// desktop counterpart of androidx.exifinterface that :core:data's
// Android side uses (§6.3 EXIF row: "not cached, Maven Central
// reachable" — pulled once here).
implementation(libs.metadata.extractor)
// JVM counterparts of the objectbox-android the Android build uses.
implementation(libs.objectbox.java)
implementation(libs.objectbox.kotlin)
// Native database library for the build/host OS. Declared explicitly so a
// packaged desktop app knows what it must bundle (objectbox-macos /
// objectbox-windows on other platforms).
runtimeOnly(libs.objectbox.linux)
}
/**
* `./gradlew :core:data-jvm:smoke` — boots the shared data layer against a
* real ObjectBox store on the JVM and round-trips a note. Temporary until
* :desktopApp provides the real entry point (Phase 1, M1b).
*/
tasks.register<JavaExec>("smoke") {
group = "verification"
description = "Opens a JVM ObjectBox store through the shared data layer."
classpath = sourceSets["main"].runtimeClasspath
mainClass.set("org.incido.data.jvm.StoreSmokeKt")
val smokeDir = layout.buildDirectory.dir("data-jvm-smoke").get().asFile
args = listOf(smokeDir.absolutePath)
// The probe asserts exact note counts, so it needs a virgin library —
// wipe the directory here to keep `smoke` idempotent across runs.
doFirst { smokeDir.deleteRecursively() }
}
/**
* `./gradlew :core:data-jvm:orientationSmoke` — Phase 1 (M4.4e): feeds a
* hand-crafted EXIF-Orientation-90 JPEG through JvmImageOrientationNormalizer
* and checks the rotation is baked into the pixels (Android contract kept).
*/
tasks.register<JavaExec>("orientationSmoke") {
group = "verification"
description = "Proves EXIF orientation handling on the JVM."
classpath = sourceSets["main"].runtimeClasspath
mainClass.set("org.incido.data.jvm.OrientationSmokeKt")
}
/**
* `./gradlew :core:data-jvm:backupSmoke --args="<backup.incido.json> [libDir]"`
* — feeds a REAL Android backup file through the :core:backup bridge on the
* JVM: preview, import into a fresh library, re-export and compare, then the
* encrypted-envelope path (including wrong-passphrase rejection). Runs
* against a fresh library every time (the script deletes libDir first).
*/
tasks.register<JavaExec>("backupSmoke") {
group = "verification"
description = "Round-trips a real Android backup export through BackupBridge on the JVM."
classpath = sourceSets["main"].runtimeClasspath
mainClass.set("org.incido.data.jvm.BackupRoundTripKt")
}
/**
* `./gradlew :core:data-jvm:backupMemory` — synthesizes worst-case
* libraries and samples heap peak during BackupBridge.exportPlain
* (Phase 1, M2 task 5: measure & record, no redesign). Needs a bigger
* heap than the other probes on purpose — the "watch tier" is ~320 MB of
* attachments and the bridge holds the whole JSON in memory by design.
*/
tasks.register<JavaExec>("backupMemory") {
group = "verification"
description = "Measures export heap peaks on synthesized worst-case libraries (M2 t5)."
classpath = sourceSets["main"].runtimeClasspath
mainClass.set("org.incido.data.jvm.BackupMemoryProbeKt")
maxHeapSize = "2g"
}
Binary file not shown.
+195
View File
@@ -0,0 +1,195 @@
{
"_note1": "KEEP THIS FILE! Check it into a version control system (VCS) like git.",
"_note2": "ObjectBox manages crucial IDs for your object model. See docs for details.",
"_note3": "If you have VCS merge conflicts, you must resolve them according to ObjectBox docs.",
"entities": [
{
"id": "1:2086366869756073512",
"lastPropertyId": "11:3900643584337280163",
"name": "NoteEntity",
"properties": [
{
"id": "1:504738300062779212",
"name": "id",
"type": 6,
"flags": 1
},
{
"id": "2:934725261850395537",
"name": "content",
"type": 9
},
{
"id": "3:7787800412489145126",
"name": "createdAt",
"indexId": "1:2377104061956606005",
"type": 6,
"flags": 8
},
{
"id": "4:7214601561419742071",
"name": "updatedAt",
"type": 6
},
{
"id": "5:8997711518431222149",
"name": "isFavorite",
"indexId": "2:2889322420050596277",
"type": 1,
"flags": 8
},
{
"id": "6:2157877161769308588",
"name": "colorKey",
"type": 3
},
{
"id": "7:9124062984393699059",
"name": "cipherVersion",
"type": 5
},
{
"id": "8:505259681403080579",
"name": "contentBlob",
"type": 23
},
{
"id": "9:2838488564098834737",
"name": "isTrashed",
"indexId": "7:9172152715891628247",
"type": 1,
"flags": 8
},
{
"id": "10:5547426387212371555",
"name": "typeKey",
"type": 3
},
{
"id": "11:3900643584337280163",
"name": "isDraft",
"indexId": "8:9185376899648223266",
"type": 1,
"flags": 8
}
],
"relations": []
},
{
"id": "2:2528940840759116824",
"lastPropertyId": "2:6290673541624313354",
"name": "HashtagEntity",
"properties": [
{
"id": "1:6991393863924167484",
"name": "id",
"type": 6,
"flags": 1
},
{
"id": "2:6290673541624313354",
"name": "name",
"indexId": "3:8935974229325273672",
"type": 9,
"flags": 2048
}
],
"relations": []
},
{
"id": "3:1814708994588042328",
"lastPropertyId": "3:4619895459374594011",
"name": "NoteHashtagCrossRef",
"properties": [
{
"id": "1:8394679598512920368",
"name": "id",
"type": 6,
"flags": 1
},
{
"id": "2:7132785913803437080",
"name": "noteId",
"indexId": "4:4609493987894622099",
"type": 6,
"flags": 8
},
{
"id": "3:4619895459374594011",
"name": "hashtagId",
"indexId": "5:4178528765644585892",
"type": 6,
"flags": 8
}
],
"relations": []
},
{
"id": "4:715630424595534313",
"lastPropertyId": "9:5604884960166980615",
"name": "NoteAttachmentEntity",
"properties": [
{
"id": "1:8895066388904375968",
"name": "id",
"type": 6,
"flags": 1
},
{
"id": "2:5099883303141941942",
"name": "noteId",
"indexId": "6:644263235201197567",
"type": 6,
"flags": 8
},
{
"id": "3:5923891227223085632",
"name": "mimeType",
"type": 9
},
{
"id": "4:5969004045087908818",
"name": "displayName",
"type": 9
},
{
"id": "5:1484939891319950467",
"name": "createdAt",
"type": 6
},
{
"id": "6:4541111239334797694",
"name": "sizeBytes",
"type": 6
},
{
"id": "7:5483350198068298485",
"name": "bytes",
"type": 23
},
{
"id": "8:6354828434115894982",
"name": "cipherVersion",
"type": 5
},
{
"id": "9:5604884960166980615",
"name": "bytesBlob",
"type": 23
}
],
"relations": []
}
],
"lastEntityId": "4:715630424595534313",
"lastIndexId": "8:9185376899648223266",
"lastRelationId": "0:0",
"lastSequenceId": "0:0",
"modelVersion": 5,
"modelVersionParserMinimum": 5,
"retiredEntityUids": [],
"retiredIndexUids": [],
"retiredPropertyUids": [],
"retiredRelationUids": [],
"version": 1
}
@@ -0,0 +1,46 @@
package org.incido.data
import io.objectbox.BoxStore
import java.io.File
import org.incido.data.entity.MyObjectBox
/**
* Desktop (JVM) counterpart of `:core:data`'s Android `ObjectBoxStore`.
*
* Deliberately the same fully-qualified name as the Android object: the two
* live in sibling modules that are never on one classpath, so shared code
* (repositories, services) refers to `org.incido.data.ObjectBoxStore` and each
* platform links its own implementation. The only real difference is how the
* store is located — Android hands ObjectBox a `Context`, desktop passes an
* explicit directory (XDG data dir in the desktop app).
*
* Encryption story is unchanged from Android: OSS ObjectBox 4.0.3 exposes no
* page-level encryption, so at-rest protection is the field cipher in
* `NoteRepositoryImpl` / `NoteCryptoService`; [encryptionKey] stays a no-op
* parameter for source compatibility.
*/
object ObjectBoxStore {
@Volatile
private var instance: BoxStore? = null
/** Open (or create) the library in [directory]. Idempotent. */
@Suppress("UNUSED_PARAMETER")
fun init(directory: File, encryptionKey: ByteArray? = null): BoxStore =
instance ?: synchronized(this) {
instance ?: MyObjectBox.builder()
.directory(directory)
.build()
.also { instance = it }
}
/** Close + drop the singleton (used by tests and store re-opens). */
fun reset() {
synchronized(this) {
instance?.close()
instance = null
}
}
fun get(): BoxStore =
instance ?: error("ObjectBoxStore not initialised — call init(directory) first")
}
@@ -0,0 +1,145 @@
package org.incido.data.jvm
import java.io.File
import java.io.FileOutputStream
import kotlin.random.Random
import kotlin.system.measureTimeMillis
import java.lang.management.ManagementFactory
import kotlinx.coroutines.runBlocking
import org.incido.compose.data.backup.BackupBridge
import org.incido.data.ImageOrientationNormalizer
import org.incido.data.ObjectBoxStore
import org.incido.data.crypto.CipherHolder
import org.incido.data.repository.NoteRepositoryImpl
import org.incido.domain.model.Note
import org.incido.domain.repository.NoteRepository
/**
* Phase 1 (M2 task 5): MEASURE the export path's memory on synthesized
* worst-case libraries — do not redesign it. The plan's gate: ~10–20
* notes with attachments must be trivial, 200+ with large attachments is
* "watch", and only a >250 MB peak forces the streaming-redesign
* discussion (which would be a formatVersion=2 change, Phase 2).
*
* The probe drives `BackupBridge.exportPlain` — the exact code the phone
* runs inside its `Uri → stream` shim — against three fresh ObjectBox
* libraries, sampling heap-used at 1 ms while the export runs.
*
* Run with `./gradlew :core:data-jvm:backupMemory` (2 GB ceiling set in
* the task; a tier that outruns it is itself the finding).
*/
private const val MB = 1024 * 1024
private class Tier(
val label: String,
val dirName: String,
val notes: Int,
/** One attachment each on the first N notes; 0 = no attachments. */
val attachmentsTotal: Int,
val attachmentMb: Int,
) {
val payloadMb: Long get() = notes * 1300L / MB + attachmentsTotal * attachmentMb.toLong()
}
/** 1 ms heap sampler; peak is the highest heap-used seen while running. */
private class HeapSampler : Runnable {
@Volatile var stop = false
@Volatile var peak = 0L
private val bean = ManagementFactory.getMemoryMXBean()
override fun run() {
while (!stop) {
val used = bean.heapMemoryUsage.used
if (used > peak) peak = used
try {
Thread.sleep(1)
} catch (_: InterruptedException) {
return
}
}
}
}
fun main() = runBlocking {
println("=== Incido Phase 1 M2 task 5: backup export memory (measure, don't redesign) ===")
println("heap ceiling : ${Runtime.getRuntime().maxMemory() / MB} MB (-Xmx of the backupMemory task)")
val libRoot = File("build/backup-memory").apply { deleteRecursively(); mkdirs() }
val tiers = listOf(
// Cheapest first so a failure in a later tier can't eat the findings.
Tier("phone-at-gate (20 notes, 3 att x 8 MB)", "t1-gate", 20, 3, 8),
Tier("many notes (2000 notes, no att)", "t2-count", 2000, 0, 0),
Tier("phone-heavy (100 notes, 10 att x 8 MB)", "t3-heavy", 100, 10, 8),
Tier("watch tier (200 notes, 40 att x 8 MB)", "t4-watch", 200, 40, 8),
)
for (tier in tiers) {
val dir = File(libRoot, tier.dirName).apply { mkdirs() }
val out = File(libRoot, "${tier.dirName}.out.json")
runCatching {
ObjectBoxStore.reset()
ObjectBoxStore.init(dir)
val repo: NoteRepository =
NoteRepositoryImpl(ObjectBoxStore.get(), CipherHolder(), ImageOrientationNormalizer.NoOp)
// Synthesize: fixed seed for repeatability; ~1.3 KB text per note.
val rnd = Random(42)
val ids = ArrayList<Long>(tier.notes)
repeat(tier.notes) { i ->
val content = (1..24).joinToString("\n") { "Note $i line $it — synthesized filler for the memory probe." }
val now = 1_700_000_000_000L + i * 1000L
val saved = repo.saveNoteWithHashtags(
note = Note(id = 0L, content = content, createdAt = now, updatedAt = now),
hashtagsToAdd = emptySet(),
hashtagsToRemove = emptySet(),
)
ids += saved.id
}
if (tier.attachmentMb > 0) {
val blob = ByteArray(tier.attachmentMb * MB)
repeat(tier.attachmentsTotal) { j ->
rnd.nextBytes(blob)
repo.addAttachment(
noteId = ids[j % ids.size],
bytes = blob,
mimeType = "image/jpeg",
displayName = "att-$j.jpg",
)
}
}
System.gc()
Thread.sleep(100)
val baseline = ManagementFactory.getMemoryMXBean().heapMemoryUsage.used
val sampler = HeapSampler()
val samplerThread = Thread(sampler).apply { isDaemon = true; start() }
val ms = measureTimeMillis {
BackupBridge.exportPlain(repo, FileOutputStream(out), "m2-memory-probe")
}
sampler.stop = true
samplerThread.join()
println(
"%s | data≈%d MB → export %d ms | heap peak %d MB (+%d MB alloc pressure) | file %d MB"
.format(
tier.label, tier.payloadMb, ms,
sampler.peak / MB, (sampler.peak - baseline) / MB, out.length() / MB,
),
)
}.onFailure {
println(
"%s | data≈%d MB → FAILED: %s: %s"
.format(tier.label, tier.payloadMb, it::class.java.simpleName, it.message),
)
}
out.delete()
ObjectBoxStore.reset()
dir.deleteRecursively()
}
val hwm = runCatching {
File("/proc/self/status").readLines().first { it.startsWith("VmHWM:") }
.filter(Char::isDigit).toLong() / 1024
}.getOrNull()
println("process peak RSS (VmHWM, incl. ObjectBox native): ${hwm ?: -1} MB")
println("verdict reference: plan gate = >250 MB forces streaming-redesign talk (formatVersion 2, Phase 2)")
println("=== backupMemory done ===")
}
@@ -0,0 +1,209 @@
package org.incido.data.jvm
import java.io.ByteArrayInputStream
import java.io.ByteArrayOutputStream
import java.io.File
import java.io.FileInputStream
import java.util.Base64
import kotlin.system.exitProcess
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.runBlocking
import org.incido.compose.data.backup.BackupBridge
import org.incido.compose.data.backup.BackupCodec
import org.incido.compose.data.backup.BackupFile
import org.incido.compose.data.backup.BackupNote
import org.incido.compose.data.backup.EncryptedBackupCodec
import org.incido.data.ImageOrientationNormalizer
import org.incido.data.ObjectBoxStore
import org.incido.data.crypto.CipherHolder
import org.incido.data.repository.NoteRepositoryImpl
import org.incido.domain.repository.NoteRepository
/**
* Phase 1 (M2) round-trip probe: runs a **real** `.incido.json` export
* produced by the Android app through the extracted `:core:backup`
* bridge on a plain JVM — import into a live ObjectBox library, re-export,
* and compare note-for-note (incl. attachment bytes), plus the encrypted
* envelope path with a wrong-passphrase rejection.
*
* Unlike `smoke`, this script deletes [libDir] up front — it always runs
* against a fresh library.
*
* Run with
* `./gradlew :core:data-jvm:backupSmoke --args="<backup.incido.json> [libDir]"`.
*/
fun main(args: Array<String>) {
val src = File(args.getOrNull(0) ?: error("usage: backupSmoke <backup.incido.json> [libDir]"))
require(src.isFile) { "backup file not found: $src" }
val libDir = File(args.getOrNull(1) ?: "build/backup-roundtrip").also {
it.deleteRecursively()
it.mkdirs()
}
println("=== Incido Phase 1 M2: backup bridge on the JVM (real Android export) ===")
println("source file : $src (${src.length()} bytes)")
val original = BackupCodec.decode(src.readText())
val origAttachments = original.notes.sumOf { it.attachments.size }
println(
"source : notes=${original.notes.size} attachments=$origAttachments " +
"orphanTags=${original.orphanedHashtags.size} app=${original.appVersion}",
)
var failures = 0
fun step(name: String, body: () -> String) {
print("${name.padEnd(32)} ")
runCatching(body)
.onSuccess { println("PASS — $it") }
.onFailure {
println("FAIL — ${it::class.java.simpleName}: ${it.message}")
failures++
}
}
// Fresh CharArray per use — the codecs zero the passphrase they consume.
fun pw(): CharArray = "RoundTrip passphrase #2026!".toCharArray()
fun repo(): NoteRepository =
NoteRepositoryImpl(ObjectBoxStore.get(), CipherHolder(), ImageOrientationNormalizer.NoOp)
step("preview (plain, no passphrase)") {
val p = BackupBridge.preview(FileInputStream(src)) ?: error("preview returned null")
require(p.noteCount == original.notes.size) { "noteCount=${p.noteCount}" }
require(p.attachmentCount == origAttachments) { "attachmentCount=${p.attachmentCount}" }
require(p.appVersion == original.appVersion) { "appVersion=${p.appVersion}" }
"notes=${p.noteCount} attachments=${p.attachmentCount} app=${p.appVersion}"
}
step("import into fresh JVM library") {
ObjectBoxStore.init(libDir)
val n = runBlocking { BackupBridge.import(repo(), FileInputStream(src)).imported }
require(n == original.notes.size) { "imported $n, expected ${original.notes.size}" }
val inStore = runBlocking { repo().observeAllIncludingTrashed().first().size }
require(inStore == original.notes.size) { "store holds $inStore" }
"imported $n notes, all readable back through the flow"
}
step("re-export plain == original") {
val out = ByteArrayOutputStream()
runBlocking { BackupBridge.exportPlain(repo(), out, "m2-roundtrip") }
val round = BackupCodec.decode(out.toString(Charsets.UTF_8))
val lostOrphans = original.orphanedHashtags.toSet() - round.orphanedHashtags.toSet()
compareNotes(original, round) +
" (orphan tags: ${round.orphanedHashtags.size}/${original.orphanedHashtags.size} recreated — " +
"importSnapshot has never restored orphans, pre-existing)" +
(if (lostOrphans.isEmpty()) "" else " [-$lostOrphans]")
}
var envelope = ByteArray(0)
step("encrypted export + wrong-pw reject") {
val out = ByteArrayOutputStream()
runBlocking { BackupBridge.exportEncrypted(repo(), out, pw(), "m2-roundtrip") }
envelope = out.toByteArray()
require(EncryptedBackupCodec.isEncrypted(envelope)) { "no INCDBK1 magic" }
val wrong = BackupBridge.preview(
ByteArrayInputStream(envelope),
"wrong wrong wrong #2026!".toCharArray(),
)
require(wrong == null) { "wrong passphrase was accepted!" }
"envelope=${envelope.size}B (json=${original.notes.size} notes), wrong passphrase → null"
}
step("import encrypted into 2nd library") {
ObjectBoxStore.reset()
val dir2 = File(libDir.absolutePath + "-enc").also { it.deleteRecursively(); it.mkdirs() }
ObjectBoxStore.init(dir2)
val n = runBlocking { BackupBridge.import(repo(), ByteArrayInputStream(envelope), pw()).imported }
require(n == original.notes.size) { "imported $n, expected ${original.notes.size}" }
val withAtt = runBlocking { repo().observeAllIncludingTrashed().first() }
.first { it.attachments.isNotEmpty() }
val bytes = runBlocking { repo().getAttachmentBytes(withAtt.attachments.single().id) }
?: error("attachment missing after encrypted import")
val expected = Base64.getDecoder()
.decode(original.notes.first { it.attachments.isNotEmpty() }.attachments.first().bytesBase64)
require(bytes.contentEquals(expected)) { "attachment bytes differ (${bytes.size} vs ${expected.size})" }
"imported $n notes; attachment ${bytes.size}B byte-identical to the phone's"
}
step("dedupe: re-import same file") {
ObjectBoxStore.reset()
val dir3 = File(libDir.absolutePath + "-dedupe").also { it.deleteRecursively(); it.mkdirs() }
ObjectBoxStore.init(dir3)
val first = runBlocking { BackupBridge.import(repo(), FileInputStream(src)) }
require(first.imported == original.notes.size && first.skipped == 0) { "first=$first" }
val again = runBlocking { BackupBridge.import(repo(), FileInputStream(src)) }
require(again.imported == 0 && again.skipped == original.notes.size) { "again=$again" }
// The override must still behave like the old additive import.
val forced = runBlocking { BackupBridge.import(repo(), FileInputStream(src), skipExisting = false) }
require(forced.imported == original.notes.size) { "forced=$forced" }
val count = runBlocking { repo().observeAllIncludingTrashed().first().size }
require(count == original.notes.size * 2) { "store holds $count after forced re-import" }
"re-import skipped=${again.skipped}; override added ${forced.imported} (store=$count)"
}
step("close libraries") {
ObjectBoxStore.reset()
"clean"
}
println()
println(
if (failures == 0) "RESULT: M2 round-trip PASS — a real Android export survives the desktop bridge."
else "RESULT: M2 round-trip FAIL — $failures step(s) failed.",
)
if (failures != 0) exitProcess(1)
}
/**
* Field-by-field comparison of two snapshots. Import forces fresh ids, so
* rows are paired positionally after sorting by the only stable keys every
* platform preserves: (createdAt, content). Attachments are paired the same
* way within each note and compared including their Base64 payload.
*/
private fun compareNotes(original: BackupFile, round: BackupFile): String {
require(round.notes.size == original.notes.size) {
"note count drifted: ${round.notes.size} != ${original.notes.size}"
}
fun List<BackupNote>.keyed() = sortedWith(
compareBy({ it.createdAt }, { it.content }),
)
val a = original.notes.keyed()
val b = round.notes.keyed()
a.forEachIndexed { i, want ->
val got = b[i]
val at = "note[$i] createdAt=${want.createdAt}"
if (got.content != want.content) {
val w = want.content
val g = got.content
val firstDiff = (0 until minOf(w.length, g.length)).firstOrNull { w[it] != g[it] }
error(
"$at: content differs at char $firstDiff " +
"(len ${w.length} vs ${g.length}) " +
"want=<${w.substring(maxOf(0, (firstDiff ?: 0) - 20), minOf(w.length, (firstDiff ?: 0) + 30)).replace("\n", "\\n")}> " +
"got=<${g.substring(maxOf(0, (firstDiff ?: 0) - 20), minOf(g.length, (firstDiff ?: 0) + 30)).replace("\n", "\\n")}>",
)
}
require(got.updatedAt == want.updatedAt) { "$at: updatedAt differs" }
require(got.isFavorite == want.isFavorite) { "$at: isFavorite differs" }
require(got.color == want.color) { "$at: color ${got.color} != ${want.color}" }
require(got.noteType == want.noteType) { "$at: noteType ${got.noteType} != ${want.noteType}" }
require(got.isTrashed == want.isTrashed) { "$at: isTrashed differs" }
require(got.isDraft == want.isDraft) { "$at: isDraft differs" }
require(got.hashtags.sorted() == want.hashtags.sorted()) {
"$at: hashtags ${got.hashtags.sorted()} != ${want.hashtags.sorted()}"
}
require(got.attachments.size == want.attachments.size) { "$at: attachment count differs" }
val sortKey = compareBy<org.incido.compose.data.backup.BackupAttachment>(
{ it.createdAt },
{ it.displayName },
)
val wa = want.attachments.sortedWith(sortKey)
val ga = got.attachments.sortedWith(sortKey)
wa.forEachIndexed { j, waJ ->
val gaJ = ga[j]
require(gaJ.mimeType == waJ.mimeType) { "$at.att[$j]: mimeType differs" }
require(gaJ.displayName == waJ.displayName) { "$at.att[$j]: displayName differs" }
require(gaJ.sizeBytes == waJ.sizeBytes) { "$at.att[$j]: sizeBytes differs" }
require(gaJ.createdAt == waJ.createdAt) { "$at.att[$j]: createdAt differs" }
require(gaJ.bytesBase64 == waJ.bytesBase64) { "$at.att[$j]: BYTES DIFFER" }
}
}
val attTotal = a.sumOf { it.attachments.size }
return "all ${a.size} notes + $attTotal attachments identical (content/times/fav/color/type/trash/draft/tags/bytes)"
}
@@ -0,0 +1,95 @@
package org.incido.data.jvm
import com.drew.imaging.ImageMetadataReader
import com.drew.metadata.exif.ExifIFD0Directory
import java.awt.geom.AffineTransform
import java.awt.image.BufferedImage
import java.io.ByteArrayInputStream
import java.io.ByteArrayOutputStream
import javax.imageio.IIOImage
import javax.imageio.ImageIO
import javax.imageio.ImageWriteParam
import kotlin.math.abs
import kotlin.math.roundToInt
import kotlin.math.sin
import org.incido.data.ImageOrientationNormalizer
/**
* Phase 1 (M4.4e) — JVM [ImageOrientationNormalizer], replacing the
* NoOp placeholder the §6.3 EXIF row deferred ("metadata-extractor not
* cached, Maven Central reachable — feasible in JVM impl").
*
* Same contract as `AndroidImageOrientationNormalizer`: read the EXIF
* Orientation tag, bake 90/180/270 rotations into the pixels, re-encode
* JPEG @ 0.92 so the stored bytes carry no orientation flag; return the
* input UNCHANGED when orientation is normal/absent, the image can't be
* decoded, or anything else goes wrong.
*
* Tooling differs, contract doesn't:
* - tag read: com.drewnoakes:metadata-extractor (the Central-side
* peer of androidx.exifinterface),
* - rotate: BufferedImage + AffineTransform (no android.graphics),
* - encode: ImageIO JPEG writer at explicit 0.92 quality (Android
* uses Bitmap.compress(JPEG, 92)).
*
* Like the Android side, only the rotate-90/180/270 orientations do
* work; the mirror orientations (2–5, 7) fall through unchanged there
* too, so behaviour matches tag-for-tag.
*/
class JvmImageOrientationNormalizer : ImageOrientationNormalizer {
override fun normalize(bytes: ByteArray): ByteArray = runCatching {
val metadata = ImageMetadataReader.readMetadata(ByteArrayInputStream(bytes))
val ifd0 = metadata.getFirstDirectoryOfType(ExifIFD0Directory::class.java)
?: return@runCatching bytes
if (ifd0.hasErrors()) return@runCatching bytes
val angle = when (ifd0.getInteger(ExifIFD0Directory.TAG_ORIENTATION)) {
6 -> 90
3 -> 180
8 -> 270
else -> return@runCatching bytes // normal, absent, or a mirror tag
}
val img = ImageIO.read(ByteArrayInputStream(bytes)) ?: return@runCatching bytes
val rotated = rotate(img, angle)
encodeJpeg(rotated)
}.getOrDefault(bytes)
private fun rotate(img: BufferedImage, degrees: Int): BufferedImage {
val radians = Math.toRadians(degrees.toDouble())
val sin = abs(sin(radians))
val cos = abs(kotlin.math.cos(radians))
val w = img.width
val h = img.height
val out = BufferedImage(
(sin * h + cos * w).roundToInt(),
(cos * h + sin * w).roundToInt(),
BufferedImage.TYPE_INT_RGB,
)
val g = out.createGraphics()
val tx = AffineTransform()
tx.translate(out.width / 2.0, out.height / 2.0)
tx.rotate(radians)
tx.translate(-w / 2.0, -h / 2.0)
g.drawImage(img, tx, null)
g.dispose()
return out
}
private fun encodeJpeg(img: BufferedImage): ByteArray {
val writer = ImageIO.getImageWritersByFormatName("jpeg").next()
try {
val params = (writer.defaultWriteParam as ImageWriteParam).apply {
setCompressionMode(ImageWriteParam.MODE_EXPLICIT)
compressionQuality = 0.92f // matches the Android side's compress(JPEG, 92)
}
val bos = ByteArrayOutputStream()
ImageIO.createImageOutputStream(bos).use { out ->
writer.output = out
writer.write(null, IIOImage(img, null, null), params)
}
return bos.toByteArray()
} finally {
writer.dispose()
}
}
}
@@ -0,0 +1,87 @@
package org.incido.data.jvm
import java.awt.image.BufferedImage
import java.io.ByteArrayInputStream
import java.io.ByteArrayOutputStream
import javax.imageio.ImageIO
import org.incido.data.ImageOrientationNormalizer
/**
* Phase 1 (M4.4e) — `./gradlew :core:data-jvm:orientationSmoke`.
*
* Proves [JvmImageOrientationNormalizer] end-to-end without needing a
* phone: hand-builds a JPEG whose EXIF Orientation tag says
* "rotate 90", feeds it through the same [ImageOrientationNormalizer]
* seam `NoteRepositoryImpl` stores images through, and checks the
* rotation was baked into the pixels (dimensions swapped) while a
* no-EXIF / garbage input comes back byte-identical — the exact
* contract the Android normalizer established.
*/
fun main() {
val normalizer = JvmImageOrientationNormalizer()
var failures = 0
fun check(name: String, ok: Boolean) {
println("EXIF ${if (ok) "PASS" else "FAIL"} $name")
if (!ok) failures++
}
// 4x2 base JPEG (deliberately non-square so a 90° rotation swaps
// the dimensions in an observable way).
val base = jpegOf(BufferedImage(4, 2, BufferedImage.TYPE_INT_RGB))
check("no-EXIF input returned unchanged", normalizer.normalize(base).contentEquals(base))
val tagged = injectExifOrientation90(base)
val normalized = normalizer.normalize(tagged)
check("EXIF-90 input was rewritten", !normalized.contentEquals(tagged))
val decoded = ImageIO.read(ByteArrayInputStream(normalized))
check(
"rotation baked into pixels (4x2 -> 2x4)",
decoded != null && decoded.width == 2 && decoded.height == 4,
)
// The stored bytes carry no orientation flag — a second pass must
// be a no-op (this is WHY the app bakes the rotation at store time).
check("normalized output is stable (no orientation flag left)", normalizer.normalize(normalized).contentEquals(normalized))
check("garbage input returned unchanged", normalizer.normalize(byteArrayOf(1, 2, 3)).contentEquals(byteArrayOf(1, 2, 3)))
if (failures == 0) {
println("RESULT: M4.4e PASS — EXIF orientation is honoured on the JVM (Android contract kept).")
} else {
println("RESULT: M4.4e FAIL — $failures check(s) failed.")
kotlin.system.exitProcess(1)
}
}
private fun jpegOf(img: BufferedImage): ByteArray {
val bos = ByteArrayOutputStream()
ImageIO.write(img, "jpeg", bos)
return bos.toByteArray()
}
/**
* Splice a minimal APP1/EXIF segment (big-endian TIFF, one IFD0 entry:
* 0x0112 Orientation = 6 → "rotate 90 CW") in right after the JPEG SOI
* marker. metadata-extractor is read-only, so the probe writes its own.
*/
private fun injectExifOrientation90(jpeg: ByteArray): ByteArray {
require(jpeg[0] == 0xFF.toByte() && jpeg[1] == 0xD8.toByte()) { "not a JPEG" }
val tiff = byteArrayOf(
'M'.code.toByte(), 'M'.code.toByte(), // big-endian
0x00, 0x2A, // TIFF magic
0x00, 0x00, 0x00, 0x08, // IFD0 at offset 8
0x00, 0x01, // one entry
0x01, 0x12, // tag: Orientation
0x00, 0x03, // type: SHORT
0x00, 0x00, 0x00, 0x01, // count: 1
0x00, 0x06, 0x00, 0x00, // value: 6 (rotate 90 CW)
0x00, 0x00, 0x00, 0x00, // no next IFD
)
val payload = "Exif".toByteArray(Charsets.US_ASCII) + byteArrayOf(0, 0) + tiff
val segmentLen = payload.size + 2
val segment = byteArrayOf(
0xFF.toByte(), 0xE1.toByte(),
(segmentLen ushr 8).toByte(), (segmentLen and 0xFF).toByte(),
) + payload
return jpeg.copyOfRange(0, 2) + segment + jpeg.copyOfRange(2, jpeg.size)
}
@@ -0,0 +1,102 @@
package org.incido.data.jvm
import java.io.File
import kotlin.system.exitProcess
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.runBlocking
import org.incido.data.ImageOrientationNormalizer
import org.incido.data.ObjectBoxStore
import org.incido.data.crypto.CipherHolder
import org.incido.data.repository.NoteRepositoryImpl
import org.incido.domain.model.Note
/**
* Phase 1 (M1a) smoke test: proves the platform-neutral data layer —
* `NoteRepositoryImpl`, the entity/codegen layer, and the repository's
* hashtag/attachment logic — runs unchanged on a plain JVM.
*
* Temporary scaffolding: replaced by the real `:desktopApp` entry point in
* M1b. Run with `./gradlew :core:data-jvm:smoke`.
*/
fun main(args: Array<String>) {
val dir = File(args.firstOrNull() ?: "build/data-jvm-smoke").also { it.mkdirs() }
println("=== Incido Phase 1 M1a: shared data layer on the JVM ===")
println("library dir : $dir")
var failures = 0
fun step(name: String, body: () -> String) {
print("${name.padEnd(30)} ")
runCatching(body)
.onSuccess { println("PASS — $it") }
.onFailure {
println("FAIL — ${it::class.java.simpleName}: ${it.message}")
failures++
}
}
val holder = CipherHolder()
step("open store (shared codegen)") {
// BoxStore.getName()/getStoreDirectory() exist only in the Android
// runtime; the JVM build just reports the directory it was given.
val store = ObjectBoxStore.init(dir)
"BoxStore built; ${store.javaClass.simpleName}"
}
val repo = NoteRepositoryImpl(ObjectBoxStore.get(), holder, ImageOrientationNormalizer.NoOp)
step("save note + hashtag") {
runBlocking {
repo.saveNoteWithHashtags(
note = Note(
id = 0L,
content = "M1a smoke note\nsecond line",
createdAt = System.currentTimeMillis(),
updatedAt = System.currentTimeMillis(),
isFavorite = true,
),
hashtagsToAdd = setOf("m1a"),
hashtagsToRemove = emptySet(),
)
}
"saved"
}
step("read back through observeAll") {
val notes = runBlocking { repo.observeAll().first() }
require(notes.size == 1) { "expected 1 note, got ${notes.size}" }
val n = notes.single()
require(n.isFavorite) { "favourite flag lost" }
require(n.hashtags.contains("m1a")) { "hashtag lost: ${n.hashtags}" }
"1 note, tags=${n.hashtags}, favorite=${n.isFavorite}"
}
step("attachment round-trip") {
val noteId = runBlocking { repo.observeAll().first().single().id }
val payload = ByteArray(2048) { (it % 97).toByte() }
val id = runBlocking {
repo.addAttachment(noteId, payload, "image/png", "shot.png")
}
val back = runBlocking { repo.getAttachmentBytes(id) }
?: error("attachment not readable")
require(back.contentEquals(payload)) { "attachment bytes differ (${back.size})" }
"id=$id, ${back.size} bytes identical"
}
step("close + reopen persists") {
ObjectBoxStore.reset()
val again = ObjectBoxStore.init(dir)
val count = runBlocking {
NoteRepositoryImpl(again, holder, ImageOrientationNormalizer.NoOp)
.observeAll().first().size
}
require(count == 1) { "expected 1 note after reopen, got $count" }
"note survived close/reopen"
}
ObjectBoxStore.reset()
println()
println(
if (failures == 0) "RESULT: M1a PASS — the shared data layer runs on the JVM."
else "RESULT: M1a FAIL — $failures step(s) failed.",
)
if (failures != 0) exitProcess(1)
}
+13 -3
View File
@@ -41,9 +41,19 @@ android {
sourceSets {
getByName("main") {
// ObjectBox generates a MyObjectBox class at build time; expose
// the generated sources directory.
kotlin.srcDirs("build/generated/source/objectbox")
// NOTE: srcDirs() *replaces* the set, so every directory this
// module compiles has to be listed here.
kotlin.srcDirs(
// ObjectBox generates a MyObjectBox class at build time.
"build/generated/source/objectbox",
// Phase 1 (M1a): the platform-neutral data layer. The SAME
// directory is compiled by :core:data-jvm for the desktop
// build — it must contain no android.* imports.
"src/main/kotlin",
// Android-only implementations of the platform seams
// (Context-based store bootstrap, EXIF rotation).
"src/androidMain/kotlin",
)
}
}
}
+195
View File
@@ -0,0 +1,195 @@
{
"_note1": "KEEP THIS FILE! Check it into a version control system (VCS) like git.",
"_note2": "ObjectBox manages crucial IDs for your object model. See docs for details.",
"_note3": "If you have VCS merge conflicts, you must resolve them according to ObjectBox docs.",
"entities": [
{
"id": "1:2086366869756073512",
"lastPropertyId": "11:3900643584337280163",
"name": "NoteEntity",
"properties": [
{
"id": "1:504738300062779212",
"name": "id",
"type": 6,
"flags": 1
},
{
"id": "2:934725261850395537",
"name": "content",
"type": 9
},
{
"id": "3:7787800412489145126",
"name": "createdAt",
"indexId": "1:2377104061956606005",
"type": 6,
"flags": 8
},
{
"id": "4:7214601561419742071",
"name": "updatedAt",
"type": 6
},
{
"id": "5:8997711518431222149",
"name": "isFavorite",
"indexId": "2:2889322420050596277",
"type": 1,
"flags": 8
},
{
"id": "6:2157877161769308588",
"name": "colorKey",
"type": 3
},
{
"id": "7:9124062984393699059",
"name": "cipherVersion",
"type": 5
},
{
"id": "8:505259681403080579",
"name": "contentBlob",
"type": 23
},
{
"id": "9:2838488564098834737",
"name": "isTrashed",
"indexId": "7:9172152715891628247",
"type": 1,
"flags": 8
},
{
"id": "10:5547426387212371555",
"name": "typeKey",
"type": 3
},
{
"id": "11:3900643584337280163",
"name": "isDraft",
"indexId": "8:9185376899648223266",
"type": 1,
"flags": 8
}
],
"relations": []
},
{
"id": "2:2528940840759116824",
"lastPropertyId": "2:6290673541624313354",
"name": "HashtagEntity",
"properties": [
{
"id": "1:6991393863924167484",
"name": "id",
"type": 6,
"flags": 1
},
{
"id": "2:6290673541624313354",
"name": "name",
"indexId": "3:8935974229325273672",
"type": 9,
"flags": 2048
}
],
"relations": []
},
{
"id": "3:1814708994588042328",
"lastPropertyId": "3:4619895459374594011",
"name": "NoteHashtagCrossRef",
"properties": [
{
"id": "1:8394679598512920368",
"name": "id",
"type": 6,
"flags": 1
},
{
"id": "2:7132785913803437080",
"name": "noteId",
"indexId": "4:4609493987894622099",
"type": 6,
"flags": 8
},
{
"id": "3:4619895459374594011",
"name": "hashtagId",
"indexId": "5:4178528765644585892",
"type": 6,
"flags": 8
}
],
"relations": []
},
{
"id": "4:715630424595534313",
"lastPropertyId": "9:5604884960166980615",
"name": "NoteAttachmentEntity",
"properties": [
{
"id": "1:8895066388904375968",
"name": "id",
"type": 6,
"flags": 1
},
{
"id": "2:5099883303141941942",
"name": "noteId",
"indexId": "6:644263235201197567",
"type": 6,
"flags": 8
},
{
"id": "3:5923891227223085632",
"name": "mimeType",
"type": 9
},
{
"id": "4:5969004045087908818",
"name": "displayName",
"type": 9
},
{
"id": "5:1484939891319950467",
"name": "createdAt",
"type": 6
},
{
"id": "6:4541111239334797694",
"name": "sizeBytes",
"type": 6
},
{
"id": "7:5483350198068298485",
"name": "bytes",
"type": 23
},
{
"id": "8:6354828434115894982",
"name": "cipherVersion",
"type": 5
},
{
"id": "9:5604884960166980615",
"name": "bytesBlob",
"type": 23
}
],
"relations": []
}
],
"lastEntityId": "4:715630424595534313",
"lastIndexId": "8:9185376899648223266",
"lastRelationId": "0:0",
"lastSequenceId": "0:0",
"modelVersion": 5,
"modelVersionParserMinimum": 5,
"retiredEntityUids": [],
"retiredIndexUids": [],
"retiredPropertyUids": [],
"retiredRelationUids": [],
"version": 1
}
@@ -0,0 +1,50 @@
package org.incido.data
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.graphics.Matrix
import androidx.exifinterface.media.ExifInterface
import java.io.ByteArrayInputStream
import java.io.ByteArrayOutputStream
/**
* Android [ImageOrientationNormalizer].
*
* v0.3.1.2 — rotate [bytes] to match the EXIF Orientation tag, then
* re-encode as JPEG so the stored bytes carry no orientation flag
* (downstream renderers — editor thumbnail, card thumbnail, viewer —
* all decode raw pixels without honouring EXIF, so the rotation is
* baked into the bitmap at storage time). Returns the input unchanged
* when the orientation is normal, the bitmap can't be decoded, or the
* rotation fails for any reason.
*
* Behaviour is byte-for-byte the code that lived in
* `NoteRepositoryImpl.normalizeImageOrientation` before the Phase-1 M1a
* platform split; only the enclosing type changed.
*/
class AndroidImageOrientationNormalizer : ImageOrientationNormalizer {
override fun normalize(bytes: ByteArray): ByteArray {
val bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.size) ?: return bytes
val angle = ExifInterface(ByteArrayInputStream(bytes))
.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
.let {
when (it) {
ExifInterface.ORIENTATION_ROTATE_90 -> 90f
ExifInterface.ORIENTATION_ROTATE_180 -> 180f
ExifInterface.ORIENTATION_ROTATE_270 -> 270f
else -> 0f
}
}
if (angle == 0f) return bytes
val matrix = Matrix().apply { postRotate(angle) }
val rotated = Bitmap.createBitmap(bmp, 0, 0, bmp.width, bmp.height, matrix, true)
bmp.recycle()
val out = ByteArrayOutputStream().use { baos ->
rotated.compress(Bitmap.CompressFormat.JPEG, 92, baos)
rotated.recycle()
baos.toByteArray()
}
return out
}
}
@@ -0,0 +1,26 @@
package org.incido.data
/**
* Phase 1 (M1a) platform seam for image normalisation.
*
* The Android app rotates inbound JPEGs against their EXIF Orientation tag
* at storage time, because every render path (card thumbnail, editor
* thumbnail, full-screen viewer) decodes raw pixels without honouring EXIF.
* That behaviour is Android-specific (`Bitmap` + `androidx.exifinterface`),
* so it is injected here and the repository stays platform-neutral.
*
* Android passes `AndroidImageOrientationNormalizer` (`:core:data`).
* Desktop currently passes [NoOp]; a JVM implementation (EXIF parse +
* re-encode) is milestone M4 — see tools/DESKTOP_FEASIBILITY.md.
*/
interface ImageOrientationNormalizer {
/** Return the bytes that should be stored for this image. */
fun normalize(bytes: ByteArray): ByteArray
companion object {
/** Stores inbound images exactly as received. */
val NoOp: ImageOrientationNormalizer = object : ImageOrientationNormalizer {
override fun normalize(bytes: ByteArray): ByteArray = bytes
}
}
}
@@ -1,14 +1,13 @@
package org.incido.compose.data.security
package org.incido.data.crypto
import java.security.SecureRandom
import javax.crypto.Cipher
import javax.crypto.spec.GCMParameterSpec
import javax.crypto.spec.SecretKeySpec
import org.incido.data.crypto.FieldCipher
/**
* v0.3.5.0: AES-256-GCM implementation of [FieldCipher] backed by the
* Keystore-wrapped 32-byte key owned by [ObjectBoxKeyProvider].
* 32-byte key served by a [FieldKeyProvider].
*
* This is what actually makes "Encrypt in place" work: note content
* and attachment blobs are stored as
@@ -23,9 +22,14 @@ import org.incido.data.crypto.FieldCipher
* primitives (public-key exchange / signatures) are not used here.
*
* The key bytes are cached for the process lifetime (they already live
* in memory whenever [ObjectBoxKeyProvider] unwraps them at startup).
* in memory whenever the provider serves them at startup — Keystore
* unwrap on Android, key-file read on desktop).
*
* Phase 1 (M3 task 2): moved from :composeApp into the shared data layer
* behind the [FieldKeyProvider] seam — the class itself never touched
* Android APIs, only the key source did. Compiled for BOTH platforms.
*/
class AesGcmFieldCipher(keyProvider: ObjectBoxKeyProvider) : FieldCipher {
class AesGcmFieldCipher(keyProvider: FieldKeyProvider) : FieldCipher {
private val keyBytes: ByteArray = keyProvider.getOrCreateKey()
private val secretKey = SecretKeySpec(keyBytes, "AES")
@@ -1,4 +1,4 @@
package org.incido.compose.data.security
package org.incido.data.crypto
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
@@ -8,8 +8,6 @@ import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import org.incido.data.crypto.EncryptionVerification
import org.incido.data.crypto.NoteCryptoService
/**
* v0.3.5.0: runs the note-encryption integrity check and exposes the
@@ -0,0 +1,24 @@
package org.incido.data.crypto
/**
* Phase 1 (M3 task 2): the platform seam the field cipher is built on.
*
* [AesGcmFieldCipher] only ever needs "the 32-byte field key, get it or
* make one" — everything else about where the key lives is platform
* territory:
*
* - Android: `ObjectBoxKeyProvider` (Keystore-wrapped key persisted in
* DataStore) is passed as `objectBoxKeyProvider::getOrCreateKey`.
* - Desktop: a JVM key provider (M3 task 3) reads/generates a `0600`
* key file, or installs the key imported through an
* [org.incido.compose.data.backup.EncryptedKeyCodec] recovery
* envelope.
*
* Declared `fun interface` so both platforms can pass a plain function
* reference / lambda instead of a class.
*/
fun interface FieldKeyProvider {
/** Return the 32-byte field key, creating and persisting one if none
* exists yet. Idempotent; blocking by design (startup call site). */
fun getOrCreateKey(): ByteArray
}
@@ -43,6 +43,8 @@ data class NoteEntity(
@Index var isTrashed: Boolean = false,
/** v0.3.8.0 — [org.incido.domain.model.NoteType] storage key (0 text, 1 task, 2 shopping). */
var typeKey: Short = 0,
/** True while a new note is being drafted; only the Drafts view shows these rows. */
@Index var isDraft: Boolean = false,
) {
override fun equals(other: Any?): Boolean {
if (this === other) return true
@@ -57,6 +59,7 @@ data class NoteEntity(
if (cipherVersion != other.cipherVersion) return false
if (!contentBlob.contentEquals(other.contentBlob)) return false
if (typeKey != other.typeKey) return false
if (isDraft != other.isDraft) return false
return true
}
@@ -71,6 +74,7 @@ data class NoteEntity(
result = 31 * result + cipherVersion.hashCode()
result = 31 * result + contentBlob.contentHashCode()
result = 31 * result + typeKey.hashCode()
result = 31 * result + isDraft.hashCode()
return result
}
}
@@ -84,6 +88,7 @@ internal fun NoteEntity.toDomain(): Note = Note(
color = NoteColor.fromStorageKey(colorKey),
isTrashed = isTrashed,
type = NoteType.fromStorageKey(typeKey),
isDraft = isDraft,
)
internal fun Note.toEntity(): NoteEntity = NoteEntity(
@@ -95,4 +100,5 @@ internal fun Note.toEntity(): NoteEntity = NoteEntity(
colorKey = color.storageKey,
isTrashed = isTrashed,
typeKey = type.storageKey,
isDraft = isDraft,
)
@@ -1,15 +1,9 @@
package org.incido.data.repository
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.graphics.Matrix
import androidx.exifinterface.media.ExifInterface
import io.objectbox.BoxStore
import io.objectbox.kotlin.boxFor
import io.objectbox.query.QueryBuilder
import io.objectbox.reactive.DataSubscription
import java.io.ByteArrayInputStream
import java.io.ByteArrayOutputStream
import java.util.concurrent.Callable
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.Flow
@@ -17,6 +11,7 @@ import kotlinx.coroutines.flow.callbackFlow
import kotlinx.coroutines.flow.flowOn
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.incido.data.ImageOrientationNormalizer
import org.incido.data.crypto.CIPHER_VERSION_AES_GCM
import org.incido.data.crypto.CIPHER_VERSION_PLAIN
import org.incido.data.crypto.CipherHolder
@@ -34,6 +29,7 @@ import org.incido.domain.model.Hashtag
import org.incido.domain.model.HashtagUsage
import org.incido.domain.model.Note
import org.incido.domain.model.NoteAttachment
import org.incido.domain.model.NoteColor
import org.incido.domain.model.NoteType
import org.incido.domain.repository.NoteRepository
@@ -63,6 +59,13 @@ import org.incido.domain.repository.NoteRepository
class NoteRepositoryImpl(
private val boxStore: BoxStore,
private val cipherHolder: CipherHolder = CipherHolder(),
/**
* Phase 1 (M1a): EXIF rotation is applied by the platform that owns an
* image decoder, so the repository itself compiles for Android *and* the
* desktop JVM build. Required (no default) on purpose — a missing
* implementation must fail the build, not silently store rotated JPEGs.
*/
private val orientationNormalizer: ImageOrientationNormalizer,
) : NoteRepository {
private val fieldCipher get() = cipherHolder.cipher
@@ -119,6 +122,45 @@ class NoteRepositoryImpl(
awaitClose { sub.cancel() }
}.flowOn(Dispatchers.Default)
override fun observeDrafts(): Flow<List<Note>> = callbackFlow {
trySend(snapshotDrafts())
val sub = noteBox.query()
.equal(NoteEntity_.isDraft, true)
.build()
.subscribe()
.observer { trySend(snapshotDrafts()) }
awaitClose { sub.cancel() }
}.flowOn(Dispatchers.Default)
override fun searchDrafts(query: String): Flow<List<Note>> = callbackFlow {
trySend(snapshotDraftsSearch(query))
val sub = noteBox.query().build().subscribe().observer {
trySend(snapshotDraftsSearch(query))
}
awaitClose { sub.cancel() }
}.flowOn(Dispatchers.Default)
override fun observeByColor(color: NoteColor): Flow<List<Note>> = callbackFlow {
trySend(snapshotByColor(color))
// Kotlin stubs expose only equal(Property, Long) for integer
// columns — widen the Short storage key (ObjectBox integer
// columns are width-agnostic, so the match is exact).
val sub = noteBox.query()
.equal(NoteEntity_.colorKey, color.storageKey.toLong())
.build()
.subscribe()
.observer { trySend(snapshotByColor(color)) }
awaitClose { sub.cancel() }
}.flowOn(Dispatchers.Default)
override fun searchByColor(query: String, color: NoteColor): Flow<List<Note>> = callbackFlow {
trySend(snapshotByColorSearch(query, color))
val sub = noteBox.query().build().subscribe().observer {
trySend(snapshotByColorSearch(query, color))
}
awaitClose { sub.cancel() }
}.flowOn(Dispatchers.Default)
override fun observeNotesForHashtag(name: String): Flow<List<Note>> = callbackFlow {
trySend(snapshotForHashtag(name))
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotForHashtag(name)) }
@@ -208,6 +250,7 @@ class NoteRepositoryImpl(
bytes: ByteArray,
mimeType: String,
displayName: String,
createdAt: Long,
): Long {
// v0.3.1.2 — honour the EXIF Orientation tag on inbound images
// (camera intent usually writes landscape pixels + an EXIF
@@ -215,7 +258,7 @@ class NoteRepositoryImpl(
// (editor thumbnail, card thumbnail, full-screen viewer) sees
// the photo the right way up. Non-images pass through unchanged.
val storedBytes: ByteArray = if (mimeType.startsWith("image/")) {
withContext(Dispatchers.IO) { normalizeImageOrientation(bytes) }
withContext(Dispatchers.IO) { orientationNormalizer.normalize(bytes) }
} else {
bytes
}
@@ -223,7 +266,9 @@ class NoteRepositoryImpl(
noteId = noteId,
mimeType = mimeType,
displayName = displayName,
createdAt = System.currentTimeMillis(),
// IMPORT FIX (Phase 1, M2): backup import supplies the phone's
// original timestamp; 0 keeps the old "now" behaviour.
createdAt = createdAt.takeIf { it != 0L } ?: System.currentTimeMillis(),
sizeBytes = storedBytes.size.toLong(),
bytes = storedBytes,
)
@@ -318,6 +363,7 @@ class NoteRepositoryImpl(
private fun contentMatchingNoteIds(
query: String,
includeTrashed: Boolean = false,
includeDrafts: Boolean = false,
): List<Long> {
val q = query.trim()
if (q.isEmpty()) return emptyList()
@@ -332,13 +378,15 @@ class NoteRepositoryImpl(
noteBox.all.filter { toReadable(it).content.lowercase().contains(needle) }
}
return candidates
.filter { it.isTrashed == includeTrashed }
.filter {
it.isTrashed == includeTrashed && (includeDrafts || !it.isDraft)
}
.map { it.id }
}
/** IDs of rows eligible for all active-note queries. */
/** IDs of rows eligible for all active-note queries (never trashed, never drafts). */
private fun activeNoteIds(): Set<Long> =
noteBox.all.filter { !it.isTrashed }.mapTo(HashSet()) { it.id }
noteBox.all.filter { !it.isTrashed && !it.isDraft }.mapTo(HashSet()) { it.id }
/** IDs of tags currently used by at least one active note. */
private fun activeTagIds(): Set<Long> {
@@ -374,7 +422,7 @@ class NoteRepositoryImpl(
.build()
.find()
.mapNotNull { ref -> noteBox.get(ref.noteId) }
.filter { it.isTrashed == includeTrashed }
.filter { it.isTrashed == includeTrashed && !it.isDraft }
.map { it.id }
}
@@ -382,37 +430,10 @@ class NoteRepositoryImpl(
}
/**
* v0.3.1.2 — rotate [bytes] to match the EXIF Orientation tag, then
* re-encode as JPEG so the stored bytes have no orientation flag
* (downstream renderers — editor thumbnail, card thumbnail, viewer
* — all decode raw pixels without honouring EXIF, so we bake the
* rotation into the bitmap at storage time). Returns the input
* unchanged when the orientation is normal, the bitmap can't be
* decoded, or the rotation fails for any reason.
* v0.3.1.2 EXIF rotation now lives behind [ImageOrientationNormalizer]
* (Phase 1, M1a) — see `AndroidImageOrientationNormalizer` in
* `core/data/src/androidMain`.
*/
private fun normalizeImageOrientation(bytes: ByteArray): ByteArray {
val bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.size) ?: return bytes
val angle = ExifInterface(ByteArrayInputStream(bytes))
.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
.let {
when (it) {
ExifInterface.ORIENTATION_ROTATE_90 -> 90f
ExifInterface.ORIENTATION_ROTATE_180 -> 180f
ExifInterface.ORIENTATION_ROTATE_270 -> 270f
else -> 0f
}
}
if (angle == 0f) return bytes
val matrix = Matrix().apply { postRotate(angle) }
val rotated = Bitmap.createBitmap(bmp, 0, 0, bmp.width, bmp.height, matrix, true)
bmp.recycle()
val out = ByteArrayOutputStream().use { baos ->
rotated.compress(Bitmap.CompressFormat.JPEG, 92, baos)
rotated.recycle()
baos.toByteArray()
}
return out
}
override suspend fun removeAttachment(id: Long) {
attachmentBox.remove(id)
@@ -425,7 +446,15 @@ class NoteRepositoryImpl(
override suspend fun upsert(note: Note): Note {
val now = System.currentTimeMillis()
val toPersist = if (note.id == 0L) {
note.copy(createdAt = now, updatedAt = now).toEntity()
// IMPORT FIX (Phase 1, M2): a caller that supplies a real
// createdAt/updatedAt (backup import must — they are the dedupe
// key and the user's own history) is honoured; 0 still means
// "now". The Android editor already stamps both fields itself,
// so this only changes the import path.
note.copy(
createdAt = note.createdAt.takeIf { it != 0L } ?: now,
updatedAt = note.updatedAt.takeIf { it != 0L } ?: now,
).toEntity()
} else {
note.copy(updatedAt = now).toEntity()
}
@@ -453,11 +482,47 @@ class NoteRepositoryImpl(
}
}
/**
* "Empty Trash": permanently delete every trashed row with the
* exact same cascade as [delete] — note row, hashtag cross-links,
* and attachment rows (their blobs live inside the attachment
* entities, so removing the row frees them too).
*/
override suspend fun deleteAllTrashed() {
val trashedIds: LongArray = noteBox.query()
.equal(NoteEntity_.isTrashed, true)
.build()
.find()
.map { it.id }
.toLongArray()
if (trashedIds.isEmpty()) return
noteBox.remove(*trashedIds)
trashedIds.forEach { id ->
val orphanXrefs: List<NoteHashtagCrossRef> = xrefBox.query()
.equal(NoteHashtagCrossRef_.noteId, id)
.build()
.find()
if (orphanXrefs.isNotEmpty()) {
xrefBox.remove(*orphanXrefs.map { it.id }.toLongArray())
}
val orphanAttachments: List<NoteAttachmentEntity> = attachmentBox.query()
.equal(NoteAttachmentEntity_.noteId, id)
.build()
.find()
if (orphanAttachments.isNotEmpty()) {
attachmentBox.remove(*orphanAttachments.map { it.id }.toLongArray())
}
}
}
/** Soft-delete only changes state; the row, links, and blobs remain intact. */
override suspend fun softDelete(id: Long) {
val entity = noteBox.get(id) ?: return
if (entity.isTrashed) return
entity.isTrashed = true
// A trashed draft comes back as a normal note on Restore — the
// draft lifecycle ends the moment it moves to Trash.
entity.isDraft = false
// `put` is intentional here: content may be ciphertext already,
// so do not pass it through toWritable and encrypt the ciphertext a
// second time. Only the additive flag is changing.
@@ -492,7 +557,12 @@ class NoteRepositoryImpl(
): Note {
val now = System.currentTimeMillis()
val toPersist = if (note.id == 0L) {
note.copy(createdAt = now, updatedAt = now).toEntity()
// IMPORT FIX (Phase 1, M2): honour caller-supplied timestamps
// (backup import) — see the matching change in upsert().
note.copy(
createdAt = note.createdAt.takeIf { it != 0L } ?: now,
updatedAt = note.updatedAt.takeIf { it != 0L } ?: now,
).toEntity()
} else {
note.copy(updatedAt = now).toEntity()
}
@@ -603,11 +673,15 @@ class NoteRepositoryImpl(
private fun decorate(
entities: List<NoteEntity>,
includeTrashed: Boolean? = false,
includeDrafts: Boolean = false,
): List<Note> {
val tags = hashtagsByNoteId()
val attachments = attachmentsByNoteId()
return entities
.filter { includeTrashed == null || it.isTrashed == includeTrashed }
.filter {
(includeTrashed == null || it.isTrashed == includeTrashed) &&
(includeDrafts || !it.isDraft)
}
.sortedWith(
compareByDescending<NoteEntity> { it.isFavorite }
.thenByDescending { it.updatedAt },
@@ -636,7 +710,8 @@ class NoteRepositoryImpl(
private fun snapshotAll(): List<Note> = decorate(noteBox.all)
private fun snapshotAllIncludingTrashed(): List<Note> = decorate(noteBox.all, includeTrashed = null)
private fun snapshotAllIncludingTrashed(): List<Note> =
decorate(noteBox.all, includeTrashed = null, includeDrafts = true)
private fun snapshotSearch(query: String): List<Note> {
val allIds = matchingNoteIds(query, includeTrashed = false)
@@ -661,6 +736,66 @@ class NoteRepositoryImpl(
return decorate(trashedEntities, includeTrashed = true)
}
private fun snapshotDrafts(): List<Note> {
val draftEntities: List<NoteEntity> = noteBox.query()
.equal(NoteEntity_.isDraft, true)
.build()
.find()
return decorate(draftEntities, includeTrashed = null, includeDrafts = true)
}
/**
* Content search restricted to drafts (tag-name matches are not
* folded in, mirroring the plain-text scope of the Drafts view).
*/
private fun snapshotDraftsSearch(query: String): List<Note> {
val q = query.trim()
if (q.isEmpty()) return snapshotDrafts()
val draftIds: Set<Long> = noteBox.query()
.equal(NoteEntity_.isDraft, true)
.build()
.find()
.mapTo(HashSet()) { it.id }
val matches: List<Long> = contentMatchingNoteIds(
q,
includeTrashed = false,
includeDrafts = true,
).filter { it in draftIds }
val entities: List<NoteEntity> = matches.mapNotNull { noteBox.get(it) }
return decorate(entities, includeTrashed = null, includeDrafts = true)
}
/**
* Active notes of one accent colour. The colour query already
* excludes nothing on trash state, so `decorate` (default
* `includeTrashed = false`) drops trashed rows exactly like
* [snapshotFavorites] / [snapshotUntagged] do.
*/
private fun snapshotByColor(color: NoteColor): List<Note> {
val colorEntities: List<NoteEntity> = noteBox.query()
.equal(NoteEntity_.colorKey, color.storageKey.toLong())
.build()
.find()
return decorate(colorEntities)
}
/**
* Context-aware search across notes of [color] only. Blank [query]
* degrades to [snapshotByColor]. Otherwise runs the same content +
* hashtag-name matching as [snapshotFavoritesSearch] and intersects
* with the colour (never trashed rows — matchingNoteIds already
* excludes them via includeTrashed = false).
*/
private fun snapshotByColorSearch(query: String, color: NoteColor): List<Note> {
val q = query.trim()
if (q.isEmpty()) return snapshotByColor(color)
val allIds: Set<Long> = matchingNoteIds(q, includeTrashed = false)
if (allIds.isEmpty()) return emptyList()
val entities: List<NoteEntity> = allIds.mapNotNull { id -> noteBox.get(id) }
.filter { it.colorKey == color.storageKey }
return decorate(entities)
}
private fun snapshotUntagged(): List<Note> {
val activeIds = activeNoteIds()
val noteIdsWithTags: Set<Long> = xrefBox.all
+34 -8
View File
@@ -1,19 +1,45 @@
// core/domain — pure-Kotlin domain module (no Android dependencies).
// Contains business types and repository interfaces only.
// Implementation lives in :core:data.
//
// Phase 1 (M4.2): converted kotlin("jvm") → kotlin("multiplatform") with
// androidTarget() + jvm(), per the Phase-0 recommendation ("core:domain is
// already JVM-clean — convert it first. Zero code changes"). This is what
// lets a KMP module's commonMain (composeApp) depend on it — plain
// kotlin("jvm") modules are invisible to commonMain. Existing plain-JVM
// (:core:data-jvm, :desktopApp) and AGP (:core:data, :app, :composeApp)
// consumers keep working through the variant metadata — zero import
// changes anywhere.
plugins {
alias(libs.plugins.kotlinJvm)
}
java {
sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17
alias(libs.plugins.androidLibrary)
alias(libs.plugins.kotlinMultiplatform)
}
kotlin {
jvmToolchain(17)
androidTarget()
jvm()
sourceSets {
commonMain.dependencies {
// Flow/StateFlow appear in the public repository interfaces.
api(libs.kotlinx.coroutines.core)
}
}
}
dependencies {
implementation(libs.kotlinx.coroutines.core)
android {
namespace = "org.incido.domain"
compileSdk = 35
defaultConfig {
minSdk = 26
}
compileOptions {
sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17
}
}
Loaded 100 of 134 files, more files were not shown because too many files have changed in this diff. Show more