feat: v0.3.0.0 — hashtags (visible on editor) + bolder colour accent + centred title + nav drawer + new version scheme

v0.3.0.0 bundles four user-facing features, the plan-compliance polish
that was deferred from v0.2, and a permanent change to how we name
releases going forward.

VERSION SCHEME (app/build.gradle.kts)
  - versionName = '0.3.0.0' (MAJOR.MINOR.MAINTENANCE.EMERGENCY)
  - versionCode = 5
  - New gradle taskGraph validator fails the build if versionName
    doesn't match ^\d+\.\d+\.\d+\.\d+$ — we can't accidentally
    regress the scheme.
  - History re-keyed across README, Plan §10, CONTRIBUTING.md.

HASHTAGS
  - value class Hashtag (domain/model) with normalise/parseOrNull
    helpers; pattern: ^[a-z0-9][a-z0-9._-]{0,30}$
  - data class HashtagUsage (name, noteCount, lastUsedAt)
  - sealed class NoteFilter { Home, Favorites, Untagged, ByTag(name) }
  - Note gains hashtags: List<String> (sorted ascending)
  - Repository:
      - new entities HashtagEntity (@Index on name) and
        NoteHashtagCrossRef (many-to-many junction)
      - new methods: observeFavorites / observeUntagged /
        observeNotesForHashtag / observeHashtagsByRecentUse /
        observeAllHashtags / searchHashtags / addHashtag / removeHashtag
      - search() now matches content OR hashtag-name (case-insensitive)
      - ObjectBox queries use explicit StringOrder + type annotations
        (kapt's stubs are finicky around Property<String> overloads)

UI
  - CenterAlignedTopAppBar on both list and editor screens
  - List:
      - Hamburger top-left opens a ModalNavigationDrawer (Home /
        Favorites / Untagged / divider / scrollable Recent tags)
      - Drawer selection drives a NoteFilter state held at root
      - Search bar visible only when filter == Home
      - NoteCard redesign — 14 dp vertical gradient stripe +
        tinted surface (12 % colour blend) + 10 dp corner chip
      - Empty-state copy is filter-aware
  - Editor:
      - Persistent hashtag chip row above the text field
      - Tag # icon in the top bar + '+ add' chip opens a ModalBottomSheet
      - Autocomplete suggestions live from repository.searchHashtags
      - '+ Create name' button when the typed value is valid + new
      - Snackbar 'Maximum 5 tags reached.' when the cap is hit
      - Reconciled on save via addHashtag / removeHashtag diff

DOCS
  - README v0.3.0.0 section + re-keyed changelog
  - Development Plan §10 history re-keyed (0.1.0.0 / 0.1.1.0 /
    0.2.0.0 / 0.2.0.1 / 0.3.0.0)
  - CONTRIBUTING.md release-process note updated for the new scheme

VERIFIED
  - ./gradlew assembleDebug assembleRelease both green
  - Debug 25.7 MB, release 19.8 MB (v2-signed)
  - versionCode=5, versionName='0.3.0.0'
  - No INTERNET permission
  - Validator regression: setting versionName='0.3' causes
    assembleDebug to fail with the new scheme error message
This commit is contained in:
Incido Developer committed 2026-08-15 02:02:53 +12:00
1 parent 84900838f7
commit d616ce3021
20 files changed
+1256 -222

No files matched your search

+13 -5
View File
@@ -140,10 +140,18 @@ under AGPL-3.0 before opening the PR.
## Release process (for maintainers) ## Release process (for maintainers)
1. Bump `versionCode` + `versionName` in `app/build.gradle.kts`. > **Version scheme (from v0.3.0.0 onwards):** `MAJOR.MINOR.MAINTENANCE.EMERGENCY` —
2. Update the Development Plan §10 history table. > e.g. `0.3.0.0`. `MAJOR.MINOR.MAINTENANCE` are normal release numbers;
3. Tag the commit: `git tag -s vX.Y.Z -m "vX.Y.Z — short summary"`. > `EMERGENCY` is non-zero only for hotfixes shipped out-of-band.
4. `./gradlew assembleRelease` → upload APK to Gitea Releases. > `versionCode` is a monotonic int and always +1 per release.
5. Push the tag: `git push origin vX.Y.Z`. > A build with a `versionName` that doesn't match `^\d+\.\d+\.\d+\.\d+$`
> 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.
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.
6. Push the tag: `git push origin vX.Y.Z.W`.
Thanks again for contributing! 🙏 Thanks again for contributing! 🙏
+11 -4
View File
@@ -361,12 +361,19 @@ A short reference for AI assistants:
## 10. Document History ## 10. Document History
> **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;
> `EMERGENCY` is non-zero only for hotfixes shipped out-of-band.
> `versionCode` is a monotonic int and always +1 per release.
> The build refuses to compile if `versionName` doesn't match this shape.
| Version | Date | Notes | | Version | Date | Notes |
|---------|------|-------| |---------|------|-------|
| 0.1 | 2026-08-14 | Initial plan drafted via interview | | 0.1.0.0 | 2026-08-14 | Initial plan drafted via interview |
| 0.1.1 | 2026-08-14 | Added F1 explicit "list of currently saved notes" requirement + F7 auto-refresh + clarified UI section | | 0.1.1.0 | 2026-08-14 | F1 explicit "list of currently saved notes" requirement + F7 auto-refresh + clarified UI section + editor IME fix (contentWindowInsets + adjustResize) + title/body on cards |
| 0.1.1 | 2026-08-14 | Editor IME fix (Scaffold contentWindowInsets + adjustResize) + title/body display on list cards | | 0.2.0.0 | 2026-08-14 | Polish + first Keep-parity features. Discard-confirm dialog; release signing config (dev keystore). Favorites (renamed from Pinned Notes), full-text search, 6 colour-coded notes, inline GFM checklists (open/done counts). ObjectBox KMP migration deferred to v0.5 (tracked). |
| 0.2 | 2026-08-14 | Polish + first Keep-parity features. Discard-confirm dialog; release signing config (dev keystore). Favorites (renamed from Pinned Notes), full-text search, 6 colour-coded notes, inline GFM checklists (open/done counts). ObjectBox KMP migration deferred to v0.5 (tracked). | | 0.2.0.1 | 2026-08-14 | Hotfix: search-active flag folded into uiState so the search icon actually opens the field. |
| 0.3.0.0 | 2026-08-14 | Hashtags (separate entity + cross-ref, 5-tag cap, autocomplete, persistent chips on editor, search() also matches tag names) + bolder colour accent (14 dp gradient stripe + tinted card background + corner chip) + nav drawer (Home / Favorites / Untagged + recent tags) + centred app-bar title + new version scheme adopted (validator in app/build.gradle.kts). |
--- ---
+85 -43
View File
@@ -6,48 +6,82 @@ 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 All data stays on your device by default — no accounts, no cloud, no
trackers. trackers.
This repository contains the **v0.2** release: a single-user, offline note This repository contains the **v0.3.0.0** release: a single-user, offline
app with favourites, full-text search, colour-coded notes, and inline note app with hashtags, favourites, full-text search, colour-coded
checklists. The architecture is multi-module Android today and is notes, and a navigation drawer. The architecture is multi-module Android
structured so iOS / Desktop ports can happen later without UI rewrites. today and is structured so iOS / Desktop ports can happen later without
UI rewrites.
**Current release:** v0.2 (see [Changelog](#changelog) below). **Current release:** v0.3.0.0 (see [Changelog](#changelog) below).
> **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;
> `EMERGENCY` is non-zero only for hotfixes shipped out-of-band.
> `versionCode` is a monotonic int and always +1 per release.
> An empty MAINTENANCE/EMERGENCY slot is written as `0`.
> The build refuses to compile if `versionName` doesn't match this shape.
--- ---
## Features ## Features
### v0.2 highlights ### v0.3.0.0 highlights
- **Hashtags.** Tag any note with up to 5 hashtags. Tags are always
visible as chips above the editor text field; tap ✕ to remove. Tap
`#` (or `+ add`) to open a sheet with autocomplete suggestions from
your existing tags. Hashtags are searchable from the list (typing
`work` finds notes containing the word *and* notes tagged `#work`).
- **Bolder colour accent on list cards.** Each colour-tagged note now
gets a 14 dp vertical gradient stripe on the left, a subtle 12 %
tinted card background, and a 10 dp solid colour chip in the
top-right — so different-coloured notes are visually distinct at a
glance without you needing to focus on the stripe.
- **Navigation drawer.** Hamburger top-left opens a drawer with
**Home**, **Favorites**, **Untagged**, a divider, then a live scrollable
list of the most-recently-used hashtags. Tap any entry to filter the
list to just those notes.
- **Centred app-bar title.** Both the list screen (`Incido`) and the
editor (`Edit note` / `New note`) now centre their titles via
Material 3's `CenterAlignedTopAppBar`.
- **New version scheme.** All version bumps from now on follow the
`MAJOR.MINOR.MAINTENANCE.EMERGENCY` pattern; the build refuses anything
that doesn't match.
### v0.2.0.0
- **Favourites.** Tap the star icon on any card to pin it to the top of - **Favourites.** Tap the star icon on any card to pin it to the top of
the list. (Replaces the §6.1 "Pinned Notes" item; renamed per the list.
maintainer request.)
- **Full-text search.** Tap the search icon in the top app bar; the list - **Full-text search.** Tap the search icon in the top app bar; the list
filters live as you type. Backed by ObjectBox's `contains` query — filters live as you type.
case-insensitive, no extra dependencies.
- **Color-coded notes.** Pick from six preset accent colours in the - **Color-coded notes.** Pick from six preset accent colours in the
editor (none / blue / green / amber / red / purple). Each list card editor; each list card gets a 4 dp vertical stripe.
gets a 4dp vertical stripe on the left edge. - **Inline checklists.** Lines beginning with `- [ ]` or `- [x]` show
- **Inline checklists.** Lines beginning with `- [ ]` or `- [x]` are open/done counts on the card preview.
parsed; the card preview shows the open/done counts (e.g.
"2 open · 1 done"). No DB schema migration — the text stays plain.
- **Discard-confirm dialog.** Closing the editor with unsaved changes - **Discard-confirm dialog.** Closing the editor with unsaved changes
now prompts "Discard changes?" with Discard / Keep-editing buttons. prompts `Discard changes?` (works for both Back arrow and hardware
Applies to both the Back arrow and the hardware back gesture. back gesture).
- **Release signing** — dev keystore in `keystore/`, `assembleRelease`
produces a v2-signed APK out of the box.
### v0.1.1 polish ### v0.2.0.1 (hotfix)
- **Editor respects the soft keyboard.** With edge-to-edge enabled, the - **Search icon actually opens the search bar.** v0.2.0.0's
editor's `Scaffold` unions `WindowInsets.systemBars` with search-active flag was on a separate `StateFlow` the composable never
`WindowInsets.ime`, so the text field automatically shrinks above the observed; folded into `uiState` so tapping the icon now lights up the
keyboard instead of being hidden behind it. `adjustResize` is also set field.
on `MainActivity` as a pre-Android-15 fallback.
- **List cards now show a title + body preview.** The first non-empty line
of a note is treated as its title and rendered in a larger / bolder
style; the remainder is shown as an abbreviated preview below it
(max 2 lines, ellipsised). Empty notes display as "Untitled".
### v0.1.0 (original MVP) ### v0.1.1.0
- **Editor respects the soft keyboard.** `Scaffold` unions
`WindowInsets.systemBars` with `WindowInsets.ime` so the text field
shrinks above the keyboard. `adjustResize` set as pre-Android-15
fallback.
- **List cards now show a title + body preview.** First non-empty line
= title; remainder = body preview (max 2 lines, ellipsised).
Empty notes display as "Untitled".
### v0.1.0.0
- Create, edit, and delete plain-text notes - Create, edit, and delete plain-text notes
- ObjectBox-backed persistence ([objectbox.io](https://objectbox.io/)) - ObjectBox-backed persistence ([objectbox.io](https://objectbox.io/))
@@ -68,10 +102,12 @@ cross-platform ports, end-to-end sync, and security features.
## Changelog ## Changelog
| Version | Date | Highlights | | Version | Date | Highlights |
|---------|------|------------| |-----------|------------|------------|
| 0.1 | 2026-08-14 | First MVP: list + editor, ObjectBox, Material 3 | | 0.1.0.0 | 2026-08-14 | First MVP: list + editor, ObjectBox, Material 3 |
| 0.1.1 | 2026-08-14 | Editor IME fix + title/body on list cards | | 0.1.1.0 | 2026-08-14 | Editor IME fix + title/body on list cards |
| 0.2 | 2026-08-14 | Polish + favourites, search, colours, checklists, discard dialog, release signing | | 0.2.0.0 | 2026-08-14 | Polish + favourites, search, colours, checklists, discard dialog, release signing |
| 0.2.0.1 | 2026-08-14 | Hotfix: search icon now actually opens the search bar |
| 0.3.0.0 | 2026-08-14 | Hashtags (visible chips on editor, 5-tag cap, autocomplete) + bolder colour accent + nav drawer (Home / Favorites / Untagged + recent tags) + centred app-bar title + new version scheme |
--- ---
@@ -154,6 +190,10 @@ Uses the dev keystore at `keystore/release.jks` — see
**Replace this keystore with a production key before any external **Replace this keystore with a production key before any external
distribution.** distribution.**
The build will **fail** if `versionName` doesn't match
`^\d+\.\d+\.\d+\.\d+$` (the new scheme). Update `app/build.gradle.kts`
to fix.
### 5. Install on a device ### 5. Install on a device
```bash ```bash
@@ -187,19 +227,21 @@ After the first push:
--- ---
## Manual Smoke Test (Development Plan §7.2 + v0.2 additions) ## Manual Smoke Test (Development Plan §7.2 + v0.3.0.0 additions)
``` ```
[ ] Launch app — see empty state message ("No notes yet. Tap + to start.") [ ] Launch app — "Incido" title centred, hamburger top-left
[ ] Tap FAB — editor opens, cursor in text field [ ] Tap hamburger → drawer slides in with Home / Favorites / Untagged + divider + Recent tags
[ ] Type "Test note 1" — tap save — returns to list, "Test note 1" card visible [ ] Tap "Favorites" → list shows only starred notes
[ ] Tap star on card 1 — it floats to the top [ ] Tap "Untagged" → list shows only notes with zero hashtags
[ ] Tap search icon — type "Test" — only matching card remains [ ] Tap a recent hashtag → list filters to that tag
[ ] Close search — full list returns, favourite still on top [ ] Tap "Home" → back to all notes
[ ] Edit "Test note 2" → tap a colour swatch → save → card shows coloured stripe [ ] Open a note → chip row above text field shows current tags (empty placeholder if none)
[ ] Create a note with "- [ ] milk\n- [x] eggs" → card preview shows "1 open · 1 done" [ ] Tap "#" icon → sheet opens, type "wo" → suggestions filter
[ ] Open a note → type extra content → tap Back → discard dialog appears [ ] Add a new tag → chip appears, counter goes from N/5 to (N+1)/5
[ ] Force-stop app from system settings, reopen → all notes + favourites still present [ ] Tap chip ✕ → removed
[ ] Add 5 tags, attempt 6th → Snackbar "Maximum 5 tags reached"
[ ] Force-stop + reopen → all notes + hashtags + favourites + colours persist
``` ```
--- ---
+32 -17
View File
@@ -1,6 +1,17 @@
// :app — Android application entry point. Hosts MainActivity and the // :app — Android application entry point. Hosts MainActivity and the
// application manifest, including the launcher icon and theme. // application manifest, including the launcher icon and theme.
import java.io.FileInputStream //
// Version scheme (v0.3.0.0 onwards):
// versionName = "MAJOR.MINOR.MAINTENANCE.EMERGENCY"
// - MAJOR: large breaking redesigns (rare in v0.x)
// - MINOR: normal feature releases
// - MAINTENANCE: bug fixes / refactors on a given MINOR
// - EMERGENCY: 0 in normal releases; non-zero only for hotfixes
// shipped out-of-band (e.g. v0.2.0.1 — search-icon fix)
// versionCode: monotonic int. Always +1 per release.
//
// The validator below fails the build if versionName doesn't match the
// required dotted format, so we can't regress the scheme by accident.
import java.util.Properties import java.util.Properties
plugins { plugins {
@@ -17,22 +28,13 @@ android {
applicationId = "org.incido.app" applicationId = "org.incido.app"
minSdk = 26 minSdk = 26
targetSdk = 35 targetSdk = 35
versionCode = 3 versionCode = 5
versionName = "0.2" versionName = "0.3.0.0"
} }
// --- Signing --- // --- Signing ---
//
// v0.2 introduces a real release signing config so `./gradlew
// assembleRelease` produces an installable APK out of the box. The
// keystore file itself is gitignored — see keystore/README.md for
// generation instructions and for the (deliberately weak) dev
// passwords baked into this build script. **Replace with a real
// production keystore before publishing.**
signingConfigs { signingConfigs {
create("release") { create("release") {
// Resolve paths relative to the project root so the same
// config works from both Android Studio and CLI.
val keystoreFilePath = rootProject.file("keystore/release.jks") val keystoreFilePath = rootProject.file("keystore/release.jks")
if (keystoreFilePath.exists()) { if (keystoreFilePath.exists()) {
storeFile = keystoreFilePath storeFile = keystoreFilePath
@@ -40,9 +42,6 @@ android {
keyAlias = "incido" keyAlias = "incido"
keyPassword = "incido_dev_keystore" keyPassword = "incido_dev_keystore"
} }
// If the keystore doesn't exist, the release build will fail
// with a clear "Keystore file not set for signing config
// release" message — by design.
} }
} }
@@ -51,7 +50,7 @@ android {
isMinifyEnabled = false isMinifyEnabled = false
} }
release { release {
isMinifyEnabled = false // TODO(v0.3): enable R8 isMinifyEnabled = false // TODO(v0.3.0.0+): enable R8
signingConfig = signingConfigs.getByName("release") signingConfig = signingConfigs.getByName("release")
} }
} }
@@ -81,7 +80,6 @@ dependencies {
implementation(libs.androidx.core.ktx) implementation(libs.androidx.core.ktx)
implementation(libs.kotlinx.coroutines.android) implementation(libs.kotlinx.coroutines.android)
// Compose BOM keeps all Compose artefact versions aligned
val composeBom = platform(libs.composeBom) val composeBom = platform(libs.composeBom)
implementation(composeBom) implementation(composeBom)
@@ -89,3 +87,20 @@ dependencies {
implementation(libs.compose.ui) implementation(libs.compose.ui)
implementation(libs.compose.material3) implementation(libs.compose.material3)
} }
// --- Version-name scheme validator ---
//
// MAJOR.MINOR.MAINTENANCE.EMERGENCY — exactly four dotted integers.
// Fails fast so we can't accidentally publish a "0.3" again.
val versionScheme = Regex("""^\d+\.\d+\.\d+\.\d+$""")
gradle.taskGraph.whenReady {
val vn = android.defaultConfig.versionName
if (vn != null && !versionScheme.matches(vn)) {
throw GradleException(
"app versionName = \"$vn\" doesn't match the required " +
"MAJOR.MINOR.MAINTENANCE.EMERGENCY scheme (e.g. 0.3.0.0). " +
"Update app/build.gradle.kts."
)
}
}
@@ -1,30 +1,94 @@
package org.incido.compose package org.incido.compose
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.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
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.lifecycle.compose.collectAsStateWithLifecycle
import androidx.navigation.NavType import androidx.navigation.NavType
import androidx.navigation.compose.NavHost import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable import androidx.navigation.compose.composable
import androidx.navigation.compose.currentBackStackEntryAsState
import androidx.navigation.compose.rememberNavController import androidx.navigation.compose.rememberNavController
import androidx.navigation.navArgument import androidx.navigation.navArgument
import kotlinx.coroutines.launch
import org.incido.compose.ui.drawer.IncidoDrawer
import org.incido.compose.ui.editor.NoteEditorScreen import org.incido.compose.ui.editor.NoteEditorScreen
import org.incido.compose.ui.notelist.NoteListScreen import org.incido.compose.ui.notelist.NoteListScreen
import org.incido.compose.ui.theme.IncidoTheme import org.incido.compose.ui.theme.IncidoTheme
import org.incido.domain.model.NoteFilter
/** Top-level navigation destinations. */ /** Top-level navigation destinations. */
private object Routes { private object Routes {
const val LIST = "list" const val LIST = "list"
const val EDITOR = "editor/{noteId}" const val EDITOR = "editor/{noteId}"
fun editor(noteId: Long?): String = fun editor(noteId: Long?): String = "editor/${noteId ?: -1L}"
"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
startsWith("tag:") -> NoteFilter.ByTag(this.removePrefix("tag:"))
else -> NoteFilter.Home
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable @Composable
fun IncidoApp() { fun IncidoApp() {
IncidoTheme { IncidoTheme {
val navController = rememberNavController() 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) }
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()
}
ModalNavigationDrawer(
drawerState = drawerState,
gesturesEnabled = isListRoute,
drawerContent = {
IncidoDrawer(
currentFilter = filterMode,
onSelectFilter = { picked ->
filterMode = picked
scope.launch { drawerState.close() }
},
)
},
) {
NavHost(navController = navController, startDestination = Routes.LIST) { NavHost(navController = navController, startDestination = Routes.LIST) {
composable(Routes.LIST) { composable(Routes.LIST) {
NoteListScreen( NoteListScreen(
filterMode = filterMode,
onOpenDrawer = { scope.launch { drawerState.open() } },
onOpenEditor = { id -> navController.navigate(Routes.editor(id)) }, onOpenEditor = { id -> navController.navigate(Routes.editor(id)) },
) )
} }
@@ -47,3 +111,9 @@ fun IncidoApp() {
} }
} }
} }
}
// 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()
@@ -0,0 +1,42 @@
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.domain.model.HashtagUsage
import org.incido.domain.repository.NoteRepository
/**
* Tiny ViewModel the navigation drawer uses to source its "Recent
* tags" list. Kept separate from [NoteListViewModel] because the
* drawer may render even before the list screen is created (and
* vice-versa).
*/
class DrawerViewModel(
repository: NoteRepository,
) : ViewModel() {
val recentHashtags: StateFlow<List<HashtagUsage>> =
repository.observeHashtagsByRecentUse()
.stateIn(
scope = viewModelScope,
started = SharingStarted.WhileSubscribed(5_000),
initialValue = emptyList(),
)
companion object {
val Factory: ViewModelProvider.Factory = viewModelFactory {
initializer {
val app = this[APPLICATION_KEY] as IncidoApplication
DrawerViewModel(app.container.noteRepository)
}
}
}
}
@@ -0,0 +1,145 @@
package org.incido.compose.ui.drawer
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
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.rememberScrollState
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.Star
import androidx.compose.material.icons.filled.Tag
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.ModalDrawerSheet
import androidx.compose.material3.NavigationDrawerItem
import androidx.compose.material3.NavigationDrawerItemDefaults
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
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.domain.model.HashtagUsage
import org.incido.domain.model.NoteFilter
/**
* Left-side navigation drawer. Top section has three fixed entries
* (Home / Favorites / Untagged); a `HorizontalDivider`; then a live
* scrollable list of the user's most-recently-used hashtags.
*
* Tapping any entry calls [onSelectFilter] and the caller (root) is
* responsible for closing the drawer.
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun IncidoDrawer(
currentFilter: NoteFilter,
onSelectFilter: (NoteFilter) -> Unit,
modifier: Modifier = Modifier,
viewModel: DrawerViewModel = viewModel(factory = DrawerViewModel.Factory),
) {
val recent by viewModel.recentHashtags.collectAsStateWithLifecycle()
ModalDrawerSheet(modifier = modifier) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 16.dp, vertical = 12.dp),
) {
Text(
text = "Incido",
style = MaterialTheme.typography.headlineSmall,
color = MaterialTheme.colorScheme.primary,
fontWeight = FontWeight.SemiBold,
modifier = Modifier.padding(start = 12.dp, top = 4.dp, bottom = 16.dp),
)
NavigationDrawerItem(
label = { Text("Home") },
selected = currentFilter == NoteFilter.Home,
onClick = { onSelectFilter(NoteFilter.Home) },
icon = { Icon(Icons.Filled.Home, contentDescription = null) },
)
NavigationDrawerItem(
label = { Text("Favorites") },
selected = currentFilter == NoteFilter.Favorites,
onClick = { onSelectFilter(NoteFilter.Favorites) },
icon = { Icon(Icons.Filled.Star, contentDescription = null) },
)
NavigationDrawerItem(
label = { Text("Untagged") },
selected = currentFilter == NoteFilter.Untagged,
onClick = { onSelectFilter(NoteFilter.Untagged) },
icon = { Icon(Icons.Filled.LabelOff, contentDescription = null) },
)
HorizontalDivider(modifier = Modifier.padding(vertical = 12.dp))
Text(
text = "Recent tags",
style = MaterialTheme.typography.labelLarge,
color = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.padding(start = 12.dp, bottom = 4.dp),
)
if (recent.isEmpty()) {
Text(
text = "No tags yet — add some from the editor.",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.padding(horizontal = 12.dp, vertical = 8.dp),
)
} else {
Column(
modifier = Modifier
.fillMaxWidth()
.verticalScroll(rememberScrollState()),
verticalArrangement = Arrangement.spacedBy(2.dp),
) {
recent.forEach { usage ->
DrawerHashtagEntry(
usage = usage,
selected = currentFilter == NoteFilter.ByTag(usage.name),
onClick = { onSelectFilter(NoteFilter.ByTag(usage.name)) },
)
}
}
}
Spacer(modifier = Modifier.height(16.dp))
}
}
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun DrawerHashtagEntry(
usage: HashtagUsage,
selected: Boolean,
onClick: () -> Unit,
) {
NavigationDrawerItem(
label = { Text("#${usage.name}") },
badge = {
val n = usage.noteCount
val label = if (n == 1) "1 note" else "$n notes"
Text(label, style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
},
selected = selected,
onClick = onClick,
icon = { Icon(Icons.Filled.Tag, contentDescription = null) },
)
}
@Suppress("unused")
private val _ignored: Color = Color.Unspecified
@@ -7,7 +7,8 @@ import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.WindowInsets import androidx.compose.foundation.layout.WindowInsets
import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.fillMaxWidth
@@ -21,28 +22,39 @@ import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.text.KeyboardOptions import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.Delete import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.Done import androidx.compose.material.icons.filled.Done
import androidx.compose.material.icons.filled.MoreVert import androidx.compose.material.icons.filled.MoreVert
import androidx.compose.material.icons.filled.Star import androidx.compose.material.icons.filled.Star
import androidx.compose.material.icons.filled.Tag
import androidx.compose.material.icons.outlined.StarOutline import androidx.compose.material.icons.outlined.StarOutline
import androidx.compose.material3.AlertDialog import androidx.compose.material3.AlertDialog
import androidx.compose.material3.AssistChip
import androidx.compose.material3.AssistChipDefaults
import androidx.compose.material3.CenterAlignedTopAppBar
import androidx.compose.material3.DropdownMenu import androidx.compose.material3.DropdownMenu
import androidx.compose.material3.DropdownMenuItem import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.ModalBottomSheet
import androidx.compose.material3.OutlinedTextField import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Scaffold import androidx.compose.material3.Scaffold
import androidx.compose.material3.SnackbarHost
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.SuggestionChip
import androidx.compose.material3.Text import androidx.compose.material3.Text
import androidx.compose.material3.TextButton import androidx.compose.material3.TextButton
import androidx.compose.material3.TopAppBar import androidx.compose.material3.rememberModalBottomSheetState
import androidx.compose.runtime.Composable import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier import androidx.compose.ui.Modifier
@@ -54,9 +66,14 @@ import androidx.compose.ui.text.input.KeyboardCapitalization
import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel import androidx.lifecycle.viewmodel.compose.viewModel
import kotlinx.coroutines.launch
import org.incido.compose.ui.theme.AllNoteColors
import org.incido.compose.ui.theme.swatchBorderColor
import org.incido.compose.ui.theme.toComposeColor
import org.incido.domain.model.Hashtag
import org.incido.domain.model.NoteColor import org.incido.domain.model.NoteColor
@OptIn(ExperimentalMaterial3Api::class) @OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
@Composable @Composable
fun NoteEditorScreen( fun NoteEditorScreen(
noteId: Long?, noteId: Long?,
@@ -70,6 +87,8 @@ fun NoteEditorScreen(
val focusRequester = remember { FocusRequester() } val focusRequester = remember { FocusRequester() }
var menuExpanded by remember { mutableStateOf(false) } var menuExpanded by remember { mutableStateOf(false) }
var showDiscardDialog by rememberSaveable { mutableStateOf(false) } var showDiscardDialog by rememberSaveable { mutableStateOf(false) }
val snackbarHost = remember { SnackbarHostState() }
val scope = rememberCoroutineScope()
LaunchedEffect(state.isLoading) { LaunchedEffect(state.isLoading) {
if (!state.isLoading && state.existing != null) { if (!state.isLoading && state.existing != null) {
@@ -80,12 +99,21 @@ fun NoteEditorScreen(
if (noteId == null) focusRequester.requestFocus() if (noteId == null) focusRequester.requestFocus()
} }
LaunchedEffect(state.snackbar) {
val msg = state.snackbar ?: return@LaunchedEffect
scope.launch {
snackbarHost.showSnackbar(msg)
viewModel.consumeSnackbar()
}
}
fun isDirty(): Boolean { fun isDirty(): Boolean {
if (state.isLoading) return false if (state.isLoading) return false
return state.isDirty( return state.isDirty(
initialContent = viewModel.initialContent, initialContent = viewModel.initialContent,
initialFavorite = viewModel.initialFavorite, initialFavorite = viewModel.initialFavorite,
initialColor = viewModel.initialColor, initialColor = viewModel.initialColor,
initialTags = viewModel.initialHashtags,
) )
} }
@@ -93,7 +121,6 @@ fun NoteEditorScreen(
if (isDirty()) showDiscardDialog = true else onClose() if (isDirty()) showDiscardDialog = true else onClose()
} }
// Intercept hardware / gesture back to honour the same discard rule.
BackHandler(enabled = true) { tryClose() } BackHandler(enabled = true) { tryClose() }
if (showDiscardDialog) { if (showDiscardDialog) {
@@ -118,14 +145,10 @@ fun NoteEditorScreen(
} }
Scaffold( Scaffold(
// Union systemBars + IME insets so the Scaffold's contentPadding
// shrinks the available area when the soft keyboard opens. With
// edge-to-edge enabled (MainActivity.enableEdgeToEdge), the IME
// inset is NOT applied by default, which previously caused the
// OutlinedTextField to extend behind the keyboard.
contentWindowInsets = WindowInsets.systemBars.union(WindowInsets.ime), contentWindowInsets = WindowInsets.systemBars.union(WindowInsets.ime),
snackbarHost = { SnackbarHost(hostState = snackbarHost) },
topBar = { topBar = {
TopAppBar( CenterAlignedTopAppBar(
title = { Text(if (state.isEditing) "Edit note" else "New note") }, title = { Text(if (state.isEditing) "Edit note" else "New note") },
navigationIcon = { navigationIcon = {
IconButton(onClick = { tryClose() }) { IconButton(onClick = { tryClose() }) {
@@ -133,6 +156,18 @@ fun NoteEditorScreen(
} }
}, },
actions = { actions = {
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,
)
}
IconButton(onClick = { viewModel.toggleFavorite() }) { IconButton(onClick = { viewModel.toggleFavorite() }) {
Icon( Icon(
imageVector = if (state.isFavorite) Icons.Filled.Star else Icons.Outlined.StarOutline, imageVector = if (state.isFavorite) Icons.Filled.Star else Icons.Outlined.StarOutline,
@@ -176,14 +211,25 @@ fun NoteEditorScreen(
.fillMaxSize() .fillMaxSize()
.padding(padding), .padding(padding),
) { ) {
// Colour-picker row (above the editor). HashtagChipRow(
tags = state.hashtags,
canAddMore = state.canAddMoreTags,
onAddClick = { viewModel.openAddTagSheet() },
onRemove = { viewModel.removeTag(it) },
)
// Colour-picker row above the editor text field.
LazyRow( LazyRow(
modifier = Modifier modifier = Modifier
.fillMaxWidth() .fillMaxWidth()
.padding(horizontal = 16.dp, vertical = 8.dp), .padding(horizontal = 16.dp, vertical = 4.dp),
horizontalArrangement = Arrangement.spacedBy(12.dp), horizontalArrangement = Arrangement.spacedBy(12.dp),
) { ) {
items(items = AllNoteColors, key = { it.storageKey.toInt() }) { color -> items(
count = AllNoteColors.size,
key = { idx -> AllNoteColors[idx].storageKey.toInt() },
) { idx ->
val color = AllNoteColors[idx]
ColorSwatch( ColorSwatch(
color = color, color = color,
selected = state.color == color, selected = state.color == color,
@@ -191,6 +237,7 @@ fun NoteEditorScreen(
) )
} }
} }
OutlinedTextField( OutlinedTextField(
value = state.content, value = state.content,
onValueChange = viewModel::onContentChange, onValueChange = viewModel::onContentChange,
@@ -207,14 +254,134 @@ fun NoteEditorScreen(
) )
} }
} }
if (state.isAddingTag) {
AddTagSheet(
tagInput = state.tagInput,
suggestions = state.tagSuggestions,
canCreate = Hashtag.parseOrNull(state.tagInput) != null &&
Hashtag.normalise(state.tagInput) !in state.hashtags,
onInputChange = viewModel::onTagInputChange,
onPickSuggestion = { picked ->
viewModel.addTag(picked)
viewModel.closeAddTagSheet()
},
onCreate = {
if (viewModel.addTag(state.tagInput)) {
viewModel.closeAddTagSheet()
}
},
onDismiss = { viewModel.closeAddTagSheet() },
)
}
} }
private fun androidx.compose.foundation.lazy.LazyListScope.items( @OptIn(ExperimentalLayoutApi::class, ExperimentalMaterial3Api::class)
items: List<NoteColor>, @Composable
key: (NoteColor) -> Any, private fun HashtagChipRow(
itemContent: @Composable (NoteColor) -> Unit, tags: List<String>,
canAddMore: Boolean,
onAddClick: () -> Unit,
onRemove: (String) -> Unit,
) { ) {
items(items.size, key = { key(items[it]) }) { idx -> itemContent(items[idx]) } if (tags.isEmpty() && !canAddMore) return
FlowRow(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 16.dp, vertical = 8.dp),
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalArrangement = Arrangement.spacedBy(4.dp),
) {
if (tags.isEmpty()) {
Text(
text = "Tags",
style = MaterialTheme.typography.labelLarge,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
tags.forEach { tag ->
AssistChip(
onClick = { onRemove(tag) },
label = { Text("#$tag") },
trailingIcon = {
Icon(Icons.Filled.Close, contentDescription = "Remove $tag", modifier = Modifier.size(16.dp))
},
)
}
if (canAddMore) {
AssistChip(
onClick = onAddClick,
label = { Text("+ add") },
leadingIcon = { Icon(Icons.Filled.Add, contentDescription = null, modifier = Modifier.size(16.dp)) },
colors = AssistChipDefaults.assistChipColors(
labelColor = MaterialTheme.colorScheme.primary,
leadingIconContentColor = MaterialTheme.colorScheme.primary,
),
)
}
}
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun AddTagSheet(
tagInput: String,
suggestions: List<String>,
canCreate: Boolean,
onInputChange: (String) -> Unit,
onPickSuggestion: (String) -> Unit,
onCreate: () -> Unit,
onDismiss: () -> Unit,
) {
val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
ModalBottomSheet(
onDismissRequest = onDismiss,
sheetState = sheetState,
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 24.dp, vertical = 8.dp),
verticalArrangement = Arrangement.spacedBy(12.dp),
) {
Text("Add a tag", style = MaterialTheme.typography.titleMedium)
OutlinedTextField(
value = tagInput,
onValueChange = onInputChange,
placeholder = { Text("#tag-name") },
singleLine = true,
leadingIcon = { Icon(Icons.Filled.Tag, contentDescription = null) },
keyboardOptions = KeyboardOptions(capitalization = KeyboardCapitalization.None),
modifier = Modifier.fillMaxWidth(),
)
if (suggestions.isNotEmpty()) {
Text(
"Suggestions",
style = MaterialTheme.typography.labelLarge,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
LazyRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
items(count = suggestions.size, key = { idx -> suggestions[idx] }) { idx ->
val s = suggestions[idx]
SuggestionChip(
onClick = { onPickSuggestion(s) },
label = { Text("#$s") },
)
}
}
}
if (canCreate) {
TextButton(onClick = onCreate) {
Text("+ Create \"${Hashtag.normalise(tagInput)}\"")
}
}
Text(
"Tags help you find notes later. Up to ${NoteEditorUiState.MAX_TAGS} per note.",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
}
} }
@Composable @Composable
@@ -12,35 +12,46 @@ import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.update import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch import kotlinx.coroutines.launch
import org.incido.compose.IncidoApplication import org.incido.compose.IncidoApplication
import org.incido.domain.model.Hashtag
import org.incido.domain.model.Note import org.incido.domain.model.Note
import org.incido.domain.model.NoteColor import org.incido.domain.model.NoteColor
import org.incido.domain.repository.NoteRepository import org.incido.domain.repository.NoteRepository
/** /**
* Immutable UI state for [NoteEditorScreen]. The editor is in "new" * Immutable UI state for [NoteEditorScreen].
* mode when [existing] is null, otherwise it edits an existing note.
*/ */
data class NoteEditorUiState( data class NoteEditorUiState(
val existing: Note? = null, val existing: Note? = null,
val content: String = "", val content: String = "",
val isFavorite: Boolean = false, val isFavorite: Boolean = false,
val color: NoteColor = NoteColor.NONE, val color: NoteColor = NoteColor.NONE,
/** Normalised, sorted ascending. */
val hashtags: List<String> = emptyList(),
/** True while the add-tag sheet is open. */
val isAddingTag: Boolean = false,
/** Latest typing in the add-tag sheet (raw, before normalisation). */
val tagInput: String = "",
/** Autocomplete suggestions for the add-tag sheet. */
val tagSuggestions: List<String> = emptyList(),
val isLoading: Boolean = true, val isLoading: Boolean = true,
val isSaving: Boolean = false, val isSaving: Boolean = false,
val isDeleted: Boolean = false, val isDeleted: Boolean = false,
val snackbar: String? = null,
) { ) {
val canSave: Boolean get() = content.isNotBlank() && !isSaving val canSave: Boolean get() = content.isNotBlank() && !isSaving
val isEditing: Boolean get() = existing != null val isEditing: Boolean get() = existing != null
val canAddMoreTags: Boolean get() = hashtags.size < MAX_TAGS
/** fun isDirty(initialContent: String, initialFavorite: Boolean, initialColor: NoteColor, initialTags: List<String>): Boolean {
* True when the editor has changes that haven't been saved. Used by
* the discard-confirm dialog in [NoteEditorScreen] to decide whether
* to prompt before closing.
*/
fun isDirty(initialContent: String, initialFavorite: Boolean, initialColor: NoteColor): Boolean {
return content != initialContent || return content != initialContent ||
isFavorite != initialFavorite || isFavorite != initialFavorite ||
color != initialColor color != initialColor ||
hashtags != initialTags
}
companion object {
/** Hard cap on tags per note (matches Development Plan §6.1). */
const val MAX_TAGS = 5
} }
} }
@@ -52,29 +63,48 @@ class NoteEditorViewModel(
private val _state = MutableStateFlow(NoteEditorUiState()) private val _state = MutableStateFlow(NoteEditorUiState())
val state: StateFlow<NoteEditorUiState> = _state.asStateFlow() val state: StateFlow<NoteEditorUiState> = _state.asStateFlow()
/** /** Snapshot of initial values for the dirty predicate (see [NoteEditorScreen]). */
* Snapshot of the initial state when the editor loaded. Used by
* [NoteEditorScreen] to compute the discard-confirm predicate.
*/
var initialContent: String = "" var initialContent: String = ""
private set private set
var initialFavorite: Boolean = false var initialFavorite: Boolean = false
private set private set
var initialColor: NoteColor = NoteColor.NONE var initialColor: NoteColor = NoteColor.NONE
private set private set
var initialHashtags: List<String> = emptyList()
private set
/** Internal: re-emits suggestions whenever the tag input changes. */
private val tagInputFlow = MutableStateFlow("")
private val tagSuggestionsFlow = MutableStateFlow<List<String>>(emptyList())
init { init {
// Tag autocomplete — re-query on every keystroke (debounced upstream
// would be nice but ObjectBox is plenty fast for this size).
viewModelScope.launch {
tagInputFlow.collect { raw ->
val prefix = Hashtag.normalise(raw)
val pool = if (prefix.isEmpty()) {
repository.observeAllHashtags()
} else {
repository.searchHashtags(prefix)
}
pool.collect { suggestions ->
_state.update { it.copy(tagSuggestions = suggestions) }
}
}
}
// Load the note if editing.
if (noteId == null || noteId == 0L) { if (noteId == null || noteId == 0L) {
// New note
_state.update { it.copy(isLoading = false) } _state.update { it.copy(isLoading = false) }
} else { } else {
viewModelScope.launch { viewModelScope.launch {
repository.observeById(noteId).collect { note -> repository.observeById(noteId).collect { note ->
if (note != null && _state.value.isLoading) { if (note != null && _state.value.isLoading) {
// First non-null load — capture the initial snapshot.
initialContent = note.content initialContent = note.content
initialFavorite = note.isFavorite initialFavorite = note.isFavorite
initialColor = note.color initialColor = note.color
initialHashtags = note.hashtags
} }
_state.update { _state.update {
it.copy( it.copy(
@@ -82,6 +112,7 @@ class NoteEditorViewModel(
content = note?.content ?: it.content, content = note?.content ?: it.content,
isFavorite = note?.isFavorite ?: it.isFavorite, isFavorite = note?.isFavorite ?: it.isFavorite,
color = note?.color ?: it.color, color = note?.color ?: it.color,
hashtags = note?.hashtags ?: it.hashtags,
isLoading = false, isLoading = false,
) )
} }
@@ -102,23 +133,74 @@ class NoteEditorViewModel(
_state.update { it.copy(color = color) } _state.update { it.copy(color = color) }
} }
fun openAddTagSheet() {
_state.update {
it.copy(
isAddingTag = true,
tagInput = "",
tagSuggestions = emptyList(),
)
}
}
fun closeAddTagSheet() {
_state.update { it.copy(isAddingTag = false, tagInput = "", tagSuggestions = emptyList()) }
}
fun onTagInputChange(raw: String) {
tagInputFlow.value = raw
_state.update { it.copy(tagInput = raw) }
}
/** Add an existing tag to the note (idempotent). Returns false if the cap is hit. */
fun addTag(name: String): Boolean {
val normalised = Hashtag.normalise(name)
if (normalised.isEmpty()) return false
if (!normalised.matches(Regex("^[a-z0-9][a-z0-9._-]{0,30}$"))) return false
val current = _state.value
if (normalised in current.hashtags) return true // already there
if (current.hashtags.size >= NoteEditorUiState.MAX_TAGS) {
_state.update { it.copy(snackbar = "Maximum ${NoteEditorUiState.MAX_TAGS} tags reached.") }
return false
}
_state.update { it.copy(hashtags = (it.hashtags + normalised).sorted()) }
return true
}
fun removeTag(name: String) {
val normalised = Hashtag.normalise(name)
_state.update { it.copy(hashtags = it.hashtags.filterNot { tag -> tag == normalised }) }
}
fun consumeSnackbar() {
_state.update { it.copy(snackbar = null) }
}
fun save(onDone: () -> Unit) { fun save(onDone: () -> Unit) {
val current = _state.value val current = _state.value
if (!current.canSave) return if (!current.canSave) return
_state.update { it.copy(isSaving = true) } _state.update { it.copy(isSaving = true) }
viewModelScope.launch { viewModelScope.launch {
val toPersist = current.existing?.copy( val baseNote = current.existing
val toPersist = baseNote?.copy(
content = current.content, content = current.content,
isFavorite = current.isFavorite, isFavorite = current.isFavorite,
color = current.color, color = current.color,
hashtags = current.hashtags,
) ?: Note( ) ?: Note(
content = current.content, content = current.content,
createdAt = System.currentTimeMillis(), createdAt = System.currentTimeMillis(),
updatedAt = System.currentTimeMillis(), updatedAt = System.currentTimeMillis(),
isFavorite = current.isFavorite, isFavorite = current.isFavorite,
color = current.color, color = current.color,
hashtags = current.hashtags,
) )
repository.upsert(toPersist) val saved = repository.upsert(toPersist)
// Reconcile hashtag set vs. what was previously persisted.
val previous = baseNote?.hashtags.orEmpty().toSet()
val currentSet = current.hashtags.toSet()
(previous - currentSet).forEach { repository.removeHashtag(saved.id, it) }
(currentSet - previous).forEach { repository.addHashtag(saved.id, it) }
_state.update { it.copy(isSaving = false) } _state.update { it.copy(isSaving = false) }
onDone() onDone()
} }
@@ -13,15 +13,18 @@ import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.CheckBox import androidx.compose.material.icons.filled.CheckBox
import androidx.compose.material.icons.filled.Delete import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.Menu
import androidx.compose.material.icons.filled.Search import androidx.compose.material.icons.filled.Search
import androidx.compose.material.icons.filled.Star import androidx.compose.material.icons.filled.Star
import androidx.compose.material.icons.outlined.StarOutline import androidx.compose.material.icons.outlined.StarOutline
import androidx.compose.material3.Card import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.CenterAlignedTopAppBar
import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FloatingActionButton import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3.Icon import androidx.compose.material3.Icon
@@ -30,8 +33,8 @@ import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Scaffold import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember import androidx.compose.runtime.remember
@@ -39,41 +42,57 @@ import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.lerp
import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel import androidx.lifecycle.viewmodel.compose.viewModel
import org.incido.compose.ui.editor.toComposeColor import org.incido.compose.ui.theme.toComposeColor
import org.incido.compose.util.rememberRelativeTimestamp import org.incido.compose.util.rememberRelativeTimestamp
import org.incido.domain.model.Note import org.incido.domain.model.Note
import org.incido.domain.model.NoteColor import org.incido.domain.model.NoteColor
import org.incido.domain.model.NoteFilter
@OptIn(ExperimentalMaterial3Api::class) @OptIn(ExperimentalMaterial3Api::class)
@Composable @Composable
fun NoteListScreen( fun NoteListScreen(
filterMode: NoteFilter,
onOpenDrawer: () -> Unit,
onOpenEditor: (Long?) -> Unit, onOpenEditor: (Long?) -> Unit,
viewModel: NoteListViewModel = viewModel(factory = NoteListViewModel.Factory), viewModel: NoteListViewModel = viewModel(factory = NoteListViewModel.Factory),
) { ) {
val state by viewModel.uiState.collectAsStateWithLifecycle() val state by viewModel.uiState.collectAsStateWithLifecycle()
var localQuery by remember { mutableStateOf("") } var localQuery by remember { mutableStateOf("") }
// Keep the ViewModel in sync with the parent's filter selection.
LaunchedEffect(filterMode) { viewModel.setFilter(filterMode) }
Scaffold( Scaffold(
topBar = { topBar = {
TopAppBar( CenterAlignedTopAppBar(
title = { Text("Incido") }, title = { Text(screenTitle(filterMode)) },
navigationIcon = {
IconButton(onClick = onOpenDrawer) {
Icon(Icons.Filled.Menu, contentDescription = "Open menu")
}
},
actions = { actions = {
if (filterMode == NoteFilter.Home) {
IconButton(onClick = { IconButton(onClick = {
if (state.isSearchActive) viewModel.closeSearch() else viewModel.openSearch() if (state.isSearchActive) viewModel.closeSearch() else viewModel.openSearch()
localQuery = "" localQuery = ""
}) { }) {
Icon(Icons.Default.Search, contentDescription = "Search notes") Icon(Icons.Filled.Search, contentDescription = "Search notes")
}
} }
}, },
) )
}, },
floatingActionButton = { floatingActionButton = {
if (!state.isSearchActive) { // FAB only on Home — adding notes while filtered makes less sense.
if (filterMode == NoteFilter.Home) {
FloatingActionButton(onClick = { onOpenEditor(null) }) { FloatingActionButton(onClick = { onOpenEditor(null) }) {
Icon(Icons.Default.Add, contentDescription = "New note") Icon(Icons.Default.Add, contentDescription = "New note")
} }
@@ -81,7 +100,7 @@ fun NoteListScreen(
}, },
) { padding -> ) { padding ->
Column(modifier = Modifier.padding(padding)) { Column(modifier = Modifier.padding(padding)) {
if (state.isSearchActive) { if (filterMode == NoteFilter.Home && state.isSearchActive) {
OutlinedTextField( OutlinedTextField(
value = localQuery, value = localQuery,
onValueChange = { onValueChange = {
@@ -99,8 +118,8 @@ fun NoteListScreen(
when { when {
state.isLoading -> Unit state.isLoading -> Unit
state.isEmpty -> EmptyState() state.isEmpty -> EmptyState(filterMode = filterMode)
state.noResults -> NoResultsState() state.noResults -> NoResultsState(filterMode = filterMode)
else -> NoteList( else -> NoteList(
notes = state.notes, notes = state.notes,
onClick = { onOpenEditor(it.id) }, onClick = { onOpenEditor(it.id) },
@@ -112,8 +131,21 @@ fun NoteListScreen(
} }
} }
private fun screenTitle(filter: NoteFilter): String = when (filter) {
NoteFilter.Home -> "Incido"
NoteFilter.Favorites -> "Favorites"
NoteFilter.Untagged -> "Untagged"
is NoteFilter.ByTag -> "#${filter.hashtag}"
}
@Composable @Composable
private fun EmptyState() { private fun EmptyState(filterMode: NoteFilter) {
val message = when (filterMode) {
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. 🎉"
is NoteFilter.ByTag -> "No notes tagged #${filterMode.hashtag} yet."
}
Box( Box(
modifier = Modifier modifier = Modifier
.fillMaxSize() .fillMaxSize()
@@ -121,7 +153,7 @@ private fun EmptyState() {
contentAlignment = Alignment.Center, contentAlignment = Alignment.Center,
) { ) {
Text( Text(
text = "No notes yet. Tap + to start.", text = message,
style = MaterialTheme.typography.bodyLarge, style = MaterialTheme.typography.bodyLarge,
color = MaterialTheme.colorScheme.onSurfaceVariant, color = MaterialTheme.colorScheme.onSurfaceVariant,
) )
@@ -129,7 +161,11 @@ private fun EmptyState() {
} }
@Composable @Composable
private fun NoResultsState() { private fun NoResultsState(filterMode: NoteFilter) {
val message = when (filterMode) {
NoteFilter.Home -> "No matching notes."
else -> "Nothing here."
}
Box( Box(
modifier = Modifier modifier = Modifier
.fillMaxSize() .fillMaxSize()
@@ -137,7 +173,7 @@ private fun NoResultsState() {
contentAlignment = Alignment.Center, contentAlignment = Alignment.Center,
) { ) {
Text( Text(
text = "No matching notes.", text = message,
style = MaterialTheme.typography.bodyLarge, style = MaterialTheme.typography.bodyLarge,
color = MaterialTheme.colorScheme.onSurfaceVariant, color = MaterialTheme.colorScheme.onSurfaceVariant,
) )
@@ -172,6 +208,13 @@ private fun NoteList(
} }
} }
/**
* v0.3.0.0 card redesign — three-layer colour accent so notes of
* different colours are visually distinct at a glance:
* 1. 14 dp vertical gradient stripe down the left edge.
* 2. Tinted card surface (12 % colour blend over the M3 surface).
* 3. 10 dp solid colour chip in the top-right corner.
*/
@Composable @Composable
private fun NoteCard( private fun NoteCard(
note: Note, note: Note,
@@ -182,19 +225,38 @@ private fun NoteCard(
val (title, body) = Note.titleAndBody(note.content) val (title, body) = Note.titleAndBody(note.content)
val bodyPreview = Note.bodyPreview(body) val bodyPreview = Note.bodyPreview(body)
val checklistSummary = Note.checklistSummary(note.content) val checklistSummary = Note.checklistSummary(note.content)
val stripeColor = note.color.toComposeColor() val noteColor = note.color
val hasColor = noteColor != NoteColor.NONE
Card( Card(
onClick = onClick, onClick = onClick,
modifier = Modifier.fillMaxWidth(), modifier = Modifier.fillMaxWidth(),
colors = if (hasColor) {
val tint = noteColor.toComposeColor()
val surface = MaterialTheme.colorScheme.surface
CardDefaults.cardColors(
containerColor = lerp(surface, tint, 0.12f),
)
} else {
CardDefaults.cardColors()
},
) { ) {
Row(modifier = Modifier.fillMaxWidth()) { Row(modifier = Modifier.fillMaxWidth()) {
// 4dp coloured accent stripe on the left. if (hasColor) {
// Layer 1: 14 dp gradient stripe.
Box( Box(
modifier = Modifier modifier = Modifier
.size(width = 4.dp, height = 96.dp) .size(width = 14.dp, height = 110.dp)
.background(stripeColor), .background(
Brush.verticalGradient(
colors = listOf(
noteColor.toComposeColor().copy(alpha = 0.95f),
noteColor.toComposeColor().copy(alpha = 0.05f),
),
) )
),
)
}
Column(modifier = Modifier.padding(16.dp).fillMaxWidth()) { Column(modifier = Modifier.padding(16.dp).fillMaxWidth()) {
Row( Row(
modifier = Modifier.fillMaxWidth(), modifier = Modifier.fillMaxWidth(),
@@ -207,6 +269,16 @@ private fun NoteCard(
overflow = TextOverflow.Ellipsis, overflow = TextOverflow.Ellipsis,
modifier = Modifier.weight(1f), modifier = Modifier.weight(1f),
) )
// Layer 3: top-right colour chip (only when coloured).
if (hasColor) {
Box(
modifier = Modifier
.size(10.dp)
.clip(CircleShape)
.background(noteColor.toComposeColor()),
)
Spacer(modifier = Modifier.size(8.dp))
}
IconButton(onClick = onToggleFavorite) { IconButton(onClick = onToggleFavorite) {
Icon( Icon(
imageVector = if (note.isFavorite) Icons.Filled.Star else Icons.Outlined.StarOutline, imageVector = if (note.isFavorite) Icons.Filled.Star else Icons.Outlined.StarOutline,
@@ -267,4 +339,11 @@ private fun NoteCard(
} }
} }
// --- Lightweight imports used to avoid shadowed-name conflicts in
// other files that might also import these symbols ---
@Suppress("unused")
private fun clip(@Suppress("UNUSED_PARAMETER") shape: androidx.compose.ui.graphics.Shape): Modifier =
Modifier.clip(shape)
@Suppress("unused")
private fun background(color: Color): Modifier = Modifier.background(color)
@@ -17,26 +17,24 @@ import kotlinx.coroutines.flow.flatMapLatest
import kotlinx.coroutines.flow.stateIn import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch import kotlinx.coroutines.launch
import org.incido.compose.IncidoApplication import org.incido.compose.IncidoApplication
import org.incido.domain.model.HashtagUsage
import org.incido.domain.model.Note import org.incido.domain.model.Note
import org.incido.domain.model.NoteFilter
import org.incido.domain.repository.NoteRepository import org.incido.domain.repository.NoteRepository
/** /**
* Immutable UI state for [NoteListScreen]. A loading flag plus the * Immutable UI state for [NoteListScreen].
* current snapshot of notes; an empty list with [isLoading] == false
* indicates the empty-state UI should be shown (F6).
*
* [isSearchActive] / [searchQuery] are now properly folded into the same
* uiState flow (v0.2.1 fix — they used to live on a separate StateFlow
* that the composable never observed, making the search icon a no-op).
*/ */
data class NoteListUiState( data class NoteListUiState(
val notes: List<Note> = emptyList(), val notes: List<Note> = emptyList(),
val isLoading: Boolean = true, val isLoading: Boolean = true,
val searchQuery: String = "", val searchQuery: String = "",
val isSearchActive: Boolean = false, val isSearchActive: Boolean = false,
val filter: NoteFilter = NoteFilter.Home,
val recentHashtags: List<HashtagUsage> = emptyList(),
) { ) {
val isEmpty: Boolean get() = !isLoading && notes.isEmpty() && !isSearchActive val isEmpty: Boolean get() = !isLoading && notes.isEmpty() && !isSearchActive && filter == NoteFilter.Home
val noResults: Boolean get() = !isLoading && notes.isEmpty() && isSearchActive val noResults: Boolean get() = !isLoading && notes.isEmpty() && !isEmpty
} }
@OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class) @OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class)
@@ -44,34 +42,36 @@ class NoteListViewModel(
private val repository: NoteRepository, private val repository: NoteRepository,
) : ViewModel() { ) : ViewModel() {
private val filterMode = MutableStateFlow<NoteFilter>(NoteFilter.Home)
private val rawQuery = MutableStateFlow("") private val rawQuery = MutableStateFlow("")
private val _isSearchActive = MutableStateFlow(false) private val _isSearchActive = MutableStateFlow(false)
/** /** Notes stream — switches on (filter, query) so the same ViewModel
* Combines the filtered notes flow, the search-active flag, and the * instance handles Home, Favorites, Untagged, ByTag, and search. */
* raw query into a single [NoteListUiState] that the composable can private val notesFlow = combine(filterMode, rawQuery) { f, q -> f to q }
* `collectAsStateWithLifecycle`. All three pieces of state are .flatMapLatest { (f, q) ->
* updated together so `if (state.isSearchActive)` in the screen when (f) {
* actually reflects the icon's toggled value. NoteFilter.Home -> if (q.isBlank()) repository.observeAll() else repository.search(q)
*/ NoteFilter.Favorites -> repository.observeFavorites()
val uiState: StateFlow<NoteListUiState> = combine( NoteFilter.Untagged -> repository.observeUntagged()
rawQuery is NoteFilter.ByTag -> repository.observeNotesForHashtag(f.hashtag)
.debounce(150)
.flatMapLatest { q ->
if (q.isBlank()) {
repository.observeAll()
} else {
repository.search(q)
} }
}, }
val uiState: StateFlow<NoteListUiState> = combine(
notesFlow,
_isSearchActive, _isSearchActive,
filterMode,
rawQuery, rawQuery,
) { notes, searchActive, q -> repository.observeHashtagsByRecentUse(),
) { notes, searchActive, filter, query, recent ->
NoteListUiState( NoteListUiState(
notes = notes, notes = notes,
isLoading = false, isLoading = false,
searchQuery = q, searchQuery = query,
isSearchActive = searchActive, isSearchActive = searchActive,
filter = filter,
recentHashtags = recent,
) )
}.stateIn( }.stateIn(
scope = viewModelScope, scope = viewModelScope,
@@ -79,6 +79,16 @@ class NoteListViewModel(
initialValue = NoteListUiState(), initialValue = NoteListUiState(),
) )
fun setFilter(filter: NoteFilter) {
filterMode.value = filter
// Switching away from Home closes the search bar (search is
// only meaningful in Home).
if (filter != NoteFilter.Home && _isSearchActive.value) {
_isSearchActive.value = false
rawQuery.value = ""
}
}
fun onQueryChange(q: String) { fun onQueryChange(q: String) {
rawQuery.value = q rawQuery.value = q
} }
@@ -1,4 +1,4 @@
package org.incido.compose.ui.editor package org.incido.compose.ui.theme
import androidx.compose.material3.MaterialTheme import androidx.compose.material3.MaterialTheme
import androidx.compose.runtime.Composable import androidx.compose.runtime.Composable
@@ -7,8 +7,8 @@ import androidx.compose.ui.graphics.Color
import org.incido.domain.model.NoteColor import org.incido.domain.model.NoteColor
/** /**
* Maps a [NoteColor] enum to a Compose [Color] using Material 3 tokens so * Maps a [NoteColor] enum to a Compose [Color]. Values are chosen to
* the swatches adapt to light/dark theme automatically. * stay readable against both light and dark surfaces.
*/ */
@Composable @Composable
@ReadOnlyComposable @ReadOnlyComposable
@@ -21,6 +21,7 @@ fun NoteColor.toComposeColor(): Color = when (this) {
NoteColor.PURPLE -> Color(0xFF7B5BA6) NoteColor.PURPLE -> Color(0xFF7B5BA6)
} }
/** All selectable colours, including [NoteColor.NONE]. */
val AllNoteColors: List<NoteColor> = listOf( val AllNoteColors: List<NoteColor> = listOf(
NoteColor.NONE, NoteColor.NONE,
NoteColor.BLUE, NoteColor.BLUE,
@@ -30,10 +31,7 @@ val AllNoteColors: List<NoteColor> = listOf(
NoteColor.PURPLE, NoteColor.PURPLE,
) )
/** /** Outline colour used to highlight the selected swatch. */
* A swatch surface colour for a swatch button — used to give the
* selected swatch a visible border by reading the theme's outline.
*/
val swatchBorderColor: Color val swatchBorderColor: Color
@Composable @Composable
@ReadOnlyComposable @ReadOnlyComposable
@@ -0,0 +1,19 @@
package org.incido.data.entity
import io.objectbox.annotation.Entity
import io.objectbox.annotation.Id
import io.objectbox.annotation.Index
/**
* A single normalised hashtag. Case-insensitive uniqueness is
* enforced at the repository layer (`NoteRepositoryImpl.addHashtag`
* uses `findFirst` and reuses the existing row); the index here just
* speeds up the lookup.
*
* The "many-to-many" link to notes lives in [NoteHashtagCrossRef].
*/
@Entity
data class HashtagEntity(
@Id var id: Long = 0,
@Index var name: String = "",
)
@@ -0,0 +1,19 @@
package org.incido.data.entity
import io.objectbox.annotation.Entity
import io.objectbox.annotation.Id
import io.objectbox.annotation.Index
/**
* Many-to-many junction between [NoteEntity] and [HashtagEntity].
* Each row is one (`noteId`, `hashtagId`) pair.
*
* Both columns are indexed for fast lookups in either direction
* (notes for a hashtag, hashtags for a note).
*/
@Entity
data class NoteHashtagCrossRef(
@Id var id: Long = 0,
@Index var noteId: Long = 0,
@Index var hashtagId: Long = 0,
)
@@ -2,72 +2,113 @@ package org.incido.data.repository
import io.objectbox.BoxStore import io.objectbox.BoxStore
import io.objectbox.kotlin.boxFor import io.objectbox.kotlin.boxFor
import io.objectbox.query.QueryBuilder
import io.objectbox.reactive.DataSubscription import io.objectbox.reactive.DataSubscription
import kotlinx.coroutines.channels.awaitClose import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.callbackFlow import kotlinx.coroutines.flow.callbackFlow
import kotlinx.coroutines.flow.flowOn import kotlinx.coroutines.flow.flowOn
import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Dispatchers
import org.incido.data.entity.HashtagEntity
import org.incido.data.entity.HashtagEntity_
import org.incido.data.entity.NoteEntity import org.incido.data.entity.NoteEntity
import org.incido.data.entity.NoteEntity_ import org.incido.data.entity.NoteEntity_
import org.incido.data.entity.NoteHashtagCrossRef
import org.incido.data.entity.NoteHashtagCrossRef_
import org.incido.data.entity.toDomain import org.incido.data.entity.toDomain
import org.incido.data.entity.toEntity import org.incido.data.entity.toEntity
import org.incido.domain.model.Hashtag
import org.incido.domain.model.HashtagUsage
import org.incido.domain.model.Note import org.incido.domain.model.Note
import org.incido.domain.repository.NoteRepository import org.incido.domain.repository.NoteRepository
/** /**
* ObjectBox-backed implementation of [NoteRepository]. All writes are * ObjectBox-backed implementation of [NoteRepository]. Hashtags live
* dispatched to `Default`; reads use ObjectBox's reactive subscription so * in two extra tables (`HashtagEntity`, `NoteHashtagCrossRef`); every
* the UI auto-refreshes whenever a row changes (F7). * "list of notes" snapshot here loads the cross-ref + tags in one
* pass so callers get fully-populated [Note.hashtags] lists.
* *
* Sort order is `isFavorite DESC, updatedAt DESC` for both [observeAll] and * Sort order for [observeAll] / [search] / filter streams:
* [search] so favourites always float to the top. * `isFavorite DESC, updatedAt DESC`.
*
* Note: ObjectBox 4.0.3's Kotlin stubs are finicky around
* `QueryBuilder.equal(Property, String, ...)` — passing the
* `StringOrder` argument explicitly is the most reliable way to call it.
*/ */
class NoteRepositoryImpl( class NoteRepositoryImpl(
private val boxStore: BoxStore, private val boxStore: BoxStore,
) : NoteRepository { ) : NoteRepository {
private val box = boxStore.boxFor<NoteEntity>() private val noteBox = boxStore.boxFor<NoteEntity>()
private val tagBox = boxStore.boxFor<HashtagEntity>()
private val xrefBox = boxStore.boxFor<NoteHashtagCrossRef>()
// ---------------------------------------------------------------------
// List / observation streams
// ---------------------------------------------------------------------
override fun observeAll(): Flow<List<Note>> = callbackFlow { override fun observeAll(): Flow<List<Note>> = callbackFlow {
trySend(sortedSnapshot("")) trySend(snapshotAll())
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotAll()) }
val subscription = box awaitClose { sub.cancel() }
.query()
.build()
.subscribe()
.observer { trySend(sortedSnapshot("")) }
awaitClose { subscription.cancel() }
}.flowOn(Dispatchers.Default) }.flowOn(Dispatchers.Default)
override fun search(query: String): Flow<List<Note>> = callbackFlow { override fun search(query: String): Flow<List<Note>> = callbackFlow {
trySend(sortedSnapshot(query)) trySend(snapshotSearch(query))
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotSearch(query)) }
awaitClose { sub.cancel() }
}.flowOn(Dispatchers.Default)
val subscription = if (query.isBlank()) { override fun observeFavorites(): Flow<List<Note>> = callbackFlow {
box.query().build().subscribe() trySend(snapshotFavorites())
} else { val sub = noteBox.query().build().subscribe().observer { trySend(snapshotFavorites()) }
box.query() awaitClose { sub.cancel() }
.contains(NoteEntity_.content, query, io.objectbox.query.QueryBuilder.StringOrder.CASE_INSENSITIVE) }.flowOn(Dispatchers.Default)
.build()
.subscribe()
}.observer { trySend(sortedSnapshot(query)) }
awaitClose { subscription.cancel() } override fun observeUntagged(): Flow<List<Note>> = callbackFlow {
trySend(snapshotUntagged())
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotUntagged()) }
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)) }
awaitClose { sub.cancel() }
}.flowOn(Dispatchers.Default)
override fun observeHashtagsByRecentUse(): Flow<List<HashtagUsage>> = callbackFlow {
trySend(hashtagUsageSnapshot())
val sub = noteBox.query().build().subscribe().observer { trySend(hashtagUsageSnapshot()) }
awaitClose { sub.cancel() }
}.flowOn(Dispatchers.Default)
override fun observeAllHashtags(): Flow<List<String>> = callbackFlow {
trySend(allHashtagsSnapshot().sorted())
val sub = noteBox.query().build().subscribe().observer {
trySend(allHashtagsSnapshot().sorted())
}
awaitClose { sub.cancel() }
}.flowOn(Dispatchers.Default)
override fun searchHashtags(prefix: String): Flow<List<String>> = callbackFlow {
trySend(searchHashtagsSnapshot(prefix))
val sub = noteBox.query().build().subscribe().observer {
trySend(searchHashtagsSnapshot(prefix))
}
awaitClose { sub.cancel() }
}.flowOn(Dispatchers.Default) }.flowOn(Dispatchers.Default)
override fun observeById(id: Long): Flow<Note?> = callbackFlow { override fun observeById(id: Long): Flow<Note?> = callbackFlow {
trySend(box.get(id)?.toDomain()) trySend(noteByIdSnapshot(id))
val sub = noteBox.query().build().subscribe().observer { trySend(noteByIdSnapshot(id)) }
val subscription = box awaitClose { sub.cancel() }
.query()
.build()
.subscribe()
.observer { trySend(box.get(id)?.toDomain()) }
awaitClose { subscription.cancel() }
}.flowOn(Dispatchers.Default) }.flowOn(Dispatchers.Default)
// ---------------------------------------------------------------------
// Writes
// ---------------------------------------------------------------------
override suspend fun upsert(note: Note): Note { override suspend fun upsert(note: Note): Note {
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
val toPersist = if (note.id == 0L) { val toPersist = if (note.id == 0L) {
@@ -75,39 +116,213 @@ class NoteRepositoryImpl(
} else { } else {
note.copy(updatedAt = now).toEntity() note.copy(updatedAt = now).toEntity()
} }
val assignedId = box.put(toPersist) val assignedId = noteBox.put(toPersist)
val existing = box.get(assignedId) return noteBox.get(assignedId)?.toDomain() ?: note.copy(id = assignedId)
return existing?.toDomain() ?: note.copy(id = assignedId)
} }
override suspend fun delete(id: Long) { override suspend fun delete(id: Long) {
box.remove(id) noteBox.remove(id)
val orphanXrefs: List<NoteHashtagCrossRef> = xrefBox.query()
.equal(NoteHashtagCrossRef_.noteId, id)
.build()
.find()
if (orphanXrefs.isNotEmpty()) {
xrefBox.remove(*orphanXrefs.map { it.id }.toLongArray())
}
} }
override suspend fun setFavorite(id: Long, isFavorite: Boolean) { override suspend fun setFavorite(id: Long, isFavorite: Boolean) {
val entity = box.get(id) ?: return val entity = noteBox.get(id) ?: return
if (entity.isFavorite == isFavorite) return if (entity.isFavorite == isFavorite) return
entity.isFavorite = isFavorite entity.isFavorite = isFavorite
box.put(entity) noteBox.put(entity)
} }
/** override suspend fun addHashtag(noteId: Long, name: String) {
* Snapshot helper. If [query] is non-blank, only notes whose content val normalised = Hashtag.normalise(name)
* contains it (case-insensitive) are included; otherwise all notes. if (!normalised.matches(Regex("^[a-z0-9][a-z0-9._-]{0,30}$"))) return
* The result is sorted favourites-first, then newest-first.
*/ val tag: HashtagEntity = tagBox.query()
private fun sortedSnapshot(query: String): List<Note> { .equal(HashtagEntity_.name, normalised, QueryBuilder.StringOrder.CASE_INSENSITIVE)
val raw = if (query.isBlank()) {
box.all
} else {
box.query()
.contains(NoteEntity_.content, query, io.objectbox.query.QueryBuilder.StringOrder.CASE_INSENSITIVE)
.build() .build()
.find() .findFirst() ?: run {
tagBox.put(HashtagEntity(name = normalised))
// Re-query to get the freshly-inserted row (with its new id).
tagBox.query()
.equal(HashtagEntity_.name, normalised, QueryBuilder.StringOrder.CASE_INSENSITIVE)
.build()
.findFirst()
} ?: return
val existing: NoteHashtagCrossRef? = xrefBox.query()
.equal(NoteHashtagCrossRef_.noteId, noteId)
.equal(NoteHashtagCrossRef_.hashtagId, tag.id)
.build()
.findFirst()
if (existing != null) return
xrefBox.put(NoteHashtagCrossRef(noteId = noteId, hashtagId = tag.id))
} }
return raw.sortedWith(
override suspend fun removeHashtag(noteId: Long, name: String) {
val normalised = Hashtag.normalise(name)
val tag: HashtagEntity = tagBox.query()
.equal(HashtagEntity_.name, normalised, QueryBuilder.StringOrder.CASE_INSENSITIVE)
.build()
.findFirst() ?: return
val xref: NoteHashtagCrossRef = xrefBox.query()
.equal(NoteHashtagCrossRef_.noteId, noteId)
.equal(NoteHashtagCrossRef_.hashtagId, tag.id)
.build()
.findFirst() ?: return
xrefBox.remove(xref.id)
}
// ---------------------------------------------------------------------
// Snapshots
// ---------------------------------------------------------------------
/** Map of noteId -> ordered list of hashtag names. */
private fun hashtagsByNoteId(): Map<Long, List<String>> {
val xrefs: List<NoteHashtagCrossRef> = xrefBox.all
if (xrefs.isEmpty()) return emptyMap()
val tagIds: Set<Long> = xrefs.map { it.hashtagId }.toSet()
val tagById: Map<Long, String> = tagIds.associateWith { id ->
tagBox.get(id)?.name ?: ""
}.filterValues { it.isNotEmpty() }
return xrefs.groupBy { it.noteId }
.mapValues { (_, refs) ->
refs.mapNotNull { tagById[it.hashtagId] }.sorted()
}
}
private fun decorate(entities: List<NoteEntity>): List<Note> {
val tags = hashtagsByNoteId()
return entities.sortedWith(
compareByDescending<NoteEntity> { it.isFavorite } compareByDescending<NoteEntity> { it.isFavorite }
.thenByDescending { it.updatedAt } .thenByDescending { it.updatedAt }
).map { it.toDomain() } ).map { e ->
val base = e.toDomain()
base.copy(hashtags = tags[e.id].orEmpty())
}
}
private fun snapshotAll(): List<Note> = decorate(noteBox.all)
private fun snapshotSearch(query: String): List<Note> {
val q = query.trim()
if (q.isEmpty()) return snapshotAll()
// Match against content (contains, case-insensitive).
val contentMatches: List<Long> = noteBox.query()
.contains(NoteEntity_.content, q, QueryBuilder.StringOrder.CASE_INSENSITIVE)
.build()
.find()
.map { it.id }
// Match against hashtag names (case-insensitive exact equality).
val matchingTag: HashtagEntity? = tagBox.query()
.equal(HashtagEntity_.name, q, QueryBuilder.StringOrder.CASE_INSENSITIVE)
.build()
.findFirst()
val tagMatches: List<Long> = if (matchingTag == null) emptyList() else {
xrefBox.query()
.equal(NoteHashtagCrossRef_.hashtagId, matchingTag.id)
.build()
.find()
.map { it.noteId }
}
val allIds: Set<Long> = (contentMatches + tagMatches).toSet()
if (allIds.isEmpty()) return emptyList()
val entities: List<NoteEntity> = allIds.mapNotNull { noteBox.get(it) }
return decorate(entities)
}
private fun snapshotFavorites(): List<Note> {
val favEntities: List<NoteEntity> = noteBox.query()
.equal(NoteEntity_.isFavorite, true)
.build()
.find()
return decorate(favEntities)
}
private fun snapshotUntagged(): List<Note> {
val noteIdsWithTags: Set<Long> = xrefBox.all.map { it.noteId }.toSet()
val untaggedEntities: List<NoteEntity> = noteBox.all.filter { it.id !in noteIdsWithTags }
return decorate(untaggedEntities)
}
private fun snapshotForHashtag(name: String): List<Note> {
val normalised = Hashtag.normalise(name)
val tag: HashtagEntity = tagBox.query()
.equal(HashtagEntity_.name, normalised, QueryBuilder.StringOrder.CASE_INSENSITIVE)
.build()
.findFirst() ?: return emptyList()
val xrefs: List<NoteHashtagCrossRef> = xrefBox.query()
.equal(NoteHashtagCrossRef_.hashtagId, tag.id)
.build()
.find()
val noteIds: Set<Long> = xrefs.map { it.id }.let { _ -> xrefs.map { it.noteId }.toSet() }
if (noteIds.isEmpty()) return emptyList()
val entities: List<NoteEntity> = noteIds.mapNotNull { noteBox.get(it) }
return decorate(entities)
}
private fun noteByIdSnapshot(id: Long): Note? {
val entity = noteBox.get(id) ?: return null
val tags = hashtagsByNoteId()[id].orEmpty()
return entity.toDomain().copy(hashtags = tags)
}
/** Build [HashtagUsage] for every distinct tag, sorted by lastUsedAt DESC. */
private fun hashtagUsageSnapshot(): List<HashtagUsage> {
val xrefs: List<NoteHashtagCrossRef> = xrefBox.all
if (xrefs.isEmpty()) return emptyList()
// For each hashtagId, accumulate (lastUsedAt, count).
data class Agg(var lastUsedAt: Long, var count: Int)
val aggregate = HashMap<Long, Agg>(xrefs.size)
for (x in xrefs) {
val note: NoteEntity = noteBox.get(x.noteId) ?: continue
val cur = aggregate[x.hashtagId]
if (cur == null) {
aggregate[x.hashtagId] = Agg(note.updatedAt, 1)
} else {
if (note.updatedAt > cur.lastUsedAt) cur.lastUsedAt = note.updatedAt
cur.count += 1
}
}
return aggregate.mapNotNull { (tagId, agg) ->
val tag: HashtagEntity = tagBox.get(tagId) ?: return@mapNotNull null
HashtagUsage(name = tag.name, noteCount = agg.count, lastUsedAt = agg.lastUsedAt)
}.sortedWith(
compareByDescending<HashtagUsage> { it.lastUsedAt }
.thenByDescending { it.noteCount }
.thenBy { it.name }
)
}
private fun allHashtagsSnapshot(): List<String> =
tagBox.all.map { it.name }
private fun searchHashtagsSnapshot(prefix: String): List<String> {
val p = prefix.trim()
if (p.isEmpty()) return allHashtagsSnapshot().sorted()
val byPrefix: List<HashtagEntity> = tagBox.query()
.startsWith(HashtagEntity_.name, p.lowercase(), QueryBuilder.StringOrder.CASE_INSENSITIVE)
.build()
.find()
// Sort by usage count (most-used first), then name.
val usageById: Map<Long, Int> = xrefBox.all.groupingBy { it.hashtagId }.eachCount()
return byPrefix
.sortedWith(
compareByDescending<HashtagEntity> { usageById[it.id] ?: 0 }
.thenBy { it.name }
)
.map { it.name }
} }
} }
@@ -0,0 +1,33 @@
package org.incido.domain.model
/**
* A single hashtag, normalised: lowercase, no leading `#`, no
* surrounding whitespace. The [name] is the on-disk identifier so
* two notes tagging "Work" and "work" share a row.
*
* Allowed characters: `a-z`, `0-9`, `.`, `_`, `-`. Must start with an
* alphanumeric. Length 1..31.
*/
@JvmInline
value class Hashtag(val name: String) {
init {
require(name.matches(Regex("^[a-z0-9][a-z0-9._-]{0,30}$"))) {
"Invalid hashtag name: \"$name\". Must match ^[a-z0-9][a-z0-9._-]{0,30}$"
}
}
/** Render with leading `#` for display. */
fun displayName(): String = "#$name"
companion object {
/** Normalise raw user input — trim, lowercase, strip leading `#`s. */
fun normalise(raw: String): String =
raw.trim().lowercase().trimStart('#').trim()
/** Try to parse; returns null when the input doesn't match the rules. */
fun parseOrNull(raw: String): Hashtag? {
val n = normalise(raw)
return if (n.matches(Regex("^[a-z0-9][a-z0-9._-]{0,30}$"))) Hashtag(n) else null
}
}
}
@@ -0,0 +1,11 @@
package org.incido.domain.model
/**
* Aggregate info about a single hashtag, for the nav drawer's "Recent
* tags" list.
*/
data class HashtagUsage(
val name: String,
val noteCount: Int,
val lastUsedAt: Long,
)
@@ -12,6 +12,8 @@ data class Note(
val updatedAt: Long, val updatedAt: Long,
val isFavorite: Boolean = false, val isFavorite: Boolean = false,
val color: NoteColor = NoteColor.NONE, val color: NoteColor = NoteColor.NONE,
/** Tags attached to this note (normalised lowercase, sorted ascending). */
val hashtags: List<String> = emptyList(),
) { ) {
companion object { companion object {
private const val UNTITLED = "Untitled" private const val UNTITLED = "Untitled"
@@ -0,0 +1,26 @@
package org.incido.domain.model
/**
* What the note list is currently showing. Drives both the
* `NoteListScreen` body and the selected entry in the navigation
* drawer.
*
* - [Home] — every note (the default). The search bar is enabled.
* - [Favorites] — only notes with `isFavorite = true`. No search.
* - [Untagged] — only notes that have zero hashtags. No search.
* - [ByTag] — only notes tagged with [hashtag]. No search.
*/
sealed class NoteFilter {
object Home : NoteFilter()
object Favorites : NoteFilter()
object Untagged : NoteFilter()
data class ByTag(val hashtag: String) : NoteFilter()
/** Stable identifier used by the drawer for `selected` matching. */
fun key(): String = when (this) {
Home -> "home"
Favorites -> "favorites"
Untagged -> "untagged"
is ByTag -> "tag:$hashtag"
}
}
@@ -1,28 +1,26 @@
package org.incido.domain.repository package org.incido.domain.repository
import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.Flow
import org.incido.domain.model.HashtagUsage
import org.incido.domain.model.Note import org.incido.domain.model.Note
/** /**
* Persistence boundary for [Note]s. The UI layer depends on this interface * Persistence boundary for [Note]s. The UI layer depends on this interface
* only — never on the ObjectBox-backed implementation in `:core:data`. * only — never on the ObjectBox-backed implementation in `:core:data`.
* *
* Implementations are expected to: * Sort order for [observeAll] / [search]: `isFavorite DESC, updatedAt DESC`.
* - Return a [Flow] that emits whenever the underlying data changes, * [search] additionally matches against any of the note's hashtags
* so the list screen satisfies F7 (auto-refresh). * (case-insensitive equality).
* - Assign a fresh id (0 or 0L on construction) for new notes and use the
* ObjectBox-managed id once persisted.
* - Sort [observeAll] / [search] with favourites first, then by [Note.updatedAt]
* descending.
*/ */
interface NoteRepository { interface NoteRepository {
/** Stream of all notes, newest-first, favourites pinned to the top. */ /** Stream of all notes, newest-first, favourites pinned to the top. */
fun observeAll(): Flow<List<Note>> fun observeAll(): Flow<List<Note>>
/** /**
* Stream of notes whose [Note.content] contains [query] (case-insensitive), * Stream of notes whose [Note.content] contains [query] (case-insensitive)
* favourites first then newest-first. An empty / blank [query] returns * OR whose hashtags contain [query] as one of the names. Favourites
* the same list as [observeAll]. * first then newest-first. Blank [query] returns the same as
* [observeAll].
*/ */
fun search(query: String): Flow<List<Note>> fun search(query: String): Flow<List<Note>>
@@ -37,4 +35,50 @@ interface NoteRepository {
/** Toggle the favourite flag on a single note. */ /** Toggle the favourite flag on a single note. */
suspend fun setFavorite(id: Long, isFavorite: Boolean) suspend fun setFavorite(id: Long, isFavorite: Boolean)
// --- Filter streams (v0.3.0.0) ---
/** Only notes with `isFavorite = true`, sorted by updatedAt DESC. */
fun observeFavorites(): Flow<List<Note>>
/** Only notes that have zero hashtags, sorted by updatedAt DESC. */
fun observeUntagged(): Flow<List<Note>>
/** Only notes tagged with [name] (normalised form), sorted by updatedAt DESC. */
fun observeNotesForHashtag(name: String): Flow<List<Note>>
/**
* Every distinct hashtag, sorted by `lastUsedAt DESC` then
* `noteCount DESC` then `name ASC`. Each entry also carries the
* number of notes that use it.
*/
fun observeHashtagsByRecentUse(): Flow<List<HashtagUsage>>
// --- Hashtag autocomplete (v0.3.0.0) ---
/**
* Every distinct hashtag in the store, sorted by usage count DESC
* then name ASC. Used to populate the autocomplete "suggestions"
* list when the input is empty.
*/
fun observeAllHashtags(): Flow<List<String>>
/**
* Hashtags whose name starts with [prefix] (case-insensitive),
* sorted by usage count DESC then name ASC. Blank [prefix] is
* equivalent to [observeAllHashtags].
*/
fun searchHashtags(prefix: String): Flow<List<String>>
/**
* Add [name] to the note's hashtag set. Creates the hashtag row
* if it doesn't exist yet. Idempotent. No-op if the note already
* has the tag.
*/
suspend fun addHashtag(noteId: Long, name: String)
/**
* Remove [name] from the note's hashtag set. Idempotent. No-op if
* the note doesn't have the tag. The hashtag row itself is NOT
* auto-deleted (cleanup is the future "tag browser" feature).
*/
suspend fun removeHashtag(noteId: Long, name: String)
} }