Compare commits

...
1 Commits
Author SHA1 Message Date
Jean-Luc Makiolaandmakiolaj 1463b08d6f Release 1.3.2 (#170)
Release — F-Droid repo + Gitea/Codeberg release + Play / detect (push) Successful in 9s
Renovate / renovate (push) Successful in 2m0s
Release — F-Droid repo + Gitea/Codeberg release + Play / release (push) Successful in 18m41s
Release — F-Droid repo + Gitea/Codeberg release + Play / play (push) Successful in 1m7s
Bumps to 1.3.2 (1030299), dates the changelog and adds the What's New for all eight store locales.

- Keep home and task list clear of the navigation bar (#152, #165)
- Keep the edited description line above the keyboard (#158, #163)
- Drop reminders when a task loses its last date (#159, #161)
- Show when a list uses its own default reminders (#121, #168)
- Setting for the description shown in reminders (#156, #162)
- Raise SEQUENCE when uploading an edited task (#137, #169)

PR 169 had no CHANGELOG entry for #137, so this adds it.

Closes #121, closes #137, closes #152, closes #156, closes #158, closes #159

Co-authored-by: Jean-Luc Makiola <business@jeanlucmakiola.de>
Reviewed-on: https://codeberg.org/jlmakiola/agendula/pulls/170
2026-11-13 16:39:50 +01:00
53 changed files with 3419 additions and 143 deletions

No files matched your search

+38
View File
@@ -7,6 +7,44 @@ All notable changes to this project are documented here. The format follows
## [Unreleased]
## [1.3.2] - 2026-11-13
### Added
- A "Description in reminders" setting under Notifications sets how much of a
task's description a reminder shows: none, a short preview of up to three
lines (the new default), or all of it as before (#156).
### Changed
- A list with its own default reminders is easier to spot. The task editor
notes when the reminders it adds come from the list's defaults rather than
the general one, and Settings → Notifications counts the lists that use
their own and marks them in Per-list reminders (#121).
### Fixed
- With 3-button navigation, the navigation bar no longer covers the last home
search results, and in landscape it no longer covers the home screen, the
task list or the home top bar's buttons. The task details and editor no
longer leave an empty gap between the open keyboard and the text, nor does
the task list while typing in the quick-add bar. On tablets and in landscape
the screens now keep to a centred, readable width as intended (#152).
- Tapping into a long task description in the editor scrolls the line you
tapped above the keyboard as soon as it opens, instead of leaving it hidden
until you start typing (#158).
- Removing a task's last date also removes its reminders, so the task can be
saved again. Reminders you picked yourself come back when you set a new date
(#159).
- With CalDAV sync, ticking off a repeating task should now also move it on in
Apple Reminders, instead of leaving the old occurrence open next to the
completed copy. Edits Agendula uploads raise the task's `SEQUENCE`, which
Apple's apps use to tell a newer version; tasks with an organiser keep
theirs (#137).
- Sub-tasks of a repeating task start over when ticking off its current
occurrence moves it on to its next date, as in tasks.org: completed and
half-done ones open again, and dated ones move along with the task. Before,
the next occurrence showed them already ticked. Unticking gives them back
their state and dates, and repeating sub-tasks keep their own schedule
(#160).
## [1.3.1] - 2026-11-09
### Changed
+2 -2
View File
@@ -33,8 +33,8 @@ android {
// (1.0.x: 1.0.0 -> 10000; from 1.1.0: 1.1.0-beta.1 -> 1010001,
// 1.1.0 -> 1010099), and CI fails if the committed one doesn't match.
// See docs/RELEASING.md.
versionCode = 1030199
versionName = "1.3.1"
versionCode = 1030299
versionName = "1.3.2"
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
@@ -0,0 +1,775 @@
{
"formatVersion": 1,
"database": {
"version": 6,
"identityHash": "6c8058a22084f0af602bc2f23c949b3c",
"entities": [
{
"tableName": "accounts",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `display_name` TEXT NOT NULL, `principal_url` TEXT, `home_set_url` TEXT, `username` TEXT, `last_sync_at` INTEGER, `last_sync_error` TEXT, `label` TEXT)",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "displayName",
"columnName": "display_name",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "principalUrl",
"columnName": "principal_url",
"affinity": "TEXT"
},
{
"fieldPath": "homeSetUrl",
"columnName": "home_set_url",
"affinity": "TEXT"
},
{
"fieldPath": "username",
"columnName": "username",
"affinity": "TEXT"
},
{
"fieldPath": "lastSyncAt",
"columnName": "last_sync_at",
"affinity": "INTEGER"
},
{
"fieldPath": "lastSyncError",
"columnName": "last_sync_error",
"affinity": "TEXT"
},
{
"fieldPath": "label",
"columnName": "label",
"affinity": "TEXT"
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
}
},
{
"tableName": "task_lists",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `color` INTEGER NOT NULL, `account_id` INTEGER, `is_visible` INTEGER NOT NULL DEFAULT 1, `is_synced` INTEGER NOT NULL DEFAULT 1, `owner` TEXT, `is_read_only` INTEGER NOT NULL DEFAULT 0, `sort_order` INTEGER NOT NULL DEFAULT 0, `href` TEXT, `ctag` TEXT, `sync_token` TEXT, `is_dirty` INTEGER NOT NULL DEFAULT 0, FOREIGN KEY(`account_id`) REFERENCES `accounts`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "name",
"columnName": "name",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "color",
"columnName": "color",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "accountId",
"columnName": "account_id",
"affinity": "INTEGER"
},
{
"fieldPath": "isVisible",
"columnName": "is_visible",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "1"
},
{
"fieldPath": "isSynced",
"columnName": "is_synced",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "1"
},
{
"fieldPath": "owner",
"columnName": "owner",
"affinity": "TEXT"
},
{
"fieldPath": "isReadOnly",
"columnName": "is_read_only",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
},
{
"fieldPath": "sortOrder",
"columnName": "sort_order",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
},
{
"fieldPath": "href",
"columnName": "href",
"affinity": "TEXT"
},
{
"fieldPath": "ctag",
"columnName": "ctag",
"affinity": "TEXT"
},
{
"fieldPath": "syncToken",
"columnName": "sync_token",
"affinity": "TEXT"
},
{
"fieldPath": "isDirty",
"columnName": "is_dirty",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_task_lists_account_id",
"unique": false,
"columnNames": [
"account_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_task_lists_account_id` ON `${TABLE_NAME}` (`account_id`)"
}
],
"foreignKeys": [
{
"table": "accounts",
"onDelete": "SET NULL",
"onUpdate": "NO ACTION",
"columns": [
"account_id"
],
"referencedColumns": [
"id"
]
}
]
},
{
"tableName": "tasks",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `list_id` INTEGER NOT NULL, `uid` TEXT NOT NULL, `href` TEXT, `etag` TEXT, `title` TEXT, `description` TEXT, `location` TEXT, `url` TEXT, `color` INTEGER, `categories` TEXT NOT NULL DEFAULT '', `status` INTEGER NOT NULL DEFAULT 0, `percent_complete` INTEGER, `completed_at` INTEGER, `priority` INTEGER NOT NULL DEFAULT 0, `classification` INTEGER, `dtstart` INTEGER, `due` INTEGER, `duration` TEXT, `is_all_day` INTEGER NOT NULL DEFAULT 0, `timezone` TEXT, `rrule` TEXT, `rdate` TEXT, `exdate` TEXT, `recurrence_id` INTEGER, `master_id` INTEGER, `parent_id` INTEGER, `sort_order` INTEGER NOT NULL DEFAULT 0, `created_at` INTEGER, `last_modified` INTEGER, `sequence` INTEGER NOT NULL DEFAULT 0, `is_dirty` INTEGER NOT NULL DEFAULT 0, `is_deleted` INTEGER NOT NULL DEFAULT 0, `unknown_properties` TEXT, `reminders_off` INTEGER NOT NULL DEFAULT 0, FOREIGN KEY(`list_id`) REFERENCES `task_lists`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`master_id`) REFERENCES `tasks`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`parent_id`) REFERENCES `tasks`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "listId",
"columnName": "list_id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "uid",
"columnName": "uid",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "href",
"columnName": "href",
"affinity": "TEXT"
},
{
"fieldPath": "etag",
"columnName": "etag",
"affinity": "TEXT"
},
{
"fieldPath": "title",
"columnName": "title",
"affinity": "TEXT"
},
{
"fieldPath": "description",
"columnName": "description",
"affinity": "TEXT"
},
{
"fieldPath": "location",
"columnName": "location",
"affinity": "TEXT"
},
{
"fieldPath": "url",
"columnName": "url",
"affinity": "TEXT"
},
{
"fieldPath": "color",
"columnName": "color",
"affinity": "INTEGER"
},
{
"fieldPath": "categories",
"columnName": "categories",
"affinity": "TEXT",
"notNull": true,
"defaultValue": "''"
},
{
"fieldPath": "status",
"columnName": "status",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
},
{
"fieldPath": "percentComplete",
"columnName": "percent_complete",
"affinity": "INTEGER"
},
{
"fieldPath": "completedAt",
"columnName": "completed_at",
"affinity": "INTEGER"
},
{
"fieldPath": "priority",
"columnName": "priority",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
},
{
"fieldPath": "classification",
"columnName": "classification",
"affinity": "INTEGER"
},
{
"fieldPath": "dtstart",
"columnName": "dtstart",
"affinity": "INTEGER"
},
{
"fieldPath": "due",
"columnName": "due",
"affinity": "INTEGER"
},
{
"fieldPath": "duration",
"columnName": "duration",
"affinity": "TEXT"
},
{
"fieldPath": "isAllDay",
"columnName": "is_all_day",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
},
{
"fieldPath": "timezone",
"columnName": "timezone",
"affinity": "TEXT"
},
{
"fieldPath": "rrule",
"columnName": "rrule",
"affinity": "TEXT"
},
{
"fieldPath": "rdate",
"columnName": "rdate",
"affinity": "TEXT"
},
{
"fieldPath": "exdate",
"columnName": "exdate",
"affinity": "TEXT"
},
{
"fieldPath": "recurrenceId",
"columnName": "recurrence_id",
"affinity": "INTEGER"
},
{
"fieldPath": "masterId",
"columnName": "master_id",
"affinity": "INTEGER"
},
{
"fieldPath": "parentId",
"columnName": "parent_id",
"affinity": "INTEGER"
},
{
"fieldPath": "sortOrder",
"columnName": "sort_order",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
},
{
"fieldPath": "createdAt",
"columnName": "created_at",
"affinity": "INTEGER"
},
{
"fieldPath": "lastModified",
"columnName": "last_modified",
"affinity": "INTEGER"
},
{
"fieldPath": "sequence",
"columnName": "sequence",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
},
{
"fieldPath": "isDirty",
"columnName": "is_dirty",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
},
{
"fieldPath": "isDeleted",
"columnName": "is_deleted",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
},
{
"fieldPath": "unknownProperties",
"columnName": "unknown_properties",
"affinity": "TEXT"
},
{
"fieldPath": "remindersOff",
"columnName": "reminders_off",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_tasks_list_id_is_deleted",
"unique": false,
"columnNames": [
"list_id",
"is_deleted"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_tasks_list_id_is_deleted` ON `${TABLE_NAME}` (`list_id`, `is_deleted`)"
},
{
"name": "index_tasks_parent_id",
"unique": false,
"columnNames": [
"parent_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_tasks_parent_id` ON `${TABLE_NAME}` (`parent_id`)"
},
{
"name": "index_tasks_master_id_recurrence_id",
"unique": false,
"columnNames": [
"master_id",
"recurrence_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_tasks_master_id_recurrence_id` ON `${TABLE_NAME}` (`master_id`, `recurrence_id`)"
},
{
"name": "index_tasks_is_dirty",
"unique": false,
"columnNames": [
"is_dirty"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_tasks_is_dirty` ON `${TABLE_NAME}` (`is_dirty`)"
},
{
"name": "index_tasks_list_id_uid_recurrence_id",
"unique": true,
"columnNames": [
"list_id",
"uid",
"recurrence_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_tasks_list_id_uid_recurrence_id` ON `${TABLE_NAME}` (`list_id`, `uid`, `recurrence_id`)"
}
],
"foreignKeys": [
{
"table": "task_lists",
"onDelete": "CASCADE",
"onUpdate": "NO ACTION",
"columns": [
"list_id"
],
"referencedColumns": [
"id"
]
},
{
"table": "tasks",
"onDelete": "CASCADE",
"onUpdate": "NO ACTION",
"columns": [
"master_id"
],
"referencedColumns": [
"id"
]
},
{
"table": "tasks",
"onDelete": "SET NULL",
"onUpdate": "NO ACTION",
"columns": [
"parent_id"
],
"referencedColumns": [
"id"
]
}
]
},
{
"tableName": "task_alarms",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `task_id` INTEGER NOT NULL, `minutes_before` INTEGER NOT NULL, `reference` TEXT NOT NULL DEFAULT 'DUE', `message` TEXT, `uid` TEXT NOT NULL DEFAULT '', `raw` TEXT, FOREIGN KEY(`task_id`) REFERENCES `tasks`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "taskId",
"columnName": "task_id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "minutesBefore",
"columnName": "minutes_before",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "reference",
"columnName": "reference",
"affinity": "TEXT",
"notNull": true,
"defaultValue": "'DUE'"
},
{
"fieldPath": "message",
"columnName": "message",
"affinity": "TEXT"
},
{
"fieldPath": "uid",
"columnName": "uid",
"affinity": "TEXT",
"notNull": true,
"defaultValue": "''"
},
{
"fieldPath": "raw",
"columnName": "raw",
"affinity": "TEXT"
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_task_alarms_task_id",
"unique": false,
"columnNames": [
"task_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_task_alarms_task_id` ON `${TABLE_NAME}` (`task_id`)"
}
],
"foreignKeys": [
{
"table": "tasks",
"onDelete": "CASCADE",
"onUpdate": "NO ACTION",
"columns": [
"task_id"
],
"referencedColumns": [
"id"
]
}
]
},
{
"tableName": "advanced_occurrences",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`copy_id` INTEGER NOT NULL, `master_id` INTEGER NOT NULL, `anchor` INTEGER NOT NULL, `advanced_to` INTEGER NOT NULL, `prior_dtstart` INTEGER, `prior_due` INTEGER, `prior_status` INTEGER NOT NULL, `prior_percent_complete` INTEGER, `prior_completed_at` INTEGER, `spent` INTEGER NOT NULL, `rule_after` TEXT, `dropped_exdates` TEXT NOT NULL DEFAULT '', `from_override` INTEGER NOT NULL, `undoable` INTEGER NOT NULL DEFAULT 1, `settled` INTEGER NOT NULL DEFAULT 0, `reset_subtasks` TEXT NOT NULL DEFAULT '', PRIMARY KEY(`copy_id`), FOREIGN KEY(`copy_id`) REFERENCES `tasks`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`master_id`) REFERENCES `tasks`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
"fields": [
{
"fieldPath": "copyId",
"columnName": "copy_id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "masterId",
"columnName": "master_id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "anchor",
"columnName": "anchor",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "advancedTo",
"columnName": "advanced_to",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "priorDtstart",
"columnName": "prior_dtstart",
"affinity": "INTEGER"
},
{
"fieldPath": "priorDue",
"columnName": "prior_due",
"affinity": "INTEGER"
},
{
"fieldPath": "priorStatus",
"columnName": "prior_status",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "priorPercentComplete",
"columnName": "prior_percent_complete",
"affinity": "INTEGER"
},
{
"fieldPath": "priorCompletedAt",
"columnName": "prior_completed_at",
"affinity": "INTEGER"
},
{
"fieldPath": "spent",
"columnName": "spent",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "ruleAfter",
"columnName": "rule_after",
"affinity": "TEXT"
},
{
"fieldPath": "droppedExdates",
"columnName": "dropped_exdates",
"affinity": "TEXT",
"notNull": true,
"defaultValue": "''"
},
{
"fieldPath": "fromOverride",
"columnName": "from_override",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "undoable",
"columnName": "undoable",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "1"
},
{
"fieldPath": "settled",
"columnName": "settled",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
},
{
"fieldPath": "resetSubtasks",
"columnName": "reset_subtasks",
"affinity": "TEXT",
"notNull": true,
"defaultValue": "''"
}
],
"primaryKey": {
"autoGenerate": false,
"columnNames": [
"copy_id"
]
},
"indices": [
{
"name": "index_advanced_occurrences_master_id_anchor",
"unique": false,
"columnNames": [
"master_id",
"anchor"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_advanced_occurrences_master_id_anchor` ON `${TABLE_NAME}` (`master_id`, `anchor`)"
}
],
"foreignKeys": [
{
"table": "tasks",
"onDelete": "CASCADE",
"onUpdate": "NO ACTION",
"columns": [
"copy_id"
],
"referencedColumns": [
"id"
]
},
{
"table": "tasks",
"onDelete": "CASCADE",
"onUpdate": "NO ACTION",
"columns": [
"master_id"
],
"referencedColumns": [
"id"
]
}
]
},
{
"tableName": "advanced_detached",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `copy_id` INTEGER NOT NULL, `anchor` INTEGER NOT NULL, `task_id` INTEGER, FOREIGN KEY(`copy_id`) REFERENCES `advanced_occurrences`(`copy_id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`task_id`) REFERENCES `tasks`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "copyId",
"columnName": "copy_id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "anchor",
"columnName": "anchor",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "taskId",
"columnName": "task_id",
"affinity": "INTEGER"
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_advanced_detached_copy_id",
"unique": false,
"columnNames": [
"copy_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_advanced_detached_copy_id` ON `${TABLE_NAME}` (`copy_id`)"
},
{
"name": "index_advanced_detached_task_id",
"unique": false,
"columnNames": [
"task_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_advanced_detached_task_id` ON `${TABLE_NAME}` (`task_id`)"
}
],
"foreignKeys": [
{
"table": "advanced_occurrences",
"onDelete": "CASCADE",
"onUpdate": "NO ACTION",
"columns": [
"copy_id"
],
"referencedColumns": [
"copy_id"
]
},
{
"table": "tasks",
"onDelete": "SET NULL",
"onUpdate": "NO ACTION",
"columns": [
"task_id"
],
"referencedColumns": [
"id"
]
}
]
}
],
"setupQueries": [
"CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
"INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '6c8058a22084f0af602bc2f23c949b3c')"
]
}
}
@@ -14,6 +14,7 @@ import org.junit.Test
import org.junit.runner.RunWith
import kotlin.time.Clock
import kotlin.time.Duration.Companion.days
import kotlin.time.Duration.Companion.hours
import kotlin.time.Instant
/**
@@ -700,6 +701,180 @@ class RoomTasksDataSourceTest {
assertThat(db.tasks().overrides(id)).hasSize(1)
}
@Test
fun movingARoutineOnReopensItsCompletedSubtasks() {
val at = now
val id = source.insertTask(form(title = "Routine"))
makeRecurring(id, at)
val done = source.insertTask(form(title = "Step").copy(parentId = id))
val nested = source.insertTask(form(title = "Nested").copy(parentId = done))
val cancelled = source.insertTask(form(title = "Skipped").copy(parentId = id))
val daily = source.insertTask(form(title = "Daily part").copy(parentId = id))
makeRecurring(daily, at, rule = "FREQ=DAILY")
source.setCompleted(done, completed = true)
source.setCompleted(nested, completed = true)
source.setCancelled(cancelled, cancelled = true)
source.setCompletedInstance(daily, at, completed = true)
source.setCompletedInstance(id, at, completed = true)
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at + 7.days)
assertThat(db.tasks().entity(done)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
assertThat(db.tasks().entity(done)!!.completedAt).isNull()
assertThat(db.tasks().entity(nested)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
assertThat(db.tasks().entity(cancelled)!!.status).isEqualTo(TaskStatus.CANCELLED)
// A recurring subtask has its own series, and its closed occurrence stays closed.
assertThat(db.tasks().overrides(daily).single().status).isEqualTo(TaskStatus.COMPLETED)
}
@Test
fun aHalfDoneSubtaskStartsOverToo() {
val at = now
val id = source.insertTask(form(title = "Routine"))
makeRecurring(id, at)
val step = source.insertTask(form(title = "Step", percentComplete = 40).copy(parentId = id))
db.tasks().update(db.tasks().entity(step)!!.copy(status = TaskStatus.IN_PROCESS, percentComplete = 40))
source.setCompletedInstance(id, at, completed = true)
assertThat(db.tasks().entity(step)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
assertThat(db.tasks().entity(step)!!.percentComplete).isNull()
}
@Test
fun movingARoutineBackRestoresTheSubtasksItReset() {
val at = now
val id = source.insertTask(form(title = "Routine"))
makeRecurring(id, at)
val done = source.insertTask(form(title = "Step").copy(parentId = id))
val touched = source.insertTask(form(title = "Touched since").copy(parentId = id))
source.setCompleted(done, completed = true)
source.setCompleted(touched, completed = true)
val completedAt = db.tasks().entity(done)!!.completedAt
source.setCompletedInstance(id, at, completed = true)
db.tasks().update(db.tasks().entity(touched)!!.copy(percentComplete = 30))
source.setCompletedInstance(id, at, completed = false)
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at)
assertThat(db.tasks().entity(done)!!.status).isEqualTo(TaskStatus.COMPLETED)
assertThat(db.tasks().entity(done)!!.completedAt).isEqualTo(completedAt)
// Changed after the reset: the user's state wins.
assertThat(db.tasks().entity(touched)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
assertThat(db.tasks().entity(touched)!!.percentComplete).isEqualTo(30)
}
@Test
fun aDatedSubtaskMovesWithItsRoutineAndBack() {
val at = now
val id = source.insertTask(form(title = "Routine"))
makeRecurring(id, at)
val step = source.insertTask(form(title = "Step", due = at + 1.days).copy(parentId = id))
val undated = source.insertTask(form(title = "Undated").copy(parentId = id))
source.setCompleted(step, completed = true)
val due = db.tasks().entity(step)!!.due!!
source.setCompletedInstance(id, at, completed = true)
// A week of wall-clock time: an hour either way across a DST change.
assertThat(db.tasks().entity(step)!!.due!! - due).isIn(com.google.common.collect.Range.closed(7.days - 1.hours, 7.days + 1.hours))
assertThat(db.tasks().entity(step)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
assertThat(db.tasks().entity(undated)!!.due).isNull()
source.setCompletedInstance(id, at, completed = false)
assertThat(db.tasks().entity(step)!!.due).isEqualTo(due)
assertThat(db.tasks().entity(step)!!.status).isEqualTo(TaskStatus.COMPLETED)
}
@Test
fun aMarkedCopyUnderARoutineIsLeftAlone() {
val at = now
val id = source.insertTask(form(title = "Routine"))
makeRecurring(id, at)
val routineUid = db.tasks().entity(id)!!.uid
val copy = source.insertTask(form(title = "Daily part").copy(parentId = id))
val elsewhere = source.insertTask(form(title = "Moved here").copy(parentId = id))
source.setCompleted(copy, completed = true)
source.setCompleted(elsewhere, completed = true)
db.tasks().update(db.tasks().entity(copy)!!.copy(unknownProperties = "X-AGENDULA-TICK-COPY:$routineUid"))
db.tasks().update(db.tasks().entity(elsewhere)!!.copy(unknownProperties = "X-AGENDULA-TICK-COPY:another-parent"))
source.setCompletedInstance(id, at, completed = true)
assertThat(db.tasks().entity(copy)!!.status).isEqualTo(TaskStatus.COMPLETED)
// Its marker names a parent it no longer sits under: an ordinary sub-task here.
assertThat(db.tasks().entity(elsewhere)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
}
@Test
fun aSubtaskInAnotherListStartsOverAndComesBack() {
val at = now
val id = source.insertTask(form(title = "Routine"))
makeRecurring(id, at)
val otherList = source.createLocalList("Errands", 0)
val step = source.insertTask(form(title = "Elsewhere", due = at + 1.days).copy(listId = otherList, parentId = id))
source.setCompleted(step, completed = true)
val due = db.tasks().entity(step)!!.due
source.setCompletedInstance(id, at, completed = true)
assertThat(db.tasks().entity(step)!!.listId).isEqualTo(otherList)
assertThat(db.tasks().entity(step)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
assertThat(db.tasks().entity(step)!!.due).isNotEqualTo(due)
source.setCompletedInstance(id, at, completed = false)
assertThat(db.tasks().entity(step)!!.status).isEqualTo(TaskStatus.COMPLETED)
assertThat(db.tasks().entity(step)!!.due).isEqualTo(due)
}
@Test
fun aSubtaskCompletedBeforeTheClosedCycleIsLeftAlone() {
val at = now
val id = source.insertTask(form(title = "Routine"))
makeRecurring(id, at)
val old = source.insertTask(form(title = "Old copy", due = at - 30.days).copy(parentId = id))
source.setCompleted(old, completed = true)
db.tasks().update(db.tasks().entity(old)!!.copy(completedAt = at - 30.days))
source.setCompletedInstance(id, at, completed = true)
assertThat(db.tasks().entity(old)!!.status).isEqualTo(TaskStatus.COMPLETED)
assertThat(db.tasks().entity(old)!!.due).isEqualTo(at - 30.days)
}
@Test
fun aRestoredSubtaskTickedSinceKeepsItsStateAndGetsItsDateBack() {
val at = now
val id = source.insertTask(form(title = "Routine"))
makeRecurring(id, at)
val step = source.insertTask(form(title = "Step", due = at + 1.days).copy(parentId = id))
source.setCompleted(step, completed = true)
val due = db.tasks().entity(step)!!.due
source.setCompletedInstance(id, at, completed = true)
source.setCompleted(step, completed = true)
source.setCompletedInstance(id, at, completed = false)
assertThat(db.tasks().entity(step)!!.status).isEqualTo(TaskStatus.COMPLETED)
assertThat(db.tasks().entity(step)!!.due).isEqualTo(due)
}
@Test
fun aRoutineTickedOnItsLastOccurrenceLeavesItsSubtasksDone() {
val at = now
val id = source.insertTask(form(title = "Once more"))
makeRecurring(id, at, rule = "FREQ=WEEKLY;COUNT=1")
val step = source.insertTask(form(title = "Step").copy(parentId = id))
source.setCompleted(step, completed = true)
source.setCompletedInstance(id, at, completed = true)
assertThat(db.tasks().entity(id)!!.status).isEqualTo(TaskStatus.COMPLETED)
assertThat(db.tasks().entity(step)!!.status).isEqualTo(TaskStatus.COMPLETED)
}
@Test
fun aSeriesReshapedSinceIsNotMovedBack() {
val at = now
@@ -174,6 +174,25 @@ class TasksDatabaseMigrationTest {
}
}
@Test
fun addsAnEmptyResetSubtasksRecord() {
helper.createDatabase(TEST_DB, 5).use { db ->
db.execSQL("INSERT INTO task_lists (id, name, color) VALUES (1, 'Personal', 0)")
db.execSQL("INSERT INTO tasks (id, list_id, uid) VALUES (1, 1, 'a'), (2, 1, 'b')")
db.execSQL(
"INSERT INTO advanced_occurrences (copy_id, master_id, anchor, advanced_to, prior_status, spent, from_override) " +
"VALUES (2, 1, 0, 1, 0, 1, 0)",
)
}
helper.runMigrationsAndValidate(TEST_DB, 6, true, TasksDatabase.MIGRATION_5_6).use { db ->
db.query("SELECT reset_subtasks FROM advanced_occurrences").use { c ->
assertThat(c.moveToFirst()).isTrue()
assertThat(c.getString(0)).isEmpty()
}
}
}
private companion object {
const val TEST_DB = "migration-test.db"
}
@@ -417,8 +417,14 @@ class CollectionSyncer(
return@forEach
}
val body = serialize(local) ?: return@forEach
if (href == null) createResource(local, body) else updateResource(local, href, body)
if (href == null) {
val body = serialize(local) ?: return@forEach
createResource(local, body)
} else {
val revised = local.revised()
val body = serialize(revised) ?: return@forEach
updateResource(revised, href, body)
}
}
}
@@ -1081,6 +1087,16 @@ class CollectionSyncer(
/** What gets serialised: a deleted override is simply absent. */
val live: List<TaskEntity> = rows.filterNot { it.isDeleted }
/**
* With `SEQUENCE` raised on each changed row. Apple's clients keep their
* cached copy of a task whose `SEQUENCE` did not move (#137).
*/
fun revised(): LocalResource = copy(
rows = rows.map { row ->
if (row.isDirty && !row.isDeleted && VTodoMapper.revisesSequence(row)) row.copy(sequence = row.sequence + 1) else row
},
)
}
private companion object {
@@ -135,6 +135,7 @@ class RoomSyncStore @Inject constructor(
if (rows.isEmpty()) return
database.runInTransaction {
database.tasks().markSynced(rows.map { it.id }, href, eTag)
rows.forEach { database.tasks().raiseSequence(it.id, it.sequence) }
// Changed while the body was on its way, by a tick or an edit: still owed to the server.
rows.forEach { database.tasks().dirtyIfChangedSince(it.id, it.lastModified) }
// The server now holds each series as far as the body moved it; a tick
@@ -89,7 +89,7 @@ object DataProvideModule {
// backed-up `.db` does not. The backup rules carry all three files and
// the app checkpoints on ON_STOP.
.setJournalMode(RoomDatabase.JournalMode.WRITE_AHEAD_LOGGING)
.addMigrations(TasksDatabase.MIGRATION_1_2, TasksDatabase.MIGRATION_2_3, TasksDatabase.MIGRATION_3_4, TasksDatabase.MIGRATION_4_5)
.addMigrations(TasksDatabase.MIGRATION_1_2, TasksDatabase.MIGRATION_2_3, TasksDatabase.MIGRATION_3_4, TasksDatabase.MIGRATION_4_5, TasksDatabase.MIGRATION_5_6)
.build()
/**
@@ -54,6 +54,9 @@ fun TimeFormatPref.is24Hour(systemIs24Hour: Boolean): Boolean = when (this) {
TimeFormatPref.TWENTY_FOUR_HOUR -> true
}
/** How much of a task's description a due reminder shows when expanded. */
enum class ReminderDescription { HIDDEN, SHORT, FULL }
const val DEFAULT_SNOOZE_MINUTES = 10
/** Done starts folded away, to keep the open tasks in focus. */ val DEFAULT_COLLAPSED_SECTIONS: Set<TaskSection> = setOf(TaskSection.COMPLETED)
@@ -103,6 +106,7 @@ data class Settings(
val sortOrder: TaskSortOrder = TaskSortOrder.DUE,
/** How long a reminder's "Snooze" action puts it off. */
val snoozeMinutes: Int = DEFAULT_SNOOZE_MINUTES,
val reminderDescription: ReminderDescription = ReminderDescription.SHORT,
val timeFormat: TimeFormatPref = TimeFormatPref.AUTO,
/** The first day of the week; `null` follows the locale. */
val weekStart: DayOfWeek? = null,
@@ -138,6 +142,14 @@ data class Settings(
/** The default reminders a task in [listId] takes — the one rule for which default applies. */
fun defaultRemindersFor(listId: Long, allDay: Boolean): List<TaskReminder> =
(if (allDay) allDayReminderLeadsFor(listId) else reminderLeadsFor(listId)).map { it.asTaskReminder() }
/** Whether [listId] has its own default reminders for [allDay] tasks (an override, "none" included). */
fun hasOwnReminders(listId: Long, allDay: Boolean): Boolean =
listId in (if (allDay) perListAllDayReminderOverride else perListReminderOverride)
/** Whether [listId] has its own default reminders for timed or all-day tasks. */
fun hasOwnReminders(listId: Long): Boolean =
hasOwnReminders(listId, allDay = false) || hasOwnReminders(listId, allDay = true)
}
/** App preferences, backed by DataStore. Mirrors Calendula's prefs shape. */
@@ -171,6 +183,9 @@ class SettingsPrefs @Inject constructor(
sortOrder = p[SORT_ORDER]?.let { runCatching { TaskSortOrder.valueOf(it) }.getOrNull() }
?: TaskSortOrder.DUE,
snoozeMinutes = p[SNOOZE_MINUTES]?.takeIf { it > 0 } ?: DEFAULT_SNOOZE_MINUTES,
reminderDescription = p[REMINDER_DESCRIPTION]
?.let { runCatching { ReminderDescription.valueOf(it) }.getOrNull() }
?: ReminderDescription.SHORT,
timeFormat = p[TIME_FORMAT]?.let { runCatching { TimeFormatPref.valueOf(it) }.getOrNull() }
?: TimeFormatPref.AUTO,
autofocusTitle = p[AUTOFOCUS_TITLE] ?: true,
@@ -199,6 +214,9 @@ class SettingsPrefs @Inject constructor(
suspend fun setSnoozeMinutes(minutes: Int) = dataStore.edit { it[SNOOZE_MINUTES] = minutes.coerceAtLeast(1) }
suspend fun setReminderDescription(pref: ReminderDescription) =
dataStore.edit { it[REMINDER_DESCRIPTION] = pref.name }
suspend fun setSyncIntervalMinutes(minutes: Int) = dataStore.edit { it[SYNC_INTERVAL] = minutes }
suspend fun setPushEnabled(enabled: Boolean) = dataStore.edit { it[PUSH_ENABLED] = enabled }
@@ -345,6 +363,7 @@ class SettingsPrefs @Inject constructor(
val DEFAULT_EDIT_FIELDS = stringSetPreferencesKey("default_edit_fields")
val SORT_ORDER = stringPreferencesKey("sort_order")
val SNOOZE_MINUTES = intPreferencesKey("snooze_minutes")
val REMINDER_DESCRIPTION = stringPreferencesKey("reminder_description")
val TIME_FORMAT = stringPreferencesKey("time_format")
val WEEK_START = stringPreferencesKey("week_start")
val AUTOFOCUS_TITLE = booleanPreferencesKey("autofocus_title")
@@ -12,12 +12,14 @@ import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import android.text.format.DateFormat
import android.util.TypedValue
import androidx.core.app.NotificationCompat
import androidx.core.app.NotificationManagerCompat
import androidx.core.content.ContextCompat
import androidx.core.content.edit
import de.jeanlucmakiola.agendula.MainActivity
import de.jeanlucmakiola.agendula.R
import de.jeanlucmakiola.agendula.data.prefs.ReminderDescription
import de.jeanlucmakiola.agendula.data.prefs.Settings
import de.jeanlucmakiola.agendula.domain.readableDescription
import de.jeanlucmakiola.agendula.data.prefs.is24Hour
@@ -30,6 +32,7 @@ import de.jeanlucmakiola.agendula.domain.calendarDate
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import java.text.BreakIterator
import java.time.Instant as JInstant
import java.time.LocalDate
import java.time.ZoneId
@@ -86,7 +89,9 @@ class TaskNotifier @Inject constructor(
),
)
}
val description = task.description?.readableDescription()?.trim()?.takeIf { it.isNotBlank() }
val description = reminderBody(settings.reminderDescription, lineChars()) {
task.description?.readableDescription()
}
val tapIntent = PendingIntent.getActivity(
context,
task.taskId.toInt(),
@@ -119,6 +124,16 @@ class TaskNotifier @Inject constructor(
NotificationManagerCompat.from(context).notify(task.taskId.toString(), NOTIFICATION_ID, notification)
}
/** Characters per line of an expanded notification on this screen, at the user's font size. */
private fun lineChars(): Int {
val res = context.resources
val widthDp = (res.configuration.screenWidthDp - NOTIFICATION_INSET_DP).toFloat()
return notificationLineChars(
textWidthPx = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, widthDp, res.displayMetrics),
textSizePx = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, NOTIFICATION_TEXT_SP, res.displayMetrics),
)
}
fun cancel(taskId: Long) {
NotificationManagerCompat.from(context).cancel(taskId.toString(), NOTIFICATION_ID)
}
@@ -277,3 +292,163 @@ internal fun expandedText(dueLine: String?, description: String?): String? = whe
dueLine == null -> description
else -> "$dueLine\n\n$description"
}
/** Characters per line assumed when the screen is not known. */
internal const val NOTIFICATION_LINE_CHARS = 40
/** A notification's body text size. */
internal const val NOTIFICATION_TEXT_SP = 14f
/** Width the expanded text doesn't get: the shade's margins, the template's padding and its icon column. */
internal const val NOTIFICATION_INSET_DP = 2 * 16 + 2 * 16 + 40
/** Average glyph advance as a share of the text size, for Latin body text. */
private const val AVERAGE_CHAR_EM = 0.52f
/** How many average characters fit on a [textWidthPx] wide line of [textSizePx] text. */
internal fun notificationLineChars(textWidthPx: Float, textSizePx: Float): Int =
if (textWidthPx <= 0f || textSizePx <= 0f) NOTIFICATION_LINE_CHARS
else (textWidthPx / (textSizePx * AVERAGE_CHAR_EM)).toInt().coerceAtLeast(10)
/**
* The description a reminder shows, as [mode] asks; null when there is none to
* show. [description] is only read when the mode shows it.
*/
internal fun reminderBody(
mode: ReminderDescription,
lineChars: Int = NOTIFICATION_LINE_CHARS,
description: () -> String?,
): String? {
if (mode == ReminderDescription.HIDDEN) return null
val text = description()?.trim()?.takeIf { it.isNotBlank() } ?: return null
return when (mode) {
ReminderDescription.HIDDEN -> null
ReminderDescription.SHORT -> shortDescription(text, lineChars = lineChars)
ReminderDescription.FULL -> text
}
}
/**
* [description] cut to about [maxLines] lines of an expanded notification,
* ending in an ellipsis when anything was left out. A long line counts as the
* lines it wraps to and a blank line as one; text that fits comes back unchanged.
*/
internal fun shortDescription(
description: String,
maxLines: Int = 3,
lineChars: Int = NOTIFICATION_LINE_CHARS,
): String {
val perLine = lineChars.coerceAtLeast(2)
val kept = mutableListOf<String>()
var rowsLeft = maxLines
val lines = description.lineSequence().iterator()
while (lines.hasNext()) {
val line = lines.next()
val last = !lines.hasNext()
val width = displayWidth(line)
val rows = ((width + perLine - 1) / perLine).coerceAtLeast(1)
// The ellipsis after a line that ends the budget needs a cell of its own.
val fits = rows < rowsLeft || (rows == rowsLeft && (last || width < rows * perLine))
if (fits) {
if (last) return description
kept += line
rowsLeft -= rows
if (rowsLeft == 0) return ellipsize(kept)
continue
}
if (rowsLeft > 0) kept += cutAtWord(line, rowsLeft * perLine - 1)
return ellipsize(kept)
}
return description
}
private fun ellipsize(lines: List<String>): String =
lines.joinToString("\n").trimEnd { it.isWhitespace() || it in ".,;:" } + "…"
/** [line] cut to at most [max] cells, at a word break when there is one, never inside a character. */
private fun cutAtWord(line: String, max: Int): String {
var end = 0
var width = 0
forEachGrapheme(line) { _, clusterEnd, cells ->
width += cells
if (width > max) return@forEachGrapheme false
end = clusterEnd
true
}
if (end >= line.length || line[end].isWhitespace()) return line.substring(0, end)
val cut = line.substring(0, end)
val space = cut.indexOfLast { it.isWhitespace() }
return if (space > end / 2) cut.substring(0, space) else cut
}
/** How many cells [text] takes; see [clusterCells]. */
internal fun displayWidth(text: String): Int {
var width = 0
forEachGrapheme(text) { _, _, cells ->
width += cells
true
}
return width
}
/** Calls [action] with each grapheme cluster's bounds and cells, until it returns false. */
private inline fun forEachGrapheme(text: String, action: (start: Int, end: Int, cells: Int) -> Boolean) {
val clusters = BreakIterator.getCharacterInstance()
clusters.setText(text)
var start = clusters.first()
var end = clusters.next()
while (end != BreakIterator.DONE) {
if (!action(start, end, clusterCells(text, start, end))) return
start = end
end = clusters.next()
}
}
/**
* Cells one grapheme cluster takes: none for lone marks and selectors, two for
* emoji and East Asian wide characters, one otherwise.
*/
private fun clusterCells(text: String, start: Int, end: Int): Int {
var base = -1
var emoji = false
var i = start
while (i < end) {
val codePoint = text.codePointAt(i)
if (codePoint == EMOJI_PRESENTATION || isPictographic(codePoint)) emoji = true
if (base < 0 && !isZeroWidth(codePoint)) base = codePoint
i += Character.charCount(codePoint)
}
return when {
base < 0 -> 0
emoji || WIDE_RANGES.any { base in it } -> 2
else -> 1
}
}
private const val EMOJI_PRESENTATION = 0xFE0F
private fun isZeroWidth(codePoint: Int): Boolean = when (Character.getType(codePoint).toByte()) {
Character.NON_SPACING_MARK, Character.ENCLOSING_MARK, Character.FORMAT -> true
else -> codePoint in 0xFE00..0xFE0F || codePoint in 0xE0100..0xE01EF
}
/** Emoji blocks, approximating Extended_Pictographic without ICU. */
private fun isPictographic(codePoint: Int): Boolean =
codePoint in 0x1F000..0x1FAFF || codePoint in 0x2600..0x27BF ||
codePoint in 0x2300..0x23FF || codePoint in 0x2B00..0x2BFF
/** East Asian Wide and Fullwidth: Hangul, CJK punctuation, kana, Han, fullwidth forms. */
private val WIDE_RANGES = listOf(
0x1100..0x115F,
0x2E80..0x303E,
0x3041..0x33FF,
0x3400..0x4DBF,
0x4E00..0x9FFF,
0xA000..0xA4CF,
0xAC00..0xD7A3,
0xF900..0xFAFF,
0xFE30..0xFE4F,
0xFF00..0xFF60,
0xFFE0..0xFFE6,
0x20000..0x3FFFD,
)
@@ -25,6 +25,8 @@ import de.jeanlucmakiola.agendula.domain.TaskForm
import de.jeanlucmakiola.agendula.domain.TaskList
import de.jeanlucmakiola.agendula.domain.export.ExportTask
import de.jeanlucmakiola.agendula.domain.normalizeTags
import de.jeanlucmakiola.agendula.domain.statusFromInt
import de.jeanlucmakiola.agendula.domain.toInt
import de.jeanlucmakiola.agendula.domain.recurrence.ExpansionWindow
import de.jeanlucmakiola.agendula.domain.recurrence.RecurrenceExpander
import de.jeanlucmakiola.agendula.domain.recurrence.RecurrenceSpec
@@ -135,21 +137,8 @@ class AndroidTasksDataSource @Inject constructor(
* the window still counts. All columns and a lenient `_deleted`, as in
* [exportTasks], since the table's shape varies across providers.
*/
override fun subtaskIds(parentTaskId: Long): List<Long> = resolver.query(
TasksContract.tasksUri(authority()),
null,
"${Tasks.PARENT_ID} = ? AND (${Tasks.DELETED} IS NULL OR ${Tasks.DELETED} = 0)",
arrayOf(parentTaskId.toString()),
null,
)?.use { c ->
val r = CursorColumnReader(c)
buildList {
while (c.moveToNext()) {
if (r.getLong(Tasks.ORIGINAL_INSTANCE_ID) != null) continue
r.getLong(Tasks.ID)?.takeIf { it != parentTaskId }?.let(::add)
}
}
} ?: emptyList()
override fun subtaskIds(parentTaskId: Long): List<Long> =
childRows(authority(), parentTaskId, projection = null) { it.getLong(Tasks.ID) }
/**
* All columns and no sort: the instances view differs across provider
@@ -197,22 +186,18 @@ class AndroidTasksDataSource @Inject constructor(
/**
* Rows of [uri] whose [idColumn] is one of [ids], in chunks that stay under
* SQLite's bound-argument limit, each mapped by [read] (null rows dropped).
* A null [projection] reads all columns, for tables whose shape varies.
*/
private fun <T : Any> queryByIds(
uri: Uri,
projection: Array<String>,
projection: Array<String>?,
idColumn: String,
ids: Collection<Long>,
filter: String? = null,
filterArgs: List<String> = emptyList(),
sortOrder: String? = null,
read: (ColumnReader) -> T?,
): List<T> = ids.distinct().chunked(MAX_SQL_ARGS - filterArgs.size).flatMap { chunk ->
val selection = buildString {
append("$idColumn IN (${chunk.joinToString(",") { "?" }})")
if (filter != null) append(" AND ($filter)")
}
val args = (chunk.map(Long::toString) + filterArgs).toTypedArray()
): List<T> = inSelections(idColumn, ids, filter, filterArgs).flatMap { (selection, args) ->
resolver.query(uri, projection, selection, args, sortOrder)?.use { c ->
val reader = CursorColumnReader(c)
buildList { while (c.moveToNext()) read(reader)?.let(::add) }
@@ -345,18 +330,7 @@ class AndroidTasksDataSource @Inject constructor(
arrayOf(Tasks.RRULE, Tasks.RDATE, Tasks.EXDATE, Tasks.DTSTART, Tasks.DUE, Tasks.IS_ALLDAY, Tasks.TZ),
null, null, null,
)?.use { c ->
if (!c.moveToFirst()) return@use null
val r = CursorColumnReader(c)
val anchor = r.getLong(Tasks.DTSTART) ?: r.getLong(Tasks.DUE) ?: return@use null
val rule = TaskMapper.seriesRule(r)
RecurrenceSpec(
rrule = rule?.rrule,
rdate = rule?.rdate,
exdate = r.getString(Tasks.EXDATE),
anchor = Instant.fromEpochMilliseconds(anchor),
isAllDay = r.getBoolean(Tasks.IS_ALLDAY),
timeZone = r.getString(Tasks.TZ),
)
if (c.moveToFirst()) TaskMapper.seriesSpec(CursorColumnReader(c)) else null
}
/** End the master's rule before [occurrenceStart], and drop the exceptions past it. */
@@ -753,31 +727,243 @@ class AndroidTasksDataSource @Inject constructor(
* Runs [write], and when it closed an occurrence the provider then detached
* into a task of its own, remembers that copy, so the occurrence can still be
* read and reopened, and how the series moved, so reopening can move it back.
* When the series moved on, its sub-tasks start over for the next occurrence
* (#160). With a copy, [resets] remembers how they were, so unticking gives
* that back; without one there is no tick to undo, and the reset stays.
*/
private fun rememberingCopy(taskId: Long, occurrenceStart: Instant, closing: Boolean, write: () -> Int): Int {
if (!closing) return write()
val authority = authority()
val lastId = runCatching { lastTaskId(authority) }.getOrNull() ?: return write()
val before = runCatching { seriesState(authority, taskId) }.getOrNull()
val series = runCatching { readSeries(authority, taskId) }.getOrNull()
val before = series?.state
return write().also { rows ->
if (rows > 0) {
runCatching {
detachedSince(authority, lastId)?.let { copy ->
val after = before?.let { seriesState(authority, taskId) }?.takeIf { it != before }
val tick = Tick(copy, taskId.takeIf { after != null }, before.takeIf { after != null }, after, System.currentTimeMillis())
val after = before?.let {
runCatching { readSeries(authority, taskId)?.state }
.onFailure { Log.w(TAG, "Reading the series after the tick failed", it) }
.getOrNull()?.takeIf { it != before }
}
val copy = runCatching { detachedSince(authority, lastId) }
.onFailure { Log.w(TAG, "Looking up the detached copy failed", it) }
.getOrNull()
if (series != null && before != null && after != null && SubtaskReset.movedOn(before, after)) {
runCatching { resetSubtasks(authority, taskId, series, before, after, record = copy != null) }
.onFailure { Log.w(TAG, "Resetting the sub-tasks failed", it) }
}
if (copy != null) {
runCatching {
val parentUid = series?.parentId?.let { uidOf(authority, it) }
parentUid?.let { markCopy(authority, copy, it) }
val tick = Tick(
copy, taskId.takeIf { after != null }, before.takeIf { after != null }, after, System.currentTimeMillis(),
parentUid = parentUid,
)
ticks.put(ticks.key(authority, taskId, occurrenceStart), tick)
}
}.onFailure { Log.w(TAG, "Looking up the detached copy failed", it) }
}.onFailure { Log.w(TAG, "Recording the tick failed", it) }
}
}
}
}
/**
* Marks [copyId], left by ticking a recurring sub-task, with the UID of the
* parent it sits under, where DAVx5 keeps and uploads unknown properties, so
* other installs know it too.
*/
private fun markCopy(authority: String, copyId: Long, parentUid: String) {
val values = mapOf(
Properties.TASK_ID to copyId,
Properties.MIMETYPE to SubtaskReset.UNKNOWN_PROPERTY_MIMETYPE,
Properties.DATA0 to SubtaskReset.copyMarkerJson(parentUid),
)
runCatching { resolver.insert(TasksContract.propertiesUri(authority), values.toContentValues()) }
.onFailure { Log.w(TAG, "Marking the ticked copy failed", it) }
}
private fun uidOf(authority: String, taskId: Long): String? =
resolver.query(taskUri(authority, taskId), null, null, null, null)
?.use { c -> if (c.moveToFirst()) CursorColumnReader(c).getString(Tasks.UID) else null }
/** The parent UID each of [taskIds] carries a copy marker for. */
private fun markerParents(authority: String, taskIds: Collection<Long>): Map<Long, String> = runCatching {
queryByIds(
TasksContract.propertiesUri(authority),
arrayOf(Properties.TASK_ID, Properties.DATA0),
Properties.TASK_ID,
taskIds,
filter = "${Properties.MIMETYPE} = ?",
filterArgs = listOf(SubtaskReset.UNKNOWN_PROPERTY_MIMETYPE),
) { r ->
val id = r.getLong(Properties.TASK_ID) ?: return@queryByIds null
SubtaskReset.markerParentFromJson(r.getString(Properties.DATA0))?.let { id to it }
}.toMap()
}.onFailure { Log.w(TAG, "Reading the copy markers failed", it) }.getOrDefault(emptyMap())
/** One `tasks` row as a reset reads it. */
private class SubtaskRow(
val id: Long,
val parentId: Long?,
val isOverride: Boolean,
val rrule: String?,
val rdate: String?,
val state: SubtaskState,
val dates: SubtaskDates,
val isAllDay: Boolean,
val lastModified: Long?,
val uid: String?,
)
private fun subtaskRow(r: ColumnReader): SubtaskRow? = r.getLong(Tasks.ID)?.let { id ->
SubtaskRow(
id = id,
parentId = r.getLong(Tasks.PARENT_ID),
isOverride = r.getLong(Tasks.ORIGINAL_INSTANCE_ID) != null,
rrule = r.getString(Tasks.RRULE),
rdate = r.getString(Tasks.RDATE),
state = subtaskState(r),
dates = SubtaskDates(r.getLong(Tasks.DTSTART), r.getLong(Tasks.DUE)),
isAllDay = r.getBoolean(Tasks.IS_ALLDAY),
lastModified = r.getLong(Tasks.LAST_MODIFIED),
uid = r.getString(Tasks.UID),
)
}
/**
* Resets what [SubtaskReset] picks under [seriesId], dated ones moved as the
* series moved from [before] to [after], and with [record] keeps it in
* [resets] first, under the anchor the series moved to. The series' list is
* read once and walked in memory, with the sub-tasks filed in other lists
* found by parent, one chunked query per level of the routine's tree.
*/
private fun resetSubtasks(
authority: String,
seriesId: Long,
series: SeriesRead,
before: Map<String, Any?>,
after: Map<String, Any?>,
record: Boolean,
) {
val listId = series.listId ?: return
val projection = SUBTASK_COLUMNS.filter { it in series.columns }.toTypedArray()
if (Tasks.ID !in projection || Tasks.PARENT_ID !in projection) return
val listRows = resolver.query(
TasksContract.tasksUri(authority),
projection,
"${Tasks.LIST_ID} = ? AND (${Tasks.DELETED} IS NULL OR ${Tasks.DELETED} = 0)",
arrayOf(listId.toString()),
null,
)?.use { c ->
val r = CursorColumnReader(c)
buildList { while (c.moveToNext()) subtaskRow(r)?.let(::add) }
}.orEmpty()
val rows = SubtaskReset.mergeSubtree(seriesId, listRows.filter { !it.isOverride }, { it.id }, { it.parentId }) { parents ->
queryByIds(
TasksContract.tasksUri(authority), projection, Tasks.PARENT_ID, parents,
filter = "${Tasks.LIST_ID} != ? AND (${Tasks.DELETED} IS NULL OR ${Tasks.DELETED} = 0)",
filterArgs = listOf(listId.toString()),
) { r -> subtaskRow(r)?.takeUnless { it.isOverride } }
}
val byId = rows.associateBy { it.id }
val children = rows.filter { !it.isOverride && it.parentId != null }.groupBy { it.parentId }
val known = knownCopies(authority, byId.keys)
val markers = markerParents(authority, children.values.flatten().map { it.id })
val uidOf = { id: Long -> if (id == seriesId) series.uid else byId[id]?.uid }
val from = SubtaskReset.anchor(before)
val to = SubtaskReset.anchor(after)
val reset = SubtaskReset.toReset(
seriesId,
SubtaskReset.shiftOf(before, after),
since = if (from != null && to != null) SubtaskReset.cycleStart(from, to) else null,
) { id ->
children[id].orEmpty().filter { it.id != id }.map {
SubtaskNode(
it.id,
SubtaskReset.recursOrCopy(it.rrule, it.rdate, known[it.id], markers[it.id], uidOf(id)),
it.state, it.dates, it.isAllDay, it.lastModified,
)
}
}
if (reset.isEmpty()) return
if (record && to != null) resets.put(authority, seriesId, to, SubtaskReset.encode(reset), System.currentTimeMillis())
val ops = reset.map { subtaskOp(authority, it.id, SubtaskState.FRESH, it.dates.takeIf { d -> d != it.priorDates }) }
resolver.applyBatch(authority, ArrayList(ops))
}
/** The copies this install knows of, the ones whose rows are gone forgotten; [present] are rows known to exist. */
private fun knownCopies(authority: String, present: Set<Long>): Map<Long, String> {
val copies = ticks.copies(authority)
val elsewhere = copies.keys - present
if (elsewhere.isEmpty()) return copies
val existing = queryByIds(
TasksContract.tasksUri(authority), arrayOf(Tasks.ID), Tasks.ID, elsewhere,
filter = "${Tasks.DELETED} IS NULL OR ${Tasks.DELETED} = 0",
) { it.getLong(Tasks.ID) }.toSet()
val gone = elsewhere - existing
ticks.forget(authority, gone)
return copies - gone
}
private fun subtaskState(r: ColumnReader) =
SubtaskState(statusFromInt(r.getInt(Tasks.STATUS)), r.getInt(Tasks.PERCENT_COMPLETE), r.getLong(Tasks.COMPLETED))
/** [state] and [dates] onto sub-task [id], each only where non-null. */
private fun subtaskOp(authority: String, id: Long, state: SubtaskState?, dates: SubtaskDates?): ContentProviderOperation {
val values = buildMap<String, Any?> {
if (state != null) {
put(Tasks.STATUS, state.status.toInt())
put(Tasks.PERCENT_COMPLETE, state.percent)
put(Tasks.COMPLETED, state.completedAt)
}
if (dates != null) {
put(Tasks.DTSTART, dates.start)
put(Tasks.DUE, dates.due)
}
}
return ContentProviderOperation.newUpdate(taskUri(authority, id)).withValues(values.toContentValues()).build()
}
/** What [SubtaskReset.toRestore] gives back to the sub-tasks of [reset]. */
private fun subtaskRestore(authority: String, reset: String): List<ContentProviderOperation> {
val entries = SubtaskReset.decode(reset)
if (entries.isEmpty()) return emptyList()
val current = queryByIds(
TasksContract.tasksUri(authority),
null,
Tasks.ID,
entries.map { it.id },
filter = "${Tasks.DELETED} IS NULL OR ${Tasks.DELETED} = 0",
) { r -> subtaskRow(r)?.let { it.id to SubtaskNow(it.state, it.dates, it.isAllDay) } }.toMap()
val outcome = SubtaskReset.toRestore(entries, current::get)
if (outcome.changed.isNotEmpty()) Log.i(TAG, "Sub-tasks ${outcome.changed} changed since the reset and keep that")
return outcome.restore.map { subtaskOp(authority, it.id, it.state, it.dates) }
}
/** Walks [parentId]'s direct sub-task rows, overrides left out, with [read] on each. */
private fun <T : Any> childRows(authority: String, parentId: Long, projection: Array<String>?, read: (ColumnReader) -> T?): List<T> =
resolver.query(
TasksContract.tasksUri(authority),
projection,
"${Tasks.PARENT_ID} = ? AND (${Tasks.DELETED} IS NULL OR ${Tasks.DELETED} = 0)",
arrayOf(parentId.toString()),
null,
)?.use { c ->
val r = CursorColumnReader(c)
buildList {
while (c.moveToNext()) {
if (r.getLong(Tasks.ORIGINAL_INSTANCE_ID) != null || r.getLong(Tasks.ID) == parentId) continue
read(r)?.let(::add)
}
}
} ?: emptyList()
/**
* Undoes the tick that left [taskId]'s occurrence at [occurrenceStart] — or,
* with no occurrence, the tick that left the copy [taskId]: the series goes
* back where it was and the copy goes, as long as the series is still where
* the tick moved it and the copy has nothing filed under it. False when it
* cannot, so the caller reopens the copy as a task of its own.
* the tick moved it and the copy has nothing filed under it. The sub-tasks
* the tick reset get back what [resets] kept. False when it cannot, so the
* caller reopens the copy as a task of its own.
*/
private fun movedBack(taskId: Long, occurrenceStart: Instant?): Boolean = runCatching {
val authority = authority()
@@ -786,31 +972,63 @@ class AndroidTasksDataSource @Inject constructor(
?: return false
val series = tick.seriesId ?: return false
val before = tick.before ?: return false
if (seriesState(authority, series) != tick.after || subtaskIds(tick.copyId).isNotEmpty()) return false
val restore = before.filter { (column, value) -> tick.after?.get(column) != value }
val after = tick.after ?: return false
// Compared on what the tick recorded: one from before IS_ALLDAY and TZ were read has neither.
val now = readSeries(authority, series)?.state ?: return false
if (after.any { (column, value) -> now[column] != value } || subtaskIds(tick.copyId).isNotEmpty()) return false
val restore = before.filter { (column, value) -> after[column] != value }
val ops = arrayListOf(
ContentProviderOperation.newUpdate(taskUri(authority, series)).withValues(restore.toContentValues()).build(),
ContentProviderOperation.newDelete(taskUri(authority, tick.copyId)).build(),
)
val anchor = SubtaskReset.anchor(after)
val record = anchor?.let { resets.get(authority, series, it) }
val subtasks = record?.let {
runCatching { subtaskRestore(authority, it) }.onFailure { e -> Log.w(TAG, "Reading the reset sub-tasks failed", e) }.getOrNull()
}
subtasks?.let(ops::addAll)
resolver.applyBatch(authority, ops)
ticks.remove(key)
// Kept when the sub-tasks could not be read, rather than lost with nothing restored.
if (anchor != null && subtasks != null) resets.remove(authority, series, anchor)
true
}.onFailure { Log.w(TAG, "Moving the series back failed", it) }.getOrDefault(false)
/** The columns a tick moves a series by, or null when [taskId] is no series. */
private fun seriesState(authority: String, taskId: Long): Map<String, Any?>? {
if (seriesRules(listOf(taskId)).isEmpty()) return null
return resolver.query(taskUri(authority, taskId), SERIES_STATE, null, null, null)?.use { c ->
/**
* A series row as a tick reads it: [state], the columns a tick changes and
* an undo changes back, null when the row does not recur; where it sits;
* and which columns the provider's `tasks` table has.
*/
private class SeriesRead(
val state: Map<String, Any?>?,
val listId: Long?,
val parentId: Long?,
val uid: String?,
val columns: Set<String>,
)
/** All columns, so a provider without one of [SERIES_STATE]'s still answers; the missing ones are left out. */
private fun readSeries(authority: String, taskId: Long): SeriesRead? =
resolver.query(taskUri(authority, taskId), null, null, null, null)?.use { c ->
if (!c.moveToFirst()) return@use null
SERIES_STATE.indices.associate { i ->
SERIES_STATE[i] to when (c.getType(i)) {
val r = CursorColumnReader(c)
val state = SERIES_STATE.mapNotNull { column ->
val i = c.getColumnIndex(column)
if (i < 0) return@mapNotNull null
column to when (c.getType(i)) {
Cursor.FIELD_TYPE_NULL -> null
Cursor.FIELD_TYPE_INTEGER -> c.getLong(i)
else -> c.getString(i)
}
}
}.toMap()
SeriesRead(
state = state.takeIf { listOf(Tasks.RRULE, Tasks.RDATE).any { !(state[it] as? String).isNullOrBlank() } },
listId = r.getLong(Tasks.LIST_ID),
parentId = r.getLong(Tasks.PARENT_ID),
uid = r.getString(Tasks.UID),
columns = c.columnNames.toSet(),
)
}
}
private fun lastTaskId(authority: String): Long =
resolver.query(TasksContract.tasksUri(authority), arrayOf(Tasks.ID), null, null, "${Tasks.ID} DESC")
@@ -830,7 +1048,12 @@ class AndroidTasksDataSource @Inject constructor(
}
}?.singleOrNull()
private val ticks = TickedCopies { context.getSharedPreferences(TICKED_COPIES, Context.MODE_PRIVATE) }
private val ticks = TickedCopies(
prefs = { context.getSharedPreferences(TICKED_COPIES, Context.MODE_PRIVATE) },
known = { context.getSharedPreferences(KNOWN_COPIES, Context.MODE_PRIVATE) },
)
private val resets = TickResets { context.getSharedPreferences(TICK_RESETS, Context.MODE_PRIVATE) }
/** The copy a tick left for [taskId]'s occurrence at [occurrenceStart], if one was remembered. */
private fun tickedCopy(taskId: Long, occurrenceStart: Instant): Long? =
@@ -939,10 +1162,28 @@ private const val MIGRATIONS = "provider_migrations"
private const val TICKED_COPIES = "provider_ticked_copies"
/** What a tick changes on a series, and an undo changes back. */
/**
* Every recurring sub-task's copy a tick on this install left, with the parent
* it sits under, kept past [TickedCopies.HORIZON_MS] alongside the marker on the row.
*/
private const val KNOWN_COPIES = "provider_known_copy_parents"
/** The sub-tasks each tick reset, kept apart from its copy. */
private const val TICK_RESETS = "provider_tick_resets"
/**
* What resetting a sub-task reads: where it sits, whether it recurs, its
* progress and its dates. Only the ones the provider's table has are asked for.
*/
private val SUBTASK_COLUMNS = listOf(
Tasks.ID, Tasks.PARENT_ID, Tasks.ORIGINAL_INSTANCE_ID, Tasks.RRULE, Tasks.RDATE, Tasks.STATUS, Tasks.PERCENT_COMPLETE,
Tasks.COMPLETED, Tasks.LAST_MODIFIED, Tasks.DTSTART, Tasks.DUE, Tasks.IS_ALLDAY, Tasks.UID,
)
/** What a tick changes on a series, and an undo changes back; with what its rule is read in. */
private val SERIES_STATE = arrayOf(
Tasks.DTSTART, Tasks.DUE, Tasks.DURATION, Tasks.RRULE, Tasks.RDATE, Tasks.EXDATE,
Tasks.STATUS, Tasks.COMPLETED, Tasks.PERCENT_COMPLETE,
Tasks.STATUS, Tasks.COMPLETED, Tasks.PERCENT_COMPLETE, Tasks.IS_ALLDAY, Tasks.TZ,
)
private const val TAG = "AndroidTasksDataSource"
@@ -950,5 +1191,3 @@ private const val TAG = "AndroidTasksDataSource"
/** No rule to look up: the provider says the row does not recur. */
private const val NO_RULE = -1L
/** SQLite's default bound-argument limit on older Android releases. */
private const val MAX_SQL_ARGS = 999
@@ -3,9 +3,9 @@ package de.jeanlucmakiola.agendula.data.tasks
import android.database.Cursor
/**
* Domain-shaped seam over a row of provider data, so the mappers can be
* unit-tested with a Map instead of a real [Cursor] (see MapColumnReader in
* test sources). Mirrors Calendula's ColumnReader.
* Domain-shaped seam over a row of provider data, read from a [Cursor] by
* [CursorColumnReader] or from a Map by [MapColumnReader], which also lets the
* mappers be unit-tested without a cursor. Mirrors Calendula's ColumnReader.
*/
interface ColumnReader {
fun getLong(name: String): Long?
@@ -1,6 +1,9 @@
package de.jeanlucmakiola.agendula.data.tasks
/** A [ColumnReader] backed by a Map, so mappers test without a real Cursor. */
/**
* A [ColumnReader] over a Map of column values, such as the series columns a
* tick records, read with the same mappers as a cursor. Tests use it too.
*/
class MapColumnReader(private val values: Map<String, Any?>) : ColumnReader {
override fun getLong(name: String): Long? = (values[name] as? Number)?.toLong()
override fun getInt(name: String): Int? = (values[name] as? Number)?.toInt()
@@ -0,0 +1,23 @@
package de.jeanlucmakiola.agendula.data.tasks
/** SQLite's default bound-argument limit on older Android releases. */
internal const val MAX_SQL_ARGS = 999
/**
* `idColumn IN (…)` selections over [ids], each with its arguments and
* [filterArgs] after them, in chunks that keep every query within [limit]
* bound arguments.
*/
internal fun inSelections(
idColumn: String,
ids: Collection<Long>,
filter: String? = null,
filterArgs: List<String> = emptyList(),
limit: Int = MAX_SQL_ARGS,
): List<Pair<String, Array<String>>> = ids.distinct().chunked(limit - filterArgs.size).map { chunk ->
val selection = buildString {
append("$idColumn IN (${chunk.joinToString(",") { "?" }})")
if (filter != null) append(" AND ($filter)")
}
selection to (chunk.map(Long::toString) + filterArgs).toTypedArray()
}
@@ -49,16 +49,31 @@ internal object StoredReminders {
zone: ZoneId,
): List<TaskReminder> {
val wanted = form.reminders.map { it.lead }.distinct()
val had = anchorsOf(start, due)
val gained = anchorsOf(form.start, form.due) - had
val revived = revived(form, start, due, wasAllDay, wanted, settings, now, zone)
if (gained.isEmpty() && revived.isEmpty()) return wanted
if (had.isEmpty() || wanted.isEmpty()) return wanted.ifEmpty { defaultsFor(form, settings, now, zone) }
val fresh = freshAnchors(form, start, due, wasAllDay, settings, now, zone)
if (fresh.isEmpty()) return wanted
if (anchorsOf(start, due).isEmpty() || wanted.isEmpty()) return wanted.ifEmpty { defaultsFor(form, settings, now, zone) }
val named = wanted.map { it.fromStart }.toSet()
val fresh = gained + revived
return wanted + defaultsFor(form, settings, now, zone).filter { it.fromStart in fresh && it.fromStart !in named }
}
/**
* The dates whose defaults [withDefaults] brings in, as [TaskReminder.fromStart]:
* those the task gains, and those [revived]. Empty = the defaults play no part.
*/
fun freshAnchors(
form: TaskForm,
start: Instant?,
due: Instant?,
wasAllDay: Boolean,
settings: Settings,
now: Long,
zone: ZoneId,
): Set<Boolean> {
val wanted = form.reminders.map { it.lead }.distinct()
val gained = anchorsOf(form.start, form.due) - anchorsOf(start, due)
return gained + revived(form, start, due, wasAllDay, wanted, settings, now, zone)
}
/**
* [reminders] for [form] once it has switched between timed and all-day.
* Reminders that are exactly the old kind's default become the new kind's;
@@ -73,15 +88,18 @@ internal object StoredReminders {
zone: ZoneId,
): List<TaskReminder> {
if (reminders.isEmpty()) return reminders
if (reminders.toSet() == settings.defaultRemindersFor(form.listId, !form.isAllDay).toSet()) {
return defaultsFor(form, settings, now, zone)
}
return keptAcrossSwitch(reminders, form, settings) ?: defaultsFor(form, settings, now, zone)
}
/** What [switched] keeps of [reminders], or null when it swaps in the new kind's defaults. */
fun keptAcrossSwitch(reminders: List<TaskReminder>, form: TaskForm, settings: Settings): List<TaskReminder>? {
if (reminders.toSet() == settings.defaultRemindersFor(form.listId, !form.isAllDay).toSet()) return null
val kept = if (form.isAllDay) {
reminders.map { it.inWholeDays() }
} else {
reminders.filter { it.allDay.minuteOfDay == null }
}
return kept.distinct().ifEmpty { defaultsFor(form, settings, now, zone) }
return kept.distinct().ifEmpty { null }
}
/**
@@ -0,0 +1,295 @@
package de.jeanlucmakiola.agendula.data.tasks
import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Tasks
import de.jeanlucmakiola.agendula.domain.TaskStatus
import de.jeanlucmakiola.agendula.domain.isClosed
import de.jeanlucmakiola.agendula.domain.recurrence.ExpansionWindow
import de.jeanlucmakiola.agendula.domain.recurrence.RecurrenceExpander
import de.jeanlucmakiola.agendula.domain.recurrence.RecurrenceSpec
import de.jeanlucmakiola.agendula.domain.recurrence.dateZone
import de.jeanlucmakiola.agendula.domain.statusFromInt
import java.time.Duration
import java.time.LocalDateTime
import java.time.ZoneId
import java.time.temporal.ChronoUnit
import kotlin.time.Duration.Companion.days
import kotlin.time.Instant
private const val MILLIS_PER_SECOND = 1000L
private const val MILLIS_PER_DAY = 24L * 60 * 60 * 1000
/** A sub-task's progress, which a routine's next occurrence starts without. */
internal data class SubtaskState(val status: TaskStatus, val percent: Int?, val completedAt: Long?) {
/** Open with nothing done yet: what a reset leaves. */
val isFresh: Boolean get() = status == TaskStatus.NEEDS_ACTION && (percent ?: 0) == 0 && completedAt == null
companion object {
val FRESH = SubtaskState(TaskStatus.NEEDS_ACTION, null, null)
}
}
/** A sub-task's own start and due, as epoch millis. */
internal data class SubtaskDates(val start: Long?, val due: Long?) {
val isEmpty: Boolean get() = start == null && due == null
/** The same dates as a store keeps them: to the second, or for an all-day task to the day. */
fun sameAs(other: SubtaskDates, isAllDay: Boolean): Boolean {
fun unit(at: Long?) = at?.let { Math.floorDiv(it, if (isAllDay) MILLIS_PER_DAY else MILLIS_PER_SECOND) }
return unit(start) == unit(other.start) && unit(due) == unit(other.due)
}
companion object {
val NONE = SubtaskDates(null, null)
}
}
/**
* A sub-task as [SubtaskReset] sees it; [recurring] also covers a copy a tick of
* a recurring one left. [lastModified] dates progress that has no completion time.
*/
internal class SubtaskNode(
val id: Long,
val recurring: Boolean,
val state: SubtaskState,
val dates: SubtaskDates = SubtaskDates.NONE,
val isAllDay: Boolean = false,
val lastModified: Long? = null,
)
/** A sub-task [SubtaskReset] reset: its state and dates before, and the dates the reset gave it. */
internal data class ResetSubtask(
val id: Long,
val prior: SubtaskState,
val priorDates: SubtaskDates = SubtaskDates.NONE,
val dates: SubtaskDates = priorDates,
)
/** A reset sub-task as it is now, for [SubtaskReset.toRestore]. */
internal class SubtaskNow(val state: SubtaskState, val dates: SubtaskDates, val isAllDay: Boolean)
/** What moving back writes to one sub-task: its [state] and its [dates], each only where non-null. */
internal data class SubtaskBack(val id: Long, val state: SubtaskState?, val dates: SubtaskDates?)
/** What moving a series back does with its reset sub-tasks, and which ones changed since and keep that. */
internal class SubtaskRestore(val restore: List<SubtaskBack>, val changed: List<Long>)
/**
* How far a series moved in [seriesZone]. A timed sub-task moves by the series'
* wall-clock change there, so it keeps its offset to the routine across a DST
* change whatever zone it is stored in; an all-day one moves by the change of
* the series' calendar date.
*/
internal class SeriesShift(from: Long, to: Long, private val seriesZone: ZoneId) {
private val delta = Duration.between(local(from, seriesZone), local(to, seriesZone))
private val days = ChronoUnit.DAYS.between(local(from, seriesZone).toLocalDate(), local(to, seriesZone).toLocalDate())
/** [at] moved along. */
fun apply(at: Long, isAllDay: Boolean): Long {
val zone = if (isAllDay) dateZone(isAllDay = true, timeZone = null) else seriesZone
val moved = if (isAllDay) local(at, zone).plusDays(days) else local(at, zone).plus(delta)
return moved.atZone(zone).toInstant().toEpochMilli()
}
private fun local(at: Long, zone: ZoneId) = LocalDateTime.ofInstant(java.time.Instant.ofEpochMilli(at), zone)
}
/**
* What a routine's sub-tasks do when its series moves on to the next occurrence
* (#160): the ones completed or in progress start over, as in tasks.org, dated
* ones move along with the routine, and moving the series back gives them their
* state and dates again.
*/
internal object SubtaskReset {
/** Only bounds the search for a next occurrence. */
private val LOOKAHEAD = (366 * 1000).days
/**
* The `X-` property Agendula puts on the copy a provider tick of a recurring
* sub-task left, valued with the UID of the parent it sits under, so any
* device knows it for one while it stays there.
*/
const val COPY_MARKER = "X-AGENDULA-TICK-COPY"
/** The provider `properties` mimetype DAVx5 keeps unknown properties under, and round-trips. */
const val UNKNOWN_PROPERTY_MIMETYPE = "vnd.android.cursor.item/vnd.ical4android.unknown-property"
private val MARKER_JSON = Regex("""^\s*\[\s*"$COPY_MARKER"\s*,\s*"((?:[^"\\]|\\.)*)"""", RegexOption.IGNORE_CASE)
/** The marker for a copy under the parent [parentUid], as DAVx5 stores an unknown property: a JSON array of name and value. */
fun copyMarkerJson(parentUid: String): String =
"[\"$COPY_MARKER\",\"${parentUid.replace("\\", "\\\\").replace("\"", "\\\"")}\"]"
/** The parent UID an unknown-property row's JSON marks its task a copy under, or null when it is no marker. */
fun markerParentFromJson(json: String?): String? =
json?.let(MARKER_JSON::find)?.groupValues?.get(1)?.replace(Regex("""\\(.)"""), "$1")
/** The parent UID a stored residue's marker names, as a copy synced in from a provider install carries it. */
fun markerParentFromResidue(residue: String?): String? = residue?.lines()?.firstNotNullOfOrNull {
val line = it.trim()
val next = line.getOrNull(COPY_MARKER.length)
if (!line.startsWith(COPY_MARKER, ignoreCase = true) || (next != ':' && next != ';')) return@firstNotNullOfOrNull null
line.substringAfter(':').replace(Regex("""\\([\\;,])"""), "$1")
}
/** Whether a record naming [copyParent] makes a task under [parentUid] a copy: only under the parent it came from. */
fun isCopyOf(copyParent: String?, parentUid: String?): Boolean = copyParent != null && copyParent == parentUid
/**
* Whether a provider row under [parentUid] is left alone as recurring: it has
* a rule, or it is a copy a tick of a recurring sibling left, known by the
* parent this install recorded for it ([knownParent]) or by its marker
* ([markerParent]), either only while it sits under that parent.
*/
fun recursOrCopy(rrule: String?, rdate: String?, knownParent: String?, markerParent: String?, parentUid: String?): Boolean =
!rrule.isNullOrBlank() || !rdate.isNullOrBlank() || isCopyOf(knownParent, parentUid) || isCopyOf(markerParent, parentUid)
/**
* [rows] grown by what [fetch] finds under the ids reached from [root] so
* far, asked once per id, until nothing new turns up: the sub-tasks filed in
* other lists than the one [rows] came from.
*/
fun <R> mergeSubtree(root: Long, rows: List<R>, id: (R) -> Long, parent: (R) -> Long?, fetch: (Set<Long>) -> List<R>): List<R> {
val all = LinkedHashMap<Long, R>().apply { rows.forEach { put(id(it), it) } }
val asked = HashSet<Long>()
while (true) {
val children = all.values.groupBy(parent)
val reached = linkedSetOf(root)
val queue = ArrayDeque(listOf(root))
while (queue.isNotEmpty()) {
children[queue.removeFirst()].orEmpty().map(id).filter(reached::add).forEach(queue::addLast)
}
val toAsk = reached - asked
if (toAsk.isEmpty()) return all.values.toList()
asked += toAsk
fetch(toAsk).forEach { all.putIfAbsent(id(it), it) }
}
}
/**
* Where the occurrence a move closes began, for [toReset]'s `since`: one
* step of the move before its old anchor [from], [to] being the new one.
*/
fun cycleStart(from: Long, to: Long): Long = from - (to - from)
/**
* The sub-tasks under [parentId], all the way down, to reset: started ones,
* and with a [shift], dated ones too. A recurring one has a series of its
* own and is left alone with everything under it; a cancelled one stays as
* it is.
*
* With [since], a started one is only reset when it was completed, or for
* one in progress last changed, at or after it: during the cycle the move
* closes. A copy an earlier cycle left, which nothing marks as one, is left
* alone that way, and so is one with neither time to go by.
*/
fun toReset(
parentId: Long,
shift: SeriesShift? = null,
since: Long? = null,
children: (Long) -> List<SubtaskNode>,
): List<ResetSubtask> {
val seen = mutableSetOf(parentId)
val reset = mutableListOf<ResetSubtask>()
fun walk(id: Long) {
children(id).filter { !it.recurring && seen.add(it.id) }.forEach {
val started = !it.state.isFresh
val stamp = it.state.completedAt ?: it.lastModified
val earlier = started && since != null && (stamp == null || stamp < since)
val moves = shift != null && !it.dates.isEmpty
if (it.state.status != TaskStatus.CANCELLED && !earlier && (started || moves)) {
val dates = if (shift == null) it.dates else SubtaskDates(
it.dates.start?.let { at -> shift.apply(at, it.isAllDay) },
it.dates.due?.let { at -> shift.apply(at, it.isAllDay) },
)
reset += ResetSubtask(it.id, it.state, it.dates, dates)
}
walk(it.id)
}
}
walk(parentId)
return reset
}
/**
* What moving back gives each reset sub-task: its state where it is still
* fresh, and its dates where they are still the ones the reset wrote. What
* changed since keeps the user's version and is listed as changed; a
* deleted sub-task is neither.
*/
fun toRestore(reset: List<ResetSubtask>, current: (Long) -> SubtaskNow?): SubtaskRestore {
val restore = mutableListOf<SubtaskBack>()
val changed = mutableListOf<Long>()
reset.forEach { entry ->
val now = current(entry.id) ?: return@forEach
val state = entry.prior.takeIf { now.state.isFresh }
val datesMoved = entry.dates != entry.priorDates
val dates = entry.priorDates.takeIf { datesMoved && now.dates.sameAs(entry.dates, now.isAllDay) }
if (state != null || dates != null) restore += SubtaskBack(entry.id, state, dates)
if (state == null || (datesMoved && dates == null)) changed += entry.id
}
return SubtaskRestore(restore, changed)
}
fun encode(reset: List<ResetSubtask>): String = reset.joinToString(";") {
listOf(
it.id, it.prior.status.name, it.prior.percent, it.prior.completedAt,
it.priorDates.start, it.priorDates.due, it.dates.start, it.dates.due,
).joinToString(",") { value -> value?.toString().orEmpty() }
}
fun decode(raw: String?): List<ResetSubtask> = raw.orEmpty().split(';').mapNotNull { entry ->
val parts = entry.split(',')
if (parts.size != 8) return@mapNotNull null
val id = parts[0].toLongOrNull() ?: return@mapNotNull null
val status = TaskStatus.entries.firstOrNull { it.name == parts[1] } ?: return@mapNotNull null
ResetSubtask(
id,
SubtaskState(status, parts[2].toIntOrNull(), parts[3].toLongOrNull()),
SubtaskDates(parts[4].toLongOrNull(), parts[5].toLongOrNull()),
SubtaskDates(parts[6].toLongOrNull(), parts[7].toLongOrNull()),
)
}
/** A provider series' rule set from its columns. */
fun specOf(state: Map<String, Any?>): RecurrenceSpec? = TaskMapper.seriesSpec(MapColumnReader(state))
/** How the series moved from [before] to [after], read in the zone its rule is expanded in. */
fun shiftOf(before: Map<String, Any?>, after: Map<String, Any?>, floating: ZoneId = ZoneId.systemDefault()): SeriesShift? {
val from = anchor(before) ?: return null
val to = anchor(after) ?: return null
val reader = MapColumnReader(after)
return SeriesShift(from, to, dateZone(reader.getBoolean(Tasks.IS_ALLDAY), reader.getString(Tasks.TZ), floating))
}
/**
* Whether a provider tick moved the series on, judged by its columns
* [before] and [after]: its start (or due) moved later and it is still open,
* with [next], its rule set as it now stands, generating an occurrence from
* there. An `EXDATE` or a status alone is no move; a series whose rule ran
* out is finished.
*/
fun movedOn(before: Map<String, Any?>?, after: Map<String, Any?>?, next: RecurrenceSpec? = after?.let(::specOf)): Boolean {
val was = anchor(before ?: return false) ?: return false
val now = anchor(after ?: return false) ?: return false
if (now <= was) return false
if (statusFromInt((after[Tasks.STATUS] as? Number)?.toInt()).isClosed) return false
val spec = next ?: return false
if (spec.rrule == null && spec.rdate == null) return false
val parts = spec.rrule?.split(';')?.map { it.trim() }?.filter { it.isNotEmpty() }
val count = parts?.firstOrNull { it.startsWith("COUNT=", ignoreCase = true) }?.substringAfter('=')?.toIntOrNull()
if (count != null && count <= 0) return false
// Expanded from the old start, as an expansion always yields its own start
// even past UNTIL. COUNT is left out: it was spent before the new start.
val probe = spec.copy(
rrule = parts?.filterNot { it.startsWith("COUNT=", ignoreCase = true) }?.joinToString(";"),
anchor = Instant.fromEpochMilliseconds(was),
)
val from = Instant.fromEpochMilliseconds(now)
return RecurrenceExpander.expand(probe, ExpansionWindow(from = from, until = from + LOOKAHEAD, maxOccurrences = 1)).isNotEmpty()
}
/** The anchor a series' columns put it at: its start, or else its due date. */
fun anchor(state: Map<String, Any?>): Long? =
(state[Tasks.DTSTART] as? Number)?.toLong() ?: (state[Tasks.DUE] as? Number)?.toLong()
}
@@ -8,6 +8,7 @@ import de.jeanlucmakiola.agendula.domain.TaskList
import de.jeanlucmakiola.agendula.domain.export.ExportTask
import de.jeanlucmakiola.agendula.domain.priorityFromICal
import de.jeanlucmakiola.agendula.domain.statusFromInt
import de.jeanlucmakiola.agendula.domain.recurrence.RecurrenceSpec
import kotlin.time.Instant
/** Maps a provider row (via [ColumnReader]) to a domain model. Pure + testable. */
@@ -77,6 +78,20 @@ object TaskMapper {
return if (rrule == null && rdate == null) null else SeriesRule(rrule, rdate)
}
/** The rule set of a `tasks` row, anchored on its start or else its due date; null without either date. */
fun seriesSpec(r: ColumnReader): RecurrenceSpec? {
val rule = seriesRule(r)
val anchor = r.getLong(Tasks.DTSTART) ?: r.getLong(Tasks.DUE) ?: return null
return RecurrenceSpec(
rrule = rule?.rrule,
rdate = rule?.rdate,
exdate = r.getString(Tasks.EXDATE),
anchor = Instant.fromEpochMilliseconds(anchor),
isAllDay = r.getBoolean(Tasks.IS_ALLDAY),
timeZone = r.getString(Tasks.TZ),
)
}
/**
* The occurrence's `RECURRENCE-ID` anchor.
*
@@ -0,0 +1,42 @@
package de.jeanlucmakiola.agendula.data.tasks
import android.content.SharedPreferences
/**
* The sub-tasks a provider tick reset, as [SubtaskReset.encode] writes them,
* kept for [TickedCopies.HORIZON_MS] under the series and the anchor the tick
* moved it to: whether or not the provider left a copy that [TickedCopies]
* could record, moving the series back from there finds them.
*/
internal class TickResets(private val prefs: () -> SharedPreferences) {
fun put(authority: String, seriesId: Long, anchor: Long, reset: String, at: Long) {
val stale = expire(prefs().all, at)
prefs().edit().apply {
stale.forEach(::remove)
putString(key(authority, seriesId, anchor), encode(at, reset))
}.apply()
}
fun get(authority: String, seriesId: Long, anchor: Long): String? =
prefs().getString(key(authority, seriesId, anchor), null)?.let(::decode)
fun remove(authority: String, seriesId: Long, anchor: Long) {
prefs().edit().remove(key(authority, seriesId, anchor)).apply()
}
companion object {
fun key(authority: String, seriesId: Long, anchor: Long) = "$authority|$seriesId|$anchor"
fun encode(at: Long, reset: String) = "$at|$reset"
/** The reset an entry holds, or null when it is not one. */
fun decode(raw: String): String? = raw.substringBefore('|', "").toLongOrNull()?.let { raw.substringAfter('|') }
/** The keys of [entries] past the horizon at [now], unreadable ones included. */
fun expire(entries: Map<String, *>, now: Long): Set<String> = entries.filter { (_, value) ->
val at = (value as? String)?.substringBefore('|', "")?.toLongOrNull() ?: 0L
now - at > TickedCopies.HORIZON_MS
}.keys
}
}
@@ -7,6 +7,8 @@ import kotlin.time.Instant
/**
* What ticking a provider occurrence left: the copy the provider detached, and
* the series' columns before and after the tick, so an undo can move it back.
* [parentUid] is the parent a recurring sub-task's copy sits under. The
* sub-tasks it reset are kept apart, in [TickResets].
*/
internal class Tick(
val copyId: Long,
@@ -14,10 +16,16 @@ internal class Tick(
val before: Map<String, Any?>?,
val after: Map<String, Any?>?,
val at: Long,
val parentUid: String? = null,
)
/** The provider keeps no record of its ticks, so they are kept here for [HORIZON_MS]. */
internal class TickedCopies(private val prefs: () -> SharedPreferences) {
/**
* The provider keeps no record of its ticks, so they are kept here for
* [HORIZON_MS]. A recurring sub-task's copy stays known after that in [known],
* with the parent it sits under: a detached copy carries nothing that marks it
* as one.
*/
internal class TickedCopies(private val prefs: () -> SharedPreferences, private val known: () -> SharedPreferences) {
fun key(authority: String, taskId: Long, occurrenceStart: Instant) =
"$authority|$taskId|${wholeSecond(occurrenceStart).epochSeconds}"
@@ -31,27 +39,53 @@ internal class TickedCopies(private val prefs: () -> SharedPreferences) {
(value as? String)?.let(::decode)?.takeIf { it.copyId == copyId }?.let { key to it }
}
/** Every recurring sub-task's copy a tick in Agendula left in [authority], with the UID of the parent it sits under. */
fun copies(authority: String): Map<Long, String> {
val copies = HashMap<Long, String>()
known().all.forEach { (key, value) ->
if (key.startsWith("$authority|")) key.substringAfter('|').toLongOrNull()?.let { id -> (value as? String)?.let { copies[id] = it } }
}
prefs().all.forEach { (key, value) ->
if (!key.startsWith("$authority|")) return@forEach
(value as? String)?.let(::decode)?.let { tick -> tick.parentUid?.let { copies[tick.copyId] = it } }
}
return copies
}
/** Forgets the known copies [ids] of [authority], whose rows are gone. */
fun forget(authority: String, ids: Collection<Long>) {
if (ids.isEmpty()) return
known().edit().apply { ids.forEach { remove(knownKey(authority, it)) } }.apply()
}
/** Records [tick] under [key]; ticks past [HORIZON_MS] go, their sub-task copies stay known. */
fun put(key: String, tick: Tick) {
val stale = prefs().all.filter { (_, value) ->
val at = (value as? String)?.let(::decode)?.at ?: 0L
tick.at - at > HORIZON_MS
}.keys
val (stale, keep) = expire(prefs().all.mapValues { (_, value) -> (value as? String)?.let(::decode) }, tick.at)
known().edit().apply {
keep.forEach { (authority, kept) -> kept.forEach { (id, parent) -> putString(knownKey(authority, id), parent) } }
}.apply()
prefs().edit().apply {
stale.forEach(::remove)
putString(key, encode(tick))
}.apply()
}
/** Drops the tick under [key], and its copy from the known ones: moving back deleted it, and its id may be reused. */
fun remove(key: String) {
val copy = get(key)?.copyId
prefs().edit().remove(key).apply()
if (copy != null) forget(key.substringBefore('|'), listOf(copy))
}
private fun knownKey(authority: String, copyId: Long) = "$authority|$copyId"
private fun encode(tick: Tick): String = JSONObject().apply {
put("copy", tick.copyId)
put("at", tick.at)
tick.seriesId?.let { put("series", it) }
tick.before?.let { put("before", columns(it)) }
tick.after?.let { put("after", columns(it)) }
tick.parentUid?.let { put("parent", it) }
}.toString()
private fun columns(values: Map<String, Any?>) = JSONObject().apply {
@@ -66,6 +100,7 @@ internal class TickedCopies(private val prefs: () -> SharedPreferences) {
before = json.optJSONObject("before")?.let(::values),
after = json.optJSONObject("after")?.let(::values),
at = json.getLong("at"),
parentUid = if (json.has("parent")) json.getString("parent") else null,
)
}.getOrNull()
@@ -80,5 +115,19 @@ internal class TickedCopies(private val prefs: () -> SharedPreferences) {
companion object {
/** As long as the own store keeps a tick undoable. */
const val HORIZON_MS = 30L * 24 * 60 * 60 * 1000
/**
* The keys of [ticks] past the horizon at [now], unreadable ones included,
* and per authority the sub-task copies they leave, with their parent's
* UID, which stay known after the tick goes. A top-level copy is not kept.
*/
fun expire(ticks: Map<String, Tick?>, now: Long): Pair<Set<String>, Map<String, Map<Long, String>>> {
val stale = ticks.filter { (_, tick) -> now - (tick?.at ?: 0L) > HORIZON_MS }
val keep = stale.entries
.mapNotNull { (key, tick) -> tick?.parentUid?.let { Triple(key.substringBefore('|'), tick.copyId, it) } }
.groupBy({ it.first }, { it.second to it.third })
.mapValues { it.value.toMap() }
return stale.keys to keep
}
}
}
@@ -461,8 +461,8 @@ object VTodoMapper {
"PERCENT-COMPLETE" -> entity.percentComplete != null
"CLASS" -> entity.classification != null
"CATEGORIES" -> entity.categories != residueCategories
// Not SEQUENCE: it is the organiser's counter and never ours to bump,
// so the column stays at its fallback and the residue always wins.
// Raised by an upload (#137); kept as the server sent it otherwise.
"SEQUENCE" -> entity.sequence != 0
else -> false
}
}
@@ -573,6 +573,13 @@ object VTodoMapper {
private fun ICalProperty.text(): String = ICalValues.unescapeText(value)
/**
* Whether an upload of [entity] should raise its `SEQUENCE` (RFC 5545 §3.8.7.4).
* Not for a scheduled task, where the counter is the organiser's.
*/
fun revisesSequence(entity: TaskEntity): Boolean =
parseResidue(entity.unknownProperties).properties("ORGANIZER").isEmpty()
private fun parseResidue(text: String?): ICalComponent {
if (text.isNullOrEmpty()) return ICalComponent("VTODO")
// The residue is stored as bare properties followed by whole sub-component
@@ -51,6 +51,8 @@ data class AdvancedOccurrenceEntity(
@ColumnInfo(name = "undoable", defaultValue = "1") val undoable: Boolean = true,
/** Set once the moved series reached the server, which then holds the move itself. */
@ColumnInfo(name = "settled", defaultValue = "0") val settled: Boolean = false,
/** The series' sub-tasks the move reset, with their state before, as [de.jeanlucmakiola.agendula.data.tasks.SubtaskReset.encode] writes them. */
@ColumnInfo(name = "reset_subtasks", defaultValue = "") val resetSubtasks: String = "",
) {
val dropped: List<Instant>
get() = droppedExdates.split(',').mapNotNull { it.toLongOrNull()?.let(Instant::fromEpochMilliseconds) }
@@ -1,6 +1,14 @@
package de.jeanlucmakiola.agendula.data.tasks.room
import android.util.Log
import androidx.room.InvalidationTracker
import de.jeanlucmakiola.agendula.data.tasks.ResetSubtask
import de.jeanlucmakiola.agendula.data.tasks.SeriesShift
import de.jeanlucmakiola.agendula.data.tasks.SubtaskDates
import de.jeanlucmakiola.agendula.data.tasks.SubtaskNode
import de.jeanlucmakiola.agendula.data.tasks.SubtaskNow
import de.jeanlucmakiola.agendula.data.tasks.SubtaskReset
import de.jeanlucmakiola.agendula.data.tasks.SubtaskState
import de.jeanlucmakiola.agendula.data.tasks.TaskQuery
import de.jeanlucmakiola.agendula.domain.TaskReminder
import de.jeanlucmakiola.agendula.domain.TaskReminderOrder
@@ -18,6 +26,7 @@ import de.jeanlucmakiola.agendula.domain.recurrence.ExpansionWindow
import de.jeanlucmakiola.agendula.domain.recurrence.RecurrenceExpander
import de.jeanlucmakiola.agendula.domain.recurrence.RecurrenceSpec
import java.time.ZoneId
import de.jeanlucmakiola.agendula.domain.recurrence.dateZone
import java.util.UUID
import javax.inject.Inject
import javax.inject.Singleton
@@ -91,6 +100,8 @@ private val TASK_TABLES = arrayOf("tasks", "task_lists", "task_alarms")
/** Distinct alarm texts whose `ACKNOWLEDGED` is remembered between scheduler passes. */
private const val ACK_CACHE_SIZE = 512
private const val TAG = "RoomTasksDataSource"
/**
* [TasksDataSource] over Agendula's own Room store.
*
@@ -638,6 +649,7 @@ class RoomTasksDataSource @Inject constructor(
isDirty = true,
),
)
val (reset, resetLists) = resetSubtasks(master, newAnchor, now)
val copyId = if (override != null) {
detach(override, now, close)
} else {
@@ -663,13 +675,65 @@ class RoomTasksDataSource @Inject constructor(
ruleAfter = ruleAfter,
droppedExdates = AdvancedOccurrenceEntity.encode(TaskFormWriter.instantsBefore(master.exdate, newAnchor, zone)),
fromOverride = override != null,
resetSubtasks = SubtaskReset.encode(reset),
),
)
advanced.insertDetached(detached.map { (at, id) -> AdvancedDetachedEntity(copyId = copyId, anchor = at, taskId = id) })
writes.onWritten(setOf(master.listId))
writes.onWritten(setOf(master.listId) + resetLists)
return true
}
/**
* Resets what [SubtaskReset] picks under [master] for the series' next
* occurrence at [newAnchor], dated ones moved along; the lists it wrote to.
* A copy a provider tick of a recurring sub-task left, synced in, is known by
* its marker while it stays under the parent the marker names.
*/
private fun resetSubtasks(master: TaskEntity, newAnchor: Instant, now: Instant): Pair<List<ResetSubtask>, Set<Long>> {
val from = master.recurrenceAnchor?.toEpochMilliseconds()
val to = newAnchor.toEpochMilliseconds()
val shift = from?.let { SeriesShift(it, to, dateZone(master.isAllDay, master.timezone, ZoneId.of(zone()))) }
val loaded = HashMap<Long, TaskEntity>().apply { put(master.id, master) }
val reset = SubtaskReset.toReset(master.id, shift, since = from?.let { SubtaskReset.cycleStart(it, to) }) { id ->
val parentUid = loaded[id]?.uid
tasks.subtasks(id).map { row ->
val sub = row.task.also { loaded[it.id] = it }
val copy = SubtaskReset.isCopyOf(SubtaskReset.markerParentFromResidue(sub.unknownProperties), parentUid)
SubtaskNode(sub.id, sub.isRecurring || copy, sub.progress, sub.dates, sub.isAllDay, sub.lastModified?.toEpochMilliseconds())
}
}
val lists = reset.mapNotNull { entry ->
loaded[entry.id]?.also { tasks.update(it.withProgress(SubtaskState.FRESH, entry.dates, now)) }?.listId
}
return reset to lists.toSet()
}
/** What [resetSubtasks] reset for [record], back as it was where nothing changed it since. */
private fun restoreSubtasks(record: AdvancedOccurrenceEntity, now: Instant): Set<Long> {
val entries = SubtaskReset.decode(record.resetSubtasks)
val current = entries.mapNotNull { entry -> tasks.entity(entry.id)?.takeUnless { it.isDeleted } }.associateBy { it.id }
val outcome = SubtaskReset.toRestore(entries) { id -> current[id]?.let { SubtaskNow(it.progress, it.dates, it.isAllDay) } }
if (outcome.changed.isNotEmpty()) Log.i(TAG, "Sub-tasks ${outcome.changed} changed since the reset and keep that")
return outcome.restore.mapNotNull { back ->
current[back.id]?.also { tasks.update(it.withProgress(back.state, back.dates, now)) }?.listId
}.toSet()
}
private val TaskEntity.progress get() = SubtaskState(status, percentComplete, completedAt?.toEpochMilliseconds())
private val TaskEntity.dates get() = SubtaskDates(dtstart?.toEpochMilliseconds(), due?.toEpochMilliseconds())
/** [state] and [dates] onto the row, each only where non-null. */
private fun TaskEntity.withProgress(state: SubtaskState?, dates: SubtaskDates?, now: Instant) = copy(
status = state?.status ?: status,
percentComplete = if (state == null) percentComplete else state.percent,
completedAt = if (state == null) completedAt else state.completedAt?.let(Instant::fromEpochMilliseconds),
dtstart = if (dates == null) dtstart else dates.start?.let(Instant::fromEpochMilliseconds),
due = if (dates == null) due else dates.due?.let(Instant::fromEpochMilliseconds),
lastModified = now,
isDirty = true,
)
/** Occurrences `COUNT` has spent before [cut]: counted before `EXDATE` (RFC 5545 §3.8.5.3). */
private fun spentBefore(spec: RecurrenceSpec, cut: Instant): Int = RecurrenceExpander.expand(
spec.copy(exdate = null),
@@ -754,7 +818,7 @@ class RoomTasksDataSource @Inject constructor(
val plain = reopened.status == TaskStatus.NEEDS_ACTION && reopened.percentComplete == null
if (record.fromOverride || !plain) toOverride(reopened, back, record.anchor, now)
else deleteTask(row.id)
writes.onWritten(setOf(master.listId))
writes.onWritten(setOf(master.listId) + restoreSubtasks(record, now))
return true
}
@@ -200,6 +200,10 @@ interface TaskDao {
@Query("UPDATE tasks SET href = :href, etag = :etag, is_dirty = 0 WHERE id IN (:taskIds)")
fun markSynced(taskIds: List<Long>, href: String?, etag: String?): Int
/** Records the `SEQUENCE` an upload sent, never lowering it. */
@Query("UPDATE tasks SET sequence = :sequence WHERE id = :taskId AND sequence < :sequence")
fun raiseSequence(taskId: Long, sequence: Int)
/** Sets `is_dirty` again on [taskId] when it was written after [seen], its `last_modified` when uploaded. */
@Query("UPDATE tasks SET is_dirty = 1 WHERE id = :taskId AND last_modified IS NOT :seen")
fun dirtyIfChangedSince(taskId: Long, seen: Instant?)
@@ -24,7 +24,7 @@ import kotlin.time.Instant
AdvancedOccurrenceEntity::class,
AdvancedDetachedEntity::class,
],
version = 5,
version = 6,
exportSchema = true,
)
@TypeConverters(Converters::class)
@@ -204,5 +204,12 @@ abstract class TasksDatabase : RoomDatabase() {
)
}
}
/** v6 remembers which sub-tasks a moved series reset, so moving it back restores them (#160). */
val MIGRATION_5_6 = object : Migration(5, 6) {
override fun migrate(db: SupportSQLiteDatabase) {
db.execSQL("ALTER TABLE advanced_occurrences ADD COLUMN `reset_subtasks` TEXT NOT NULL DEFAULT ''")
}
}
}
}
@@ -12,6 +12,16 @@ import kotlin.time.Instant
private const val MILLIS_PER_SECOND = 1000L
private const val MILLIS_PER_DAY = 24L * 60 * 60 * 1000
/**
* The zone a task's dates are read in: UTC for an all-day one, whose dates are
* midnights there; else its [timeZone], or [floating] when it has none or an
* unknown one.
*/
fun dateZone(isAllDay: Boolean, timeZone: String?, floating: ZoneId = ZoneId.systemDefault()): ZoneId {
if (isAllDay) return ZoneId.of("UTC")
return timeZone?.let { runCatching { ZoneId.of(it) }.getOrNull() } ?: floating
}
/** The rule set of one task series, as stored. All strings are raw iCalendar values. */
data class RecurrenceSpec(
val rrule: String?,
@@ -133,11 +143,8 @@ object RecurrenceExpander {
return occurrences.indices.map { it - current }
}
private fun zoneOf(spec: RecurrenceSpec, floatingZone: ZoneId): TimeZone {
if (spec.isAllDay) return TimeZone.getTimeZone(ZoneId.of("UTC"))
val stored = spec.timeZone?.let { runCatching { ZoneId.of(it) }.getOrNull() }
return TimeZone.getTimeZone(stored ?: floatingZone)
}
private fun zoneOf(spec: RecurrenceSpec, floatingZone: ZoneId): TimeZone =
TimeZone.getTimeZone(dateZone(spec.isAllDay, spec.timeZone, floatingZone))
/**
* All-day series are date-anchored: pin the anchor to UTC midnight, as it is
@@ -18,6 +18,7 @@ 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.consumeWindowInsets
import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
@@ -268,6 +269,9 @@ private fun DetailBody(
modifier = Modifier
.fillMaxSize()
.padding(inner)
// Consume the bar insets so imePadding adds only what the keyboard
// covers beyond them.
.consumeWindowInsets(inner)
// Shrink the scroll viewport by the keyboard so the focused add-subtask
// field scrolls into view above the IME instead of being hidden.
.imePadding()
@@ -0,0 +1,32 @@
package de.jeanlucmakiola.agendula.ui.edit
import de.jeanlucmakiola.agendula.domain.TaskReminder
/**
* The editor's note that [listName]'s own defaults decided the reminders;
* [none] = they added none to this task.
*/
data class ListDefaultsHint(val listName: String, val none: Boolean)
/**
* The hint once the defaults have been applied, or null. [applied] = the defaults
* played a part (a gained or revived date, or an all-day switch that swapped them
* in); [wanted] are the reminders before that and [result] after. Only a list
* that overrides the general default ([ownDefaults]) gets one: naming it when its
* defaults added reminders, and saying it added none when the task is left with
* no reminder at all.
*/
internal fun listDefaultsHint(
listName: String?,
ownDefaults: Boolean,
applied: Boolean,
wanted: List<TaskReminder>,
result: List<TaskReminder>,
): ListDefaultsHint? {
if (listName == null || !ownDefaults || !applied) return null
return when {
(result - wanted.toSet()).isNotEmpty() -> ListDefaultsHint(listName, none = false)
result.isEmpty() -> ListDefaultsHint(listName, none = true)
else -> null
}
}
@@ -57,6 +57,7 @@ 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.consumeWindowInsets
import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
@@ -219,7 +220,9 @@ fun TaskEditScreen(
viewModel = viewModel,
scroll = scroll,
onTitleBottom = { titleBottom = it },
modifier = Modifier.padding(inner),
// Consumed so EditContent's imePadding adds only what the keyboard
// covers beyond the bars.
modifier = Modifier.padding(inner).consumeWindowInsets(inner),
)
}
@@ -583,6 +586,16 @@ private fun EditContent(
),
onClick = { showReminderPicker = true },
)
state.listDefaultsHint?.let { hint ->
Spacer(Modifier.height(4.dp))
FieldNote(
stringResource(
if (hint.none) R.string.edit_reminder_list_defaults_none else R.string.edit_reminder_list_defaults,
hint.listName,
),
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
if (TaskFormError.REMINDER_WITHOUT_DATE in state.errors) {
Spacer(Modifier.height(4.dp))
FieldError(R.string.error_reminder_without_date)
@@ -1280,10 +1293,14 @@ private fun FieldPickerDialog(
}
@Composable
private fun FieldError(messageRes: Int) {
private fun FieldError(messageRes: Int) = FieldNote(stringResource(messageRes), MaterialTheme.colorScheme.error)
/** A line of small text under a field: an error, or a quieter note. */
@Composable
private fun FieldNote(text: String, color: Color) {
Text(
text = stringResource(messageRes),
color = MaterialTheme.colorScheme.error,
text = text,
color = color,
style = MaterialTheme.typography.bodySmall,
modifier = Modifier.padding(start = 4.dp),
)
@@ -66,6 +66,8 @@ data class TaskEditUiState(
val remindersChosen: Boolean = false,
/** The time an all-day reminder without one of its own rings at. */
val allDayMinuteOfDay: Int = DEFAULT_ALL_DAY_REMINDER_MINUTE,
/** Set while the defaults being applied are the list's own rather than the general ones. */
val listDefaultsHint: ListDefaultsHint? = null,
val location: String = "",
val url: String = "",
val tags: List<String> = emptyList(),
@@ -149,6 +151,12 @@ class TaskEditViewModel @Inject constructor(
private var loadedDue: Instant? = null
private var loadedAllDay = false
/** Whether [loadedReminders] are all-day ones; a task without dates converts them once it gets one. */
private var loadedKindAllDay = false
/** The reminders the user picked before clearing the task's last date, until a date comes back. */
private val setAside = mutableListOf<SetAside>()
/** Start a fresh task, optionally pre-selecting a list / parent. */
fun bindNew(
presetListId: Long? = null,
@@ -161,6 +169,7 @@ class TaskEditViewModel @Inject constructor(
if (bound) return
bound = true
editingTaskId = null
setAside.clear()
baselineLastModified = null
viewModelScope.launch {
val settings = settingsPrefs.settings.first()
@@ -214,6 +223,7 @@ class TaskEditViewModel @Inject constructor(
bound = true
editingTaskId = taskId
editingOccurrence = occurrenceStart
setAside.clear()
viewModelScope.launch {
val settings = settingsPrefs.settings.first()
this@TaskEditViewModel.settings = settings
@@ -230,6 +240,7 @@ class TaskEditViewModel @Inject constructor(
loadedStart = task.start
loadedDue = task.due
loadedAllDay = task.isAllDay
loadedKindAllDay = task.isAllDay
_state.value = withFields(
TaskEditUiState(
loading = false,
@@ -255,7 +266,12 @@ class TaskEditViewModel @Inject constructor(
isOccurrence = task.isOccurrence,
lists = lists,
parentCandidates = loadParents(task.listId, selfId = taskId),
),
).let {
// Reminders stored on a task without dates can't ring; they don't come back with a date either.
if (it.hasDates) return@let it
loadedReminders = emptyList()
it.withoutReminders()
},
).also { baseline = it.toForm() }
editingOccurrence = task.occurrenceStart
}
@@ -296,7 +312,8 @@ class TaskEditViewModel @Inject constructor(
* field that already carries a value (so editing never hides real data).
*/
private fun withFields(state: TaskEditUiState): TaskEditUiState {
val visible = defaultFields + state.toForm().populatedFields()
val visible = defaultFields + state.toForm().populatedFields() +
setOfNotNull(TaskFormField.Reminder.takeIf { state.listDefaultsHint != null })
return state.copy(visibleFields = visible, hiddenFields = hiddenOf(visible))
}
@@ -309,15 +326,22 @@ class TaskEditViewModel @Inject constructor(
/** Switching list invalidates the parent (it lived in the old list); reload candidates. */
fun onListChange(listId: Long) {
if (_state.value.listId == listId) return // re-picking the same list keeps the parent
update { it.copy(listId = listId, parentId = null, errors = emptySet()).withDefaultReminders() }
update { it.copy(listId = listId, parentId = null, errors = emptySet()).withDatedReminders() }
viewModelScope.launch {
val candidates = loadParents(listId, selfId = editingTaskId)
update { it.copy(parentCandidates = candidates) }
}
}
fun onStartChange(value: Instant?) = update { it.copy(start = value).withDefaultReminders() }
fun onDueChange(value: Instant?) = update { it.copy(due = value).withDefaultReminders() }
fun onStartChange(value: Instant?) = update {
val next = it.copy(start = value)
next.withDatedReminders(lostDates = it.hasDates && !next.hasDates)
}
fun onDueChange(value: Instant?) = update {
val next = it.copy(due = value)
next.withDatedReminders(lostDates = it.hasDates && !next.hasDates)
}
/**
* All-day and timed values use different conventions (UTC midnight vs. a real
* instant in the device zone), so the switch has to move the timestamps too —
@@ -334,8 +358,16 @@ class TaskEditViewModel @Inject constructor(
due = it.due?.rebasedForAllDay(value),
)
if (!it.remindersTouched) {
loadedReminders = carried(loadedReminders, switched)
return@update switched.withDefaultReminders()
val before = loadedReminders
val next = switched.withDatedReminders()
// The loaded reminders only change kind on a dated task; the list's defaults swapped in show the hint.
val swapped = before.isNotEmpty() && loadedReminders !== before &&
StoredReminders.keptAcrossSwitch(before, switched.toForm(), settings) == null
return@update if (swapped && next.listDefaultsHint == null) {
next.withListHint(applied = true, wanted = emptyList())
} else {
next
}
}
switched.copy(reminders = carried(it.reminders, switched).sortedForDisplay(switched))
}
@@ -346,12 +378,40 @@ class TaskEditViewModel @Inject constructor(
val carried = if (previous != null && previous.second == reminders) {
previous.first
} else {
StoredReminders.switched(reminders, switched.toForm(), settings, nowMillis(), ZoneId.systemDefault())
switchedFor(reminders, switched)
}
lastSwitch = reminders to carried
return carried
}
/** [reminders] made [state]'s kind, timed or all-day. */
private fun switchedFor(reminders: List<TaskReminder>, state: TaskEditUiState): List<TaskReminder> =
StoredReminders.switched(reminders, state.toForm(), settings, nowMillis(), ZoneId.systemDefault())
/**
* [withDefaultReminders] for a task that may have lost its dates: with none
* left its reminders have nothing to count from and go (#159). Those the user
* picked are set aside when the last date goes and come back with the next
* one; untouched ones come back from [loadedReminders] anyway. Reminders
* picked while the task has no date stay, for the form to point out.
*/
private fun TaskEditUiState.withDatedReminders(lostDates: Boolean = false): TaskEditUiState {
if (!hasDates) {
if (!remindersTouched) return if (reminders.isEmpty()) this else withoutReminders()
if (!lostDates || reminders.isEmpty()) return this
setAside += SetAside(reminders, isAllDay)
return withoutReminders()
}
if (loadedKindAllDay != isAllDay) {
loadedReminders = carried(loadedReminders, this)
loadedKindAllDay = isAllDay
}
if (setAside.isEmpty()) return withDefaultReminders()
val restored = setAside.flatMap { if (it.allDay == isAllDay) it.reminders else switchedFor(it.reminders, this) }
setAside.clear()
return copy(reminders = (reminders + restored).distinct().sortedForDisplay(this), remindersChosen = true)
}
/**
* The reminders the task will be saved with while the user has not
* touched them: those it was loaded with, plus the defaults of the dates
@@ -370,13 +430,39 @@ class TaskEditViewModel @Inject constructor(
ZoneId.systemDefault(),
).sortedForDisplay(this)
val visible = if (reminders.isEmpty()) visibleFields else visibleFields + TaskFormField.Reminder
val applied = StoredReminders.freshAnchors(
toForm().copy(reminders = loadedReminders),
loadedStart,
loadedDue,
loadedAllDay,
settings,
nowMillis(),
ZoneId.systemDefault(),
).isNotEmpty()
return copy(
reminders = reminders,
// A new task's, or defaults added to the ones it had: stored as shown.
remindersChosen = isNew || reminders.toSet() != storedReminders,
visibleFields = visible,
hiddenFields = hiddenOf(visible),
).withListHint(applied, loadedReminders)
}
/**
* Sets [TaskEditUiState.listDefaultsHint] for defaults just applied over [wanted]
* (see [listDefaultsHint]), unfolding the reminders so the hint shows.
*/
private fun TaskEditUiState.withListHint(applied: Boolean, wanted: List<TaskReminder>): TaskEditUiState {
val hint = listDefaultsHint(
listName = lists.firstOrNull { it.id == listId }?.name,
ownDefaults = listId?.let { settings.hasOwnReminders(it, isAllDay) } == true,
applied = applied,
wanted = wanted,
result = reminders,
)
if (hint == null) return copy(listDefaultsHint = null)
val visible = visibleFields + TaskFormField.Reminder
return copy(listDefaultsHint = hint, visibleFields = visible, hiddenFields = hiddenOf(visible))
}
private fun nowMillis(): Long = Clock.System.now().toEpochMilliseconds()
@@ -388,11 +474,12 @@ class TaskEditViewModel @Inject constructor(
reminders = (it.reminders + reminder).distinct().sortedForDisplay(it),
remindersTouched = true,
remindersChosen = true,
listDefaultsHint = null,
errors = emptySet(),
)
}
fun removeReminder(reminder: TaskReminder) = update {
it.copy(reminders = it.reminders - reminder, remindersTouched = true, remindersChosen = true)
it.copy(reminders = it.reminders - reminder, remindersTouched = true, remindersChosen = true, listDefaultsHint = null)
}
fun onLocationChange(value: String) = update { it.copy(location = value) }
fun onUrlChange(value: String) = update { it.copy(url = value) }
@@ -473,6 +560,15 @@ class TaskEditViewModel @Inject constructor(
private fun List<TaskReminder>.sortedForDisplay(state: TaskEditUiState): List<TaskReminder> =
sortedWith(taskReminderDisplayOrder(state.isAllDay, state.allDayMinuteOfDay))
private val TaskEditUiState.hasDates: Boolean get() = start != null || due != null
/** No reminders shown; saved, the task keeps none of its own without turning reminders off. */
private fun TaskEditUiState.withoutReminders(): TaskEditUiState =
copy(reminders = emptyList(), remindersChosen = false, listDefaultsHint = null)
/** Reminders put away while the task has no date, as the kind they were picked in. */
private class SetAside(val reminders: List<TaskReminder>, val allDay: Boolean)
/** Snapshot the editable state as a validated [TaskForm]. */
private fun TaskEditUiState.toForm(): TaskForm = TaskForm(
title = title,
@@ -29,7 +29,12 @@ import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.heightIn
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.statusBarsPadding
import androidx.compose.foundation.layout.WindowInsets
import androidx.compose.foundation.layout.ime
import androidx.compose.foundation.layout.navigationBars
import androidx.compose.foundation.layout.union
import androidx.compose.foundation.layout.windowInsetsBottomHeight
import androidx.compose.foundation.layout.windowInsetsPadding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.LazyListScope
@@ -60,6 +65,7 @@ import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
@@ -513,7 +519,7 @@ private fun HomeTopBar(
Row(
modifier = Modifier
.fillMaxWidth()
.statusBarsPadding()
.windowInsetsPadding(TopAppBarDefaults.windowInsets)
.height(72.dp)
.padding(horizontal = 12.dp),
verticalAlignment = Alignment.CenterVertically,
@@ -672,10 +678,14 @@ private fun SearchResults(
)
}
} else {
// The last result scrolls clear of the navigation bar and the keyboard.
LazyColumn(modifier = Modifier.fillMaxSize()) {
items(results, key = { it.occurrenceKey }) { task ->
UpcomingRow(task = task, onClick = { onOpenTask(task) })
}
item(key = "bottom-inset") {
Spacer(Modifier.windowInsetsBottomHeight(WindowInsets.navigationBars.union(WindowInsets.ime)))
}
}
}
}
@@ -6,16 +6,22 @@ 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.WindowInsetsSides
import androidx.compose.foundation.layout.consumeWindowInsets
import androidx.compose.foundation.layout.fillMaxHeight
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.only
import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.layout.windowInsetsPadding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.rounded.TaskAlt
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.ScaffoldDefaults
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
@@ -44,14 +50,20 @@ private val MAX_CONTENT_WIDTH = 720.dp
/**
* A phone-shaped column centred on a tablet or a landscape screen: a task list
* or a form stretched edge to edge across 1200dp reads as a spreadsheet.
*
* Also clears (and consumes) the side system bars and cutout, e.g. a 3-button
* navigation bar in landscape, so the screens inside only handle top and bottom.
*/
@Composable
internal fun ReadableWidth(modifier: Modifier = Modifier, content: @Composable () -> Unit) {
Box(
modifier = modifier.fillMaxSize().background(MaterialTheme.colorScheme.surface),
modifier = modifier
.fillMaxSize()
.background(MaterialTheme.colorScheme.surface)
.windowInsetsPadding(ScaffoldDefaults.contentWindowInsets.only(WindowInsetsSides.Horizontal)),
contentAlignment = Alignment.TopCenter,
) {
Box(modifier = Modifier.fillMaxSize().widthIn(max = MAX_CONTENT_WIDTH)) { content() }
Box(modifier = Modifier.fillMaxHeight().widthIn(max = MAX_CONTENT_WIDTH).fillMaxWidth()) { content() }
}
}
@@ -74,37 +86,50 @@ internal fun TaskListDetailPanes(
val clear = { selectedId = Dest.NO_ID }
BackHandler(enabled = selectedId != Dest.NO_ID, onBack = clear)
// Each pane clears only the side insets of the screen edge it touches, and
// consumes the other so its scaffold doesn't pad for it again.
val sideInsets = ScaffoldDefaults.contentWindowInsets
val start = sideInsets.only(WindowInsetsSides.Start)
val end = sideInsets.only(WindowInsetsSides.End)
Row(
modifier = Modifier.fillMaxSize().background(MaterialTheme.colorScheme.surface),
horizontalArrangement = Arrangement.spacedBy(8.dp),
) {
Box(Modifier.weight(1f).fillMaxHeight()) { list(select) }
Box(
Modifier
.weight(1f)
.fillMaxHeight()
.windowInsetsPadding(start)
.consumeWindowInsets(end),
) { list(select) }
Surface(
color = MaterialTheme.colorScheme.surfaceContainerLow,
shape = RoundedCornerShape(topStart = 28.dp, bottomStart = 28.dp),
modifier = Modifier.weight(1.2f).fillMaxHeight(),
) {
if (selectedId == Dest.NO_ID) {
EmptyDetailPane()
} else {
val vm: TaskDetailViewModel = hiltViewModel(key = "task-detail-pane")
LaunchedEffect(selectedId, selectedOccurrence) {
vm.bind(
selectedId,
selectedOccurrence.takeIf { it != Dest.NO_ID }?.let(Instant::fromEpochMilliseconds),
Box(Modifier.fillMaxSize().windowInsetsPadding(end).consumeWindowInsets(start)) {
if (selectedId == Dest.NO_ID) {
EmptyDetailPane()
} else {
val vm: TaskDetailViewModel = hiltViewModel(key = "task-detail-pane")
LaunchedEffect(selectedId, selectedOccurrence) {
vm.bind(
selectedId,
selectedOccurrence.takeIf { it != Dest.NO_ID }?.let(Instant::fromEpochMilliseconds),
)
}
TaskDetailScreen(
viewModel = vm,
onEdit = onEdit,
onDeleted = clear,
onBack = clear,
onOpenTask = select,
onDuplicated = { id ->
selectedId = id
selectedOccurrence = Dest.NO_ID
},
)
}
TaskDetailScreen(
viewModel = vm,
onEdit = onEdit,
onDeleted = clear,
onBack = clear,
onOpenTask = select,
onDuplicated = { id ->
selectedId = id
selectedOccurrence = Dest.NO_ID
},
)
}
}
}
@@ -33,12 +33,17 @@ import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.pluralStringResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.AnnotatedString
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import androidx.core.app.ActivityCompat
import androidx.core.app.NotificationManagerCompat
import androidx.core.content.ContextCompat
import androidx.core.net.toUri
import de.jeanlucmakiola.agendula.R
import de.jeanlucmakiola.agendula.data.prefs.ReminderDescription
import de.jeanlucmakiola.agendula.data.prefs.SNOOZE_PRESETS
import de.jeanlucmakiola.agendula.data.reminders.TaskNotifier
import de.jeanlucmakiola.agendula.domain.TaskReminderOrder
@@ -113,6 +118,7 @@ internal fun NotificationsScreen(
var showOffset by remember { mutableStateOf(false) }
var showAllDay by remember { mutableStateOf(false) }
var showSnooze by remember { mutableStateOf(false) }
var showDescription by remember { mutableStateOf(false) }
var showAllDayTime by remember { mutableStateOf(false) }
var perListExpanded by remember { mutableStateOf(false) }
var expandedLists by remember { mutableStateOf(emptySet<Long>()) }
@@ -122,6 +128,9 @@ internal fun NotificationsScreen(
formatMinuteOfDay(state.settings.allDayReminderMinuteOfDay, LocalUse24HourFormat.current),
)
val lists = state.lists.filter { it.id > 0L }
val ownTimed = lists.count { state.settings.hasOwnReminders(it.id, allDay = false) }
val ownAllDay = lists.count { state.settings.hasOwnReminders(it.id, allDay = true) }
val ownAny = lists.count { state.settings.hasOwnReminders(it.id) }
CollapsingScaffold(
title = stringResource(R.string.settings_section_reminders),
@@ -162,13 +171,13 @@ internal fun NotificationsScreen(
}
GroupedRow(
title = stringResource(R.string.settings_default_reminder),
summary = reminderChoiceLabel(state.settings.defaultReminders),
summary = withOwnCount(reminderChoiceLabel(state.settings.defaultReminders), ownTimed),
position = Position.Middle,
onClick = { showOffset = true },
)
GroupedRow(
title = stringResource(R.string.settings_default_reminder_allday),
summary = reminderChoiceLabel(state.settings.defaultAllDayReminders, allDay = true),
summary = withOwnCount(reminderChoiceLabel(state.settings.defaultAllDayReminders, allDay = true), ownAllDay),
position = Position.Middle,
onClick = { showAllDay = true },
)
@@ -178,9 +187,15 @@ internal fun NotificationsScreen(
R.string.settings_allday_reminder_time_summary,
formatMinuteOfDay(state.settings.allDayReminderMinuteOfDay, LocalUse24HourFormat.current),
),
position = Position.Bottom,
position = Position.Middle,
onClick = { showAllDayTime = true },
)
GroupedRow(
title = stringResource(R.string.settings_reminder_description),
summary = reminderDescriptionLabel(state.settings.reminderDescription),
position = Position.Bottom,
onClick = { showDescription = true },
)
Spacer(Modifier.height(24.dp))
val batteryExempt = rememberBatteryOptimizationExempt(context)
@@ -209,7 +224,10 @@ internal fun NotificationsScreen(
// opens its bottom (Top) when expanded, and the last list rounds it off.
GroupedRow(
title = stringResource(R.string.settings_list_reminders_title),
summary = stringResource(R.string.settings_list_reminders_hint),
summary = listOfNotNull(
if (ownAny > 0) pluralStringResource(R.plurals.settings_list_reminders_own_count, ownAny, ownAny) else null,
stringResource(R.string.settings_list_reminders_hint),
).joinToString("\n"),
position = if (perListExpanded) Position.Top else Position.Alone,
trailing = {
Icon(
@@ -232,7 +250,8 @@ internal fun NotificationsScreen(
// Every list is mid-run under the header; the last rounds
// off, unless it is open and its two rows close the run.
GroupedRow(
title = list.name,
title = AnnotatedString(list.name),
summary = listSourceSummary(state.settings.hasOwnReminders(list.id)),
position = if (last && !expanded) Position.Bottom else Position.Middle,
leading = {
Icon(Icons.Rounded.Circle, contentDescription = null, tint = pastelize(list.color, dark))
@@ -318,6 +337,17 @@ internal fun NotificationsScreen(
onDismiss = { showSnooze = false },
)
}
if (showDescription) {
OptionPicker(
title = stringResource(R.string.settings_reminder_description),
options = ReminderDescription.entries,
selected = state.settings.reminderDescription,
label = { reminderDescriptionLabel(it) },
summary = { reminderDescriptionSummary(it) },
onSelect = viewModel::setReminderDescription,
onDismiss = { showDescription = false },
)
}
if (showAllDayTime) {
val minute = state.settings.allDayReminderMinuteOfDay
TimePickerAlert(
@@ -354,9 +384,46 @@ private fun snoozeLabel(minutes: Int): String =
if (minutes % 60 == 0) pluralStringResource(R.plurals.duration_hours, minutes / 60, minutes / 60)
else pluralStringResource(R.plurals.duration_minutes, minutes, minutes)
@Composable
private fun reminderDescriptionLabel(pref: ReminderDescription): String = stringResource(
when (pref) {
ReminderDescription.HIDDEN -> R.string.settings_reminder_description_hidden
ReminderDescription.SHORT -> R.string.settings_reminder_description_short
ReminderDescription.FULL -> R.string.settings_reminder_description_full
},
)
@Composable
private fun reminderDescriptionSummary(pref: ReminderDescription): String = stringResource(
when (pref) {
ReminderDescription.HIDDEN -> R.string.settings_reminder_description_hidden_summary
ReminderDescription.SHORT -> R.string.settings_reminder_description_short_summary
ReminderDescription.FULL -> R.string.settings_reminder_description_full_summary
},
)
/** Which list's override picker is open, and for which kind of task. */
private data class OverrideTarget(val listId: Long, val allDay: Boolean)
/** The default row's summary, with a second line counting the lists that override it. */
@Composable
private fun withOwnCount(label: String, own: Int): String =
if (own == 0) label
else label + "\n" + pluralStringResource(R.plurals.settings_default_reminder_lists_own, own, own)
/** Whether a list follows the general default; an override stands out in the primary colour. */
@Composable
private fun listSourceSummary(own: Boolean): AnnotatedString =
if (own) {
buildAnnotatedString {
withStyle(SpanStyle(color = MaterialTheme.colorScheme.primary)) {
append(stringResource(R.string.settings_list_reminder_own))
}
}
} else {
AnnotatedString(stringResource(R.string.settings_list_reminder_follows))
}
/** Row summary for a list: its override, or the inherited global default. */
@Composable
private fun listOverrideSummary(choice: ReminderOverride, globalDefault: List<ReminderLead>, allDay: Boolean): String =
@@ -6,6 +6,7 @@ import dagger.hilt.android.lifecycle.HiltViewModel
import de.jeanlucmakiola.agendula.data.appname.LauncherName
import de.jeanlucmakiola.agendula.data.appname.LauncherNameManager
import de.jeanlucmakiola.agendula.data.di.IoDispatcher
import de.jeanlucmakiola.agendula.data.prefs.ReminderDescription
import de.jeanlucmakiola.agendula.data.prefs.Settings
import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
import de.jeanlucmakiola.agendula.data.prefs.ThemeMode
@@ -259,6 +260,7 @@ class SettingsViewModel @Inject constructor(
fun setTimeFormat(pref: TimeFormatPref) = viewModelScope.launch { prefs.setTimeFormat(pref) }
fun setWeekStart(day: DayOfWeek?) = viewModelScope.launch { prefs.setWeekStart(day) }
fun setSnoozeMinutes(minutes: Int) = viewModelScope.launch { prefs.setSnoozeMinutes(minutes) }
fun setReminderDescription(pref: ReminderDescription) = viewModelScope.launch { prefs.setReminderDescription(pref) }
fun setShowAddSubtaskRow(show: Boolean) = viewModelScope.launch { prefs.setShowAddSubtaskRow(show) }
fun setBottomAddBar(enabled: Boolean) = viewModelScope.launch { prefs.setBottomAddBar(enabled) }
fun setDefaultStartToday(enabled: Boolean) = viewModelScope.launch { prefs.setDefaultStartToday(enabled) }
@@ -22,6 +22,9 @@ import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.WindowInsets
import androidx.compose.foundation.layout.WindowInsetsSides
import androidx.compose.foundation.layout.displayCutout
import androidx.compose.foundation.layout.only
import androidx.compose.foundation.layout.ime
import androidx.compose.foundation.layout.isImeVisible
import androidx.compose.foundation.layout.navigationBars
@@ -424,7 +427,9 @@ private fun TaskListBody(
modifier = Modifier.fillMaxSize().then(viewport),
contentPadding = PaddingValues(
top = inner.calculateTopPadding() + 8.dp,
bottom = inner.calculateBottomPadding() + if (bottomBarShown) 16.dp else 96.dp,
// While typing the viewport already ends above the bar or keyboard.
bottom = (if (imeVisible) 0.dp else inner.calculateBottomPadding()) +
if (bottomBarShown) 16.dp else 96.dp,
),
) {
if (state.tasks.isEmpty()) {
@@ -618,7 +623,11 @@ private fun QuickAddBar(onAdd: (String) -> Unit) {
Box(
modifier = Modifier
.fillMaxWidth()
.windowInsetsPadding(WindowInsets.ime.union(WindowInsets.navigationBars)),
.windowInsetsPadding(
WindowInsets.ime
.union(WindowInsets.navigationBars)
.union(WindowInsets.displayCutout.only(WindowInsetsSides.Horizontal)),
),
) {
InlineAdd(onAdd = onAdd, elevated = true)
}
+19
View File
@@ -127,6 +127,16 @@
<string name="settings_list_notifications">Sound &amp; vibration</string>
<string name="settings_list_notifications_hint">Sound, vibration and importance for this list’s reminders</string>
<string name="settings_list_reminder_inherits">Default (%1$s)</string>
<string name="settings_list_reminder_own">Own default reminders</string>
<string name="settings_list_reminder_follows">Follows the default</string>
<plurals name="settings_list_reminders_own_count">
<item quantity="one">%1$d list has its own default reminders</item>
<item quantity="other">%1$d lists have their own default reminders</item>
</plurals>
<plurals name="settings_default_reminder_lists_own">
<item quantity="one">%1$d list uses its own</item>
<item quantity="other">%1$d lists use their own</item>
</plurals>
<!-- Recurrence: read-out and picker -->
<string name="recurrence_title">Repeat</string>
@@ -200,6 +210,8 @@
<string name="edit_reminder_add">Add reminder</string>
<string name="edit_reminder_add_first">Add a reminder (otherwise the default applies)</string>
<string name="edit_reminder_remove">Remove reminder</string>
<string name="edit_reminder_list_defaults">Default reminders from list %1$s</string>
<string name="edit_reminder_list_defaults_none">List %1$s sets no default reminder for this task</string>
<string name="reminder_at_start">At start time</string>
<string name="reminder_at_due_time">At due time</string>
<string name="reminder_on_start_date">On the start date</string>
@@ -472,6 +484,13 @@
<string name="settings_snooze_duration">Snooze duration</string>
<string name="settings_reliable_delivery_hint">Android may delay reminders to save battery. Exempt Agendula so they arrive on time.</string>
<string name="settings_reliable_delivery_exempt">Exempt from battery optimisation — reminders arrive on time.</string>
<string name="settings_reminder_description">Description in reminders</string>
<string name="settings_reminder_description_hidden">Hidden</string>
<string name="settings_reminder_description_short">Short</string>
<string name="settings_reminder_description_full">Full</string>
<string name="settings_reminder_description_hidden_summary">Only the title and due time</string>
<string name="settings_reminder_description_short_summary">A short preview of the description</string>
<string name="settings_reminder_description_full_summary">The whole description</string>
<string name="settings_default_list">Default list</string>
<string name="settings_default_list_first">First available list</string>
<string name="settings_add_subtask_row">Show \"add a subtask\" row</string>
@@ -0,0 +1,167 @@
package de.jeanlucmakiola.agendula.data.reminders
import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.agendula.data.prefs.ReminderDescription
import org.junit.jupiter.api.Test
class ShortDescriptionTest {
@Test
fun `short text is left alone`() {
assertThat(shortDescription("Buy oat milk")).isEqualTo("Buy oat milk")
}
@Test
fun `three short lines fit`() {
assertThat(shortDescription("one\ntwo\nthree")).isEqualTo("one\ntwo\nthree")
}
@Test
fun `lines past the third are cut with an ellipsis`() {
assertThat(shortDescription("one\ntwo\nthree\nfour\nfive")).isEqualTo("one\ntwo\nthree…")
}
@Test
fun `text that fits comes back unchanged, blank lines included`() {
assertThat(shortDescription("one\n\ntwo")).isEqualTo("one\n\ntwo")
assertThat(shortDescription("one\r\ntwo")).isEqualTo("one\r\ntwo")
}
@Test
fun `a blank line counts as a row`() {
assertThat(shortDescription("one\n\ntwo\n\nthree")).isEqualTo("one\n\ntwo…")
}
@Test
fun `an ellipsis never follows a blank line`() {
assertThat(shortDescription("one\ntwo\n\nthree")).isEqualTo("one\ntwo…")
}
@Test
fun `a long paragraph is cut at a word within the line budget`() {
val text = List(40) { "word" }.joinToString(" ")
val short = shortDescription(text, maxLines = 3, lineChars = 40)
assertThat(short).endsWith("word…")
assertThat(short.length).isAtMost(3 * 40)
}
@Test
fun `a wrapping line counts as the lines it takes`() {
val long = "a".repeat(70)
val short = shortDescription("$long\nsecond\nthird", maxLines = 3, lineChars = 40)
assertThat(short).isEqualTo("$long\nsecond…")
}
@Test
fun `a word with no break is cut hard`() {
val short = shortDescription("x".repeat(200), maxLines = 3, lineChars = 40)
assertThat(short).isEqualTo("x".repeat(119) + "…")
}
@Test
fun `trailing punctuation gives way to the ellipsis`() {
assertThat(shortDescription("one.\ntwo,\nthree.\nfour")).isEqualTo("one.\ntwo,\nthree…")
}
@Test
fun `a line that fills the budget exactly leaves room for the ellipsis`() {
val full = "a".repeat(120)
val short = shortDescription("$full\nmore", maxLines = 3, lineChars = 40)
assertThat(short).isEqualTo("a".repeat(119) + "…")
}
@Test
fun `a cut never splits an emoji`() {
val short = shortDescription("x".repeat(118) + "😀" + "y".repeat(10), maxLines = 3, lineChars = 40)
assertThat(short).isEqualTo("x".repeat(118) + "…")
}
@Test
fun `a word that ends right at the cut is kept`() {
val short = shortDescription("aaaa bbbb cccc", maxLines = 1, lineChars = 10)
assertThat(short).isEqualTo("aaaa bbbb…")
}
@Test
fun `tabs count as word breaks`() {
val short = shortDescription("Meeting\tagenda\tnotes", maxLines = 1, lineChars = 12)
assertThat(short).isEqualTo("Meeting…")
}
@Test
fun `no space is left before the ellipsis`() {
assertThat(shortDescription("see list :\nmore", maxLines = 1, lineChars = 40)).isEqualTo("see list…")
}
@Test
fun `wide characters take two cells`() {
val short = shortDescription("中".repeat(30), maxLines = 1, lineChars = 20)
assertThat(short).isEqualTo("中".repeat(9) + "…")
}
@Test
fun `the setting picks what the reminder shows`() {
val long = List(60) { "word" }.joinToString(" ")
assertThat(reminderBody(ReminderDescription.FULL) { long }).isEqualTo(long)
assertThat(reminderBody(ReminderDescription.SHORT) { long }).isEqualTo(shortDescription(long))
assertThat(reminderBody(ReminderDescription.FULL) { " " }).isNull()
}
@Test
fun `hidden never converts the description`() {
var read = false
assertThat(reminderBody(ReminderDescription.HIDDEN) { read = true; "text" }).isNull()
assertThat(read).isFalse()
}
@Test
fun `a cut keeps a flag whole`() {
val short = shortDescription("x".repeat(117) + "🇩🇪" + "y".repeat(10), maxLines = 3, lineChars = 40)
assertThat(short).isEqualTo("x".repeat(117) + "🇩🇪…")
}
@Test
fun `a cut keeps a skin tone with its emoji`() {
val short = shortDescription("x".repeat(117) + "👍🏽" + "y".repeat(10), maxLines = 3, lineChars = 40)
assertThat(short).isEqualTo("x".repeat(117) + "👍🏽…")
}
@Test
fun `a cut keeps a ZWJ sequence whole`() {
val short = shortDescription("x".repeat(117) + "👩‍💻" + "y".repeat(10), maxLines = 3, lineChars = 40)
assertThat(short).isEqualTo("x".repeat(117) + "👩‍💻…")
}
@Test
fun `a cut keeps a combining accent with its letter`() {
val short = shortDescription("x".repeat(118) + "é" + "y".repeat(10), maxLines = 3, lineChars = 40)
assertThat(short).isEqualTo("x".repeat(118) + "é…")
}
@Test
fun `marks take no cells`() {
assertThat(displayWidth("مَرْحَبًا")).isEqualTo(5)
assertThat(displayWidth("é")).isEqualTo(1)
}
@Test
fun `CJK punctuation is wide`() {
assertThat(displayWidth("。、")).isEqualTo(4)
}
@Test
fun `each emoji takes two cells, however many code points it has`() {
assertThat(displayWidth("✅")).isEqualTo(2)
assertThat(displayWidth("🇩🇪")).isEqualTo(2)
assertThat(displayWidth("👍🏽")).isEqualTo(2)
assertThat(displayWidth("👨‍👩‍👧‍👦")).isEqualTo(2)
}
@Test
fun `line length follows the text width and size`() {
assertThat(notificationLineChars(textWidthPx = 296f, textSizePx = 14f)).isEqualTo(40)
assertThat(notificationLineChars(textWidthPx = 296f * 2.625f, textSizePx = 14f * 2.625f)).isEqualTo(40)
assertThat(notificationLineChars(textWidthPx = 296f, textSizePx = 14f * 1.3f)).isEqualTo(31)
assertThat(notificationLineChars(textWidthPx = 0f, textSizePx = 14f)).isEqualTo(NOTIFICATION_LINE_CHARS)
}
}
@@ -0,0 +1,24 @@
package de.jeanlucmakiola.agendula.data.tasks
import com.google.common.truth.Truth.assertThat
import org.junit.jupiter.api.Test
class SqlChunksTest {
@Test
fun `ids are split so no query binds more than the limit`() {
val ids = (1L..2_100L).toList()
val chunks = inSelections("_id", ids, filter = "deleted = ?", filterArgs = listOf("0"))
assertThat(chunks.map { it.second.size }).containsExactly(999, 999, 105).inOrder()
assertThat(chunks.flatMap { (_, args) -> args.dropLast(1) }).isEqualTo(ids.map(Long::toString))
assertThat(chunks.all { (_, args) -> args.last() == "0" }).isTrue()
assertThat(chunks.first().first).endsWith("?) AND (deleted = ?)")
}
@Test
fun `repeated ids are bound once, and none give no query`() {
assertThat(inSelections("_id", listOf(3L, 3L, 4L)).single().second).asList().containsExactly("3", "4")
assertThat(inSelections("_id", emptyList())).isEmpty()
}
}
@@ -0,0 +1,332 @@
package de.jeanlucmakiola.agendula.data.tasks
import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Tasks
import de.jeanlucmakiola.agendula.domain.TaskStatus
import de.jeanlucmakiola.agendula.domain.recurrence.RecurrenceSpec
import org.junit.jupiter.api.Test
import java.time.ZoneId
import java.time.ZoneOffset
import kotlin.time.Instant
class SubtaskResetTest {
private val done = SubtaskState(TaskStatus.COMPLETED, 100, 1_000L)
private val halfway = SubtaskState(TaskStatus.IN_PROCESS, 50, null)
private val cancelled = SubtaskState(TaskStatus.CANCELLED, null, null)
private fun node(id: Long, state: SubtaskState = done, recurring: Boolean = false) = SubtaskNode(id, recurring, state)
private fun reset(vararg tree: Pair<Long, List<SubtaskNode>>): List<Long> {
val children = tree.toMap()
return SubtaskReset.toReset(1L) { children[it].orEmpty() }.map { it.id }
}
@Test
fun `completed and half-done sub-tasks of a routine start over, fresh ones are left (#160)`() {
val reopened = reset(1L to listOf(node(2), node(3, SubtaskState.FRESH), node(4, halfway)))
assertThat(reopened).containsExactly(2L, 4L)
}
@Test
fun `an open sub-task with progress counts as started`() {
assertThat(reset(1L to listOf(node(2, SubtaskState(TaskStatus.NEEDS_ACTION, 20, null))))).containsExactly(2L)
}
@Test
fun `a cancelled sub-task stays cancelled, what is under it still starts over`() {
assertThat(reset(1L to listOf(node(2, cancelled)), 2L to listOf(node(3)))).containsExactly(3L)
}
@Test
fun `nested sub-tasks start over too, also under a fresh one`() {
val reopened = reset(
1L to listOf(node(2, SubtaskState.FRESH)),
2L to listOf(node(3)),
3L to listOf(node(4)),
)
assertThat(reopened).containsExactly(3L, 4L)
}
@Test
fun `a recurring sub-task, or a copy a tick of one left, is left alone with what is under it`() {
val reopened = reset(
1L to listOf(node(2, recurring = true), node(3), node(5, recurring = true)),
2L to listOf(node(4)),
)
assertThat(reopened).containsExactly(3L)
}
@Test
fun `a provider copy is left alone while it sits under the parent it was recorded or marked for`() {
assertThat(SubtaskReset.recursOrCopy("FREQ=DAILY", null, null, null, "routine")).isTrue()
assertThat(SubtaskReset.recursOrCopy(null, "20261110T080000Z", null, null, "routine")).isTrue()
assertThat(SubtaskReset.recursOrCopy(" ", null, null, null, "routine")).isFalse()
assertThat(SubtaskReset.recursOrCopy(null, null, knownParent = "routine", markerParent = null, parentUid = "routine")).isTrue()
assertThat(SubtaskReset.recursOrCopy(null, null, knownParent = null, markerParent = "routine", parentUid = "routine")).isTrue()
// Moved under another parent since: an ordinary completed sub-task there.
assertThat(SubtaskReset.recursOrCopy(null, null, knownParent = "routine", markerParent = "routine", parentUid = "other")).isFalse()
assertThat(SubtaskReset.recursOrCopy(null, null, knownParent = "routine", markerParent = null, parentUid = null)).isFalse()
}
@Test
fun `sub-tasks in other lists join the routine's tree, level by level, each parent asked once`() {
// id to parent: 2 and 3 in the routine's list, 4 elsewhere under 2, 5 elsewhere under 4, 6 back in the list under 5.
val listRows = listOf(2L to 1L, 3L to 1L, 6L to 5L, 9L to 8L)
val elsewhere = listOf(4L to 2L, 5L to 4L, 7L to 99L)
val asked = mutableListOf<Set<Long>>()
val merged = SubtaskReset.mergeSubtree(1L, listRows, { it.first }, { it.second }) { parents ->
asked += parents
elsewhere.filter { it.second in parents }
}
assertThat(merged.map { it.first }).containsExactly(2L, 3L, 6L, 9L, 4L, 5L)
assertThat(asked).containsExactly(setOf(1L, 2L, 3L), setOf(4L), setOf(5L, 6L)).inOrder()
}
@Test
fun `a cycle or the parent listed under itself is not walked twice`() {
val reopened = reset(
1L to listOf(node(1), node(2)),
2L to listOf(node(3)),
3L to listOf(node(2)),
)
assertThat(reopened).containsExactly(2L, 3L)
}
@Test
fun `only what was completed or changed during the closed cycle starts over`() {
val since = at("2026-11-02T08:00:00Z")
fun completed(at: Long) = SubtaskState(TaskStatus.COMPLETED, 100, at)
val nodes = listOf(
SubtaskNode(2, false, completed(since)),
SubtaskNode(3, false, completed(since + 1)),
// An unmarked copy from an earlier cycle.
SubtaskNode(4, false, completed(since - 1)),
SubtaskNode(5, false, halfway, lastModified = since + 1),
SubtaskNode(6, false, halfway, lastModified = since - 1),
// Nothing to date it by.
SubtaskNode(7, false, halfway),
SubtaskNode(8, false, SubtaskState(TaskStatus.COMPLETED, 100, null), lastModified = since + 1),
)
val reset = SubtaskReset.toReset(1L, since = since) { if (it == 1L) nodes else emptyList() }
assertThat(reset.map { it.id }).containsExactly(2L, 3L, 5L, 8L)
assertThat(SubtaskReset.cycleStart(at("2026-11-09T08:00:00Z"), at("2026-11-16T08:00:00Z"))).isEqualTo(since)
}
@Test
fun `an earlier cycle's completed sub-task is neither reset nor moved`() {
val shift = SeriesShift(at("2026-11-09T08:00:00Z"), at("2026-11-16T08:00:00Z"), ZoneOffset.UTC)
val old = SubtaskNode(2, false, SubtaskState(TaskStatus.COMPLETED, 100, at("2026-10-01T08:00:00Z")), SubtaskDates(at("2026-10-01T08:00:00Z"), null))
assertThat(SubtaskReset.toReset(1L, shift, since = at("2026-11-02T08:00:00Z")) { if (it == 1L) listOf(old) else emptyList() }).isEmpty()
}
@Test
fun `what was reset survives encoding`() {
val reset = listOf(
ResetSubtask(2, done),
ResetSubtask(3, halfway, SubtaskDates(1L, 2L), SubtaskDates(11L, 12L)),
ResetSubtask(4, SubtaskState(TaskStatus.NEEDS_ACTION, 10, null), SubtaskDates(null, 5L), SubtaskDates(null, 15L)),
)
assertThat(SubtaskReset.decode(SubtaskReset.encode(reset))).isEqualTo(reset)
assertThat(SubtaskReset.decode("")).isEmpty()
assertThat(SubtaskReset.decode(null)).isEmpty()
assertThat(SubtaskReset.decode("2,COMPLETED,100,1000")).isEmpty()
assertThat(SubtaskReset.decode("x,COMPLETED,,,,,,;2,NOPE,,,,,,;3,IN_PROCESS")).isEmpty()
}
private fun now(state: SubtaskState, dates: SubtaskDates = SubtaskDates.NONE, allDay: Boolean = false) = SubtaskNow(state, dates, allDay)
@Test
fun `moving back gives back state and dates each where the reset's still stands`() {
val prior = SubtaskDates(10_000L, null)
val moved = SubtaskDates(20_000L, null)
val reset = listOf(
ResetSubtask(2, done),
ResetSubtask(3, halfway),
ResetSubtask(4, done),
ResetSubtask(5, done, prior, moved),
ResetSubtask(6, done, prior, moved),
ResetSubtask(7, done, prior, moved),
)
val current = mapOf(
2L to now(SubtaskState.FRESH),
3L to now(done),
5L to now(SubtaskState.FRESH, moved),
// Re-dated since: the user's dates stay, the state comes back.
6L to now(SubtaskState.FRESH, SubtaskDates(30_000L, null)),
// Ticked since: the user's state stays, the dates go back.
7L to now(done, moved),
)
val outcome = SubtaskReset.toRestore(reset, current::get)
assertThat(outcome.restore).containsExactly(
SubtaskBack(2, done, null),
SubtaskBack(5, done, prior),
SubtaskBack(6, done, null),
SubtaskBack(7, null, prior),
)
// 4 is gone: neither restored nor reported as changed.
assertThat(outcome.changed).containsExactly(3L, 6L, 7L)
}
@Test
fun `dates compare as a store keeps them, to the second or the day`() {
val timed = ResetSubtask(2, done, SubtaskDates(1L, null), SubtaskDates(at("2026-11-09T10:00:00.250Z"), null))
val allDay = ResetSubtask(3, done, SubtaskDates(null, 1L), SubtaskDates(null, at("2026-11-10T00:00:00Z")))
fun datesBack(entry: ResetSubtask, stored: Long, isAllDay: Boolean) =
SubtaskReset.toRestore(listOf(entry)) { now(done, SubtaskDates(if (isAllDay) null else stored, if (isAllDay) stored else null), isAllDay) }
.restore.singleOrNull()?.dates != null
assertThat(datesBack(timed, at("2026-11-09T10:00:00Z"), isAllDay = false)).isTrue()
assertThat(datesBack(timed, at("2026-11-09T10:00:01Z"), isAllDay = false)).isFalse()
assertThat(datesBack(allDay, at("2026-11-10T12:00:00Z"), isAllDay = true)).isTrue()
assertThat(datesBack(allDay, at("2026-11-11T00:00:00Z"), isAllDay = true)).isFalse()
}
private val berlin = ZoneId.of("Europe/Berlin")
private fun at(text: String) = java.time.Instant.parse(text).toEpochMilli()
@Test
fun `a dated sub-task keeps its offset to the routine across a DST change`() {
// A weekly routine at 09:00 Berlin moves from the last Monday of summer time to the first of winter time.
val shift = SeriesShift(at("2026-10-19T07:00:00Z"), at("2026-10-26T08:00:00Z"), berlin)
assertThat(shift.apply(at("2026-10-20T08:00:00Z"), isAllDay = false)).isEqualTo(at("2026-10-27T09:00:00Z"))
assertThat(shift.apply(at("2026-10-21T00:00:00Z"), isAllDay = true)).isEqualTo(at("2026-10-28T00:00:00Z"))
}
@Test
fun `a sub-task stored in UTC under a Berlin routine keeps its offset across DST`() {
// 10:00 Berlin, an hour after the routine, stored as 08:00 UTC: an hour after it again a week on, at 09:00 UTC.
val shift = SeriesShift(at("2026-10-19T07:00:00Z"), at("2026-10-26T08:00:00Z"), berlin)
val moved = shift.apply(at("2026-10-19T08:00:00Z"), isAllDay = false)
assertThat(moved).isEqualTo(at("2026-10-26T09:00:00Z"))
assertThat(moved - at("2026-10-26T08:00:00Z")).isEqualTo(at("2026-10-19T08:00:00Z") - at("2026-10-19T07:00:00Z"))
}
@Test
fun `an all-day sub-task follows the routine's change of date, also on a step under a day`() {
// An eight-hourly routine moves from 20:00 to 04:00 the next day in Berlin.
val shift = SeriesShift(at("2026-11-09T19:00:00Z"), at("2026-11-10T03:00:00Z"), berlin)
assertThat(shift.apply(at("2026-11-09T00:00:00Z"), isAllDay = true)).isEqualTo(at("2026-11-10T00:00:00Z"))
// From 04:00 to 12:00 the date stays.
val sameDay = SeriesShift(at("2026-11-10T03:00:00Z"), at("2026-11-10T11:00:00Z"), berlin)
assertThat(sameDay.apply(at("2026-11-10T00:00:00Z"), isAllDay = true)).isEqualTo(at("2026-11-10T00:00:00Z"))
}
@Test
fun `moving on shifts dated sub-tasks, fresh ones included, and leaves undated fresh ones`() {
val shift = SeriesShift(at("2026-11-02T08:00:00Z"), at("2026-11-09T08:00:00Z"), ZoneOffset.UTC)
val nodes = listOf(
SubtaskNode(2, false, done, SubtaskDates(at("2026-11-02T10:00:00Z"), null)),
SubtaskNode(3, false, SubtaskState.FRESH, SubtaskDates(null, at("2026-11-03T00:00:00Z")), isAllDay = true),
SubtaskNode(4, false, SubtaskState.FRESH),
SubtaskNode(5, false, cancelled, SubtaskDates(at("2026-11-02T10:00:00Z"), null)),
)
val reset = SubtaskReset.toReset(1L, shift) { if (it == 1L) nodes else emptyList() }
assertThat(reset).containsExactly(
ResetSubtask(2, done, SubtaskDates(at("2026-11-02T10:00:00Z"), null), SubtaskDates(at("2026-11-09T10:00:00Z"), null)),
ResetSubtask(3, SubtaskState.FRESH, SubtaskDates(null, at("2026-11-03T00:00:00Z")), SubtaskDates(null, at("2026-11-10T00:00:00Z"))),
)
}
@Test
fun `a provider series' shift is read in its own zone`() {
val before = mapOf<String, Any?>(Tasks.DTSTART to at("2026-10-19T07:00:00Z"), Tasks.TZ to "Europe/Berlin", Tasks.IS_ALLDAY to 0L)
val after = before + (Tasks.DTSTART to at("2026-10-26T08:00:00Z"))
val shift = SubtaskReset.shiftOf(before, after, floating = ZoneOffset.UTC)!!
assertThat(shift.apply(at("2026-10-20T08:00:00Z"), isAllDay = false)).isEqualTo(at("2026-10-27T09:00:00Z"))
}
@Test
fun `a provider series' rule set is read from its columns`() {
val state = mapOf<String, Any?>(
Tasks.DTSTART to at("2026-11-02T08:00:00Z"), Tasks.RRULE to "FREQ=WEEKLY", Tasks.EXDATE to null,
Tasks.IS_ALLDAY to 1L, Tasks.TZ to null,
)
val spec = SubtaskReset.specOf(state)!!
assertThat(spec.rrule).isEqualTo("FREQ=WEEKLY")
assertThat(spec.isAllDay).isTrue()
assertThat(SubtaskReset.specOf(state + (Tasks.RRULE to " "))!!.rrule).isNull()
assertThat(SubtaskReset.specOf(state + (Tasks.DTSTART to null))).isNull()
}
@Test
fun `the copy marker names the parent it was left under`() {
val json = SubtaskReset.copyMarkerJson("parent-\"1\"")
assertThat(SubtaskReset.markerParentFromJson(json)).isEqualTo("parent-\"1\"")
assertThat(SubtaskReset.markerParentFromJson(" [\"x-agendula-tick-copy\", \"p\"]")).isEqualTo("p")
assertThat(SubtaskReset.markerParentFromJson("[\"X-AGENDULA-TICK-COPYRIGHT\",\"p\"]")).isNull()
assertThat(SubtaskReset.markerParentFromJson(null)).isNull()
assertThat(SubtaskReset.markerParentFromResidue("X-OTHER:1\r\nX-AGENDULA-TICK-COPY:p\\,1")).isEqualTo("p,1")
assertThat(SubtaskReset.markerParentFromResidue("X-AGENDULA-TICK-COPY;X-P=1:p")).isEqualTo("p")
assertThat(SubtaskReset.markerParentFromResidue("X-AGENDULA-TICK-COPYRIGHT:p")).isNull()
assertThat(SubtaskReset.markerParentFromResidue(null)).isNull()
}
@Test
fun `a moved-on provider series resets, and a copy's record is found by series and anchor`() {
val before = state(start) + (Tasks.RRULE to "FREQ=WEEKLY")
val after = state(start + week) + (Tasks.RRULE to "FREQ=WEEKLY")
assertThat(SubtaskReset.movedOn(before, after)).isTrue()
assertThat(SubtaskReset.movedOn(before, before)).isFalse()
val anchor = SubtaskReset.anchor(after)!!
val key = TickResets.key("org.dmfs.tasks", 4, anchor)
val record = SubtaskReset.encode(listOf(ResetSubtask(2, done)))
assertThat(key).isEqualTo("org.dmfs.tasks|4|${start + week}")
assertThat(TickResets.decode(TickResets.encode(1L, record))).isEqualTo(record)
assertThat(SubtaskReset.toRestore(SubtaskReset.decode(record)) { now(SubtaskState.FRESH) }.restore.map { it.id }).containsExactly(2L)
}
@Test
fun `a reset record expires with the tick horizon`() {
val now = 100L * 24 * 60 * 60 * 1000
val entries = mapOf(
"a|1|1" to TickResets.encode(now - 31L * 24 * 60 * 60 * 1000, "2,COMPLETED,,,,,,"),
"a|1|2" to TickResets.encode(now - 1, "3,COMPLETED,,,,,,"),
"garbage" to "x",
)
assertThat(TickResets.expire(entries, now)).containsExactly("a|1|1", "garbage")
assertThat(TickResets.decode("x")).isNull()
}
private val week = 7L * 24 * 60 * 60 * 1000
private val start = Instant.parse("2026-11-02T08:00:00Z").toEpochMilliseconds()
private fun state(dtstart: Long?, status: Int = TasksContract.STATUS_NEEDS_ACTION, exdate: String? = null, due: Long? = null) =
mapOf<String, Any?>(Tasks.DTSTART to dtstart, Tasks.DUE to due, Tasks.STATUS to status.toLong(), Tasks.EXDATE to exdate)
private fun spec(at: Long, rrule: String = "FREQ=WEEKLY") =
RecurrenceSpec(rrule = rrule, rdate = null, exdate = null, anchor = Instant.fromEpochMilliseconds(at), isAllDay = false, timeZone = "UTC")
@Test
fun `a provider series whose start moved later has moved on`() {
assertThat(SubtaskReset.movedOn(state(start), state(start + week), spec(start + week))).isTrue()
assertThat(SubtaskReset.movedOn(state(null, due = start), state(null, due = start + week), spec(start + week))).isTrue()
}
@Test
fun `ticking a later occurrence only adds an exception and moves nothing`() {
val after = state(start, exdate = "20261109T080000Z")
assertThat(SubtaskReset.movedOn(state(start), after, spec(start))).isFalse()
}
@Test
fun `a provider series ticked on its last occurrence is finished`() {
// OpenTasks deletes the master or drops its rule: there is no series state after.
assertThat(SubtaskReset.movedOn(state(start), null, null)).isFalse()
// Closed through its status.
assertThat(SubtaskReset.movedOn(state(start), state(start + week, TasksContract.STATUS_COMPLETED), spec(start + week))).isFalse()
// Dates moved, but the rule has nothing left from there.
val ended = spec(start + week, rrule = "FREQ=WEEKLY;UNTIL=20261103T080000Z")
assertThat(SubtaskReset.movedOn(state(start), state(start + week), ended)).isFalse()
assertThat(SubtaskReset.movedOn(state(start), state(start + week), null)).isFalse()
}
@Test
fun `a provider series moved earlier or without dates has not moved on`() {
assertThat(SubtaskReset.movedOn(state(start), state(start - week), spec(start - week))).isFalse()
assertThat(SubtaskReset.movedOn(state(null), state(null), spec(start))).isFalse()
assertThat(SubtaskReset.movedOn(null, state(start + week), spec(start + week))).isFalse()
}
}
@@ -0,0 +1,36 @@
package de.jeanlucmakiola.agendula.data.tasks
import com.google.common.truth.Truth.assertThat
import org.junit.jupiter.api.Test
class TickedCopiesTest {
private val now = 100L * 24 * 60 * 60 * 1000
private fun tick(copy: Long, daysAgo: Long, parentUid: String? = "routine") =
Tick(copy, seriesId = 1, before = null, after = null, at = now - daysAgo * 24 * 60 * 60 * 1000, parentUid = parentUid)
@Test
fun `a tick past the horizon goes, and its sub-task copy stays known with its parent`() {
val ticks = mapOf(
"org.dmfs.tasks|1|10" to tick(copy = 7, daysAgo = 31),
"org.dmfs.tasks|1|20" to tick(copy = 8, daysAgo = 2),
"org.dmfs.tasks|2|10" to tick(copy = 10, daysAgo = 35, parentUid = null),
"org.tasks.opentasks|5|10" to tick(copy = 9, daysAgo = 40, parentUid = "other"),
"garbage" to null,
)
val (stale, known) = TickedCopies.expire(ticks, now)
assertThat(stale).containsExactly("org.dmfs.tasks|1|10", "org.dmfs.tasks|2|10", "org.tasks.opentasks|5|10", "garbage")
// A top-level routine's copy (no parent) is not kept.
assertThat(known).containsExactly("org.dmfs.tasks", mapOf(7L to "routine"), "org.tasks.opentasks", mapOf(9L to "other"))
}
@Test
fun `nothing expires inside the horizon`() {
val (stale, known) = TickedCopies.expire(mapOf("a|1|1" to tick(copy = 3, daysAgo = 29)), now)
assertThat(stale).isEmpty()
assertThat(known).isEmpty()
}
}
@@ -218,13 +218,20 @@ class VTodoMapperTest {
}
@Test
fun `SEQUENCE is preserved verbatim and never bumped`() {
// It is the Organizer's revision counter (RFC 5545 section 3.8.7.4);
// a client that increments it confuses scheduling-aware peers.
fun `SEQUENCE is written as the column holds it`() {
// Raising it is the upload's job, not the mapper's.
val entity = entity(sequence = 7)
assertThat(VTodoMapper.write(entity).property("SEQUENCE")?.value).isEqualTo("7")
}
@Test
fun `an unreadable SEQUENCE gives way once an upload raised it`() {
val read = VTodoMapper.read(vtodo("SEQUENCE:x")).entity
assertThat(VTodoMapper.write(read).properties("SEQUENCE").map { it.value }).containsExactly("x")
val raised = VTodoMapper.write(read.copy(sequence = 1)).properties("SEQUENCE").map { it.value }
assertThat(raised).containsExactly("1")
}
@Test
fun `COMPLETED is written in UTC, with no TZID and no DATE form`() {
val entity = entity(
@@ -0,0 +1,93 @@
package de.jeanlucmakiola.agendula.ui.edit
import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.agendula.data.prefs.Settings
import de.jeanlucmakiola.agendula.data.tasks.StoredReminders
import de.jeanlucmakiola.agendula.domain.TaskForm
import de.jeanlucmakiola.agendula.domain.TaskReminder
import de.jeanlucmakiola.floret.reminders.ReminderLead
import java.time.ZoneId
import kotlin.time.Duration.Companion.days
import kotlin.time.Instant
import org.junit.jupiter.api.Test
class ListDefaultsHintTest {
private val zone = ZoneId.of("Europe/Berlin")
private val now = Instant.parse("2026-10-01T10:00:00Z")
private val atDue = TaskReminder(0)
private val hourBeforeStart = TaskReminder(60, fromStart = true)
/** List 1 ("Prywatny") keeps only "At due", list 3 sets none, list 2 follows the general default. */
private val settings = Settings(
defaultReminders = listOf(ReminderLead(60, fromStart = true), ReminderLead(0)),
perListReminderOverride = mapOf(1L to listOf(ReminderLead(0)), 3L to emptyList()),
perListAllDayReminderOverride = mapOf(2L to emptyList()),
)
/** What the editor does for a new task: apply the defaults, then derive the hint. */
private fun hintForNew(form: TaskForm, name: String = "Prywatny"): Pair<List<TaskReminder>, ListDefaultsHint?> {
val millis = now.toEpochMilliseconds()
val result = StoredReminders.withDefaults(form, null, null, form.isAllDay, settings, millis, zone)
val applied = StoredReminders.freshAnchors(form, null, null, form.isAllDay, settings, millis, zone).isNotEmpty()
val hint = listDefaultsHint(name, settings.hasOwnReminders(form.listId, form.isAllDay), applied, emptyList(), result)
return result to hint
}
@Test
fun `a due date in a list with its own defaults names the list`() {
val (reminders, hint) = hintForNew(TaskForm(title = "t", listId = 1, due = now + 2.days))
assertThat(reminders).containsExactly(atDue)
assertThat(hint).isEqualTo(ListDefaultsHint("Prywatny", none = false))
}
@Test
fun `the #121 case - only At due, a start-only task - says the list added none`() {
val (reminders, hint) = hintForNew(TaskForm(title = "t", listId = 1, start = now + 2.days))
assertThat(reminders).isEmpty()
assertThat(hint).isEqualTo(ListDefaultsHint("Prywatny", none = true))
}
@Test
fun `an override of no reminder says so`() {
assertThat(hintForNew(TaskForm(title = "t", listId = 3, due = now + 2.days), "Quiet").second)
.isEqualTo(ListDefaultsHint("Quiet", none = true))
}
@Test
fun `a list following the general default gets no hint`() {
val (reminders, hint) = hintForNew(TaskForm(title = "t", listId = 2, start = now + 2.days), "Work")
assertThat(reminders).containsExactly(hourBeforeStart)
assertThat(hint).isNull()
}
@Test
fun `no hint when the defaults played no part`() {
assertThat(hintForNew(TaskForm(title = "t", listId = 1)).second).isNull()
assertThat(listDefaultsHint("Prywatny", ownDefaults = true, applied = false, emptyList(), emptyList())).isNull()
}
@Test
fun `no hint when the gained date's defaults added nothing to reminders already there`() {
val wanted = listOf(TaskReminder(30))
assertThat(listDefaultsHint("Prywatny", ownDefaults = true, applied = true, wanted, wanted)).isNull()
assertThat(listDefaultsHint("Prywatny", ownDefaults = true, applied = true, wanted, wanted + atDue))
.isEqualTo(ListDefaultsHint("Prywatny", none = false))
}
@Test
fun `hasOwnReminders covers either kind`() {
assertThat(settings.hasOwnReminders(1)).isTrue()
assertThat(settings.hasOwnReminders(2)).isTrue()
assertThat(settings.hasOwnReminders(2, allDay = false)).isFalse()
assertThat(settings.hasOwnReminders(4)).isFalse()
}
@Test
fun `an all-day switch of exactly the defaults swaps them in`() {
val form = TaskForm(title = "t", listId = 2, due = now + 2.days, isAllDay = true)
val timedDefaults = settings.defaultRemindersFor(2, allDay = false)
assertThat(StoredReminders.keptAcrossSwitch(timedDefaults, form, settings)).isNull()
assertThat(StoredReminders.keptAcrossSwitch(listOf(TaskReminder(1_440)), form, settings)).isNotNull()
}
}
@@ -0,0 +1,223 @@
package de.jeanlucmakiola.agendula.ui.edit
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.emptyPreferences
import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
import de.jeanlucmakiola.agendula.data.tasks.ProviderEnvironment
import de.jeanlucmakiola.agendula.data.tasks.ProviderResolver
import de.jeanlucmakiola.agendula.data.tasks.TasksRepository
import de.jeanlucmakiola.agendula.domain.Priority
import de.jeanlucmakiola.agendula.domain.Task
import de.jeanlucmakiola.agendula.domain.TaskDetail
import de.jeanlucmakiola.agendula.domain.TaskFilter
import de.jeanlucmakiola.agendula.domain.TaskForm
import de.jeanlucmakiola.agendula.domain.TaskList
import de.jeanlucmakiola.agendula.domain.TaskReminder
import de.jeanlucmakiola.agendula.domain.TaskStatus
import de.jeanlucmakiola.agendula.domain.recurrence.RecurringScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.UnconfinedTestDispatcher
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.setMain
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import java.lang.reflect.Proxy
import kotlin.time.Clock
import kotlin.time.Duration.Companion.days
import kotlin.time.Instant
/** Reminders on a task that loses or regains its dates in the editor (#159). */
@OptIn(ExperimentalCoroutinesApi::class)
class TaskEditViewModelTest {
private val due = Clock.System.now() + 3.days
private val reminder = TaskReminder(30)
private val repository = FakeRepository()
@BeforeEach fun setUp() = Dispatchers.setMain(UnconfinedTestDispatcher())
@AfterEach fun tearDown() = Dispatchers.resetMain()
private fun editing(
start: Instant? = null,
due: Instant? = this.due,
reminders: List<TaskReminder> = listOf(reminder),
): TaskEditViewModel {
repository.task = task(start, due)
repository.reminders = reminders
return TaskEditViewModel(repository, settingsPrefs()).apply { bindEdit(TASK_ID) }
}
@Test
fun `clearing the last date drops the reminders and the task saves`() {
val vm = editing()
vm.onDueChange(null)
vm.save()
assertThat(vm.state.value.errors).isEmpty()
assertThat(repository.saved?.reminders).isEmpty()
// Empty but not chosen: no reminders of its own, without turning the default off for good.
assertThat(repository.saved?.remindersChosen).isFalse()
}
@Test
fun `untouched reminders survive an all-day switch while the task has no date`() {
val vm = editing(reminders = listOf(TaskReminder(0)))
vm.onDueChange(null)
vm.onAllDayChange(true)
vm.onDueChange(due)
assertThat(vm.state.value.reminders).isNotEmpty()
assertThat(vm.state.value.reminders.all { it.allDay.minuteOfDay != null || it.minutesBefore % (24 * 60) == 0 })
.isTrue()
}
@Test
fun `a reminder added without a date stays, and the set-aside ones come back with it`() {
val vm = editing()
val picked = TaskReminder(120)
val added = TaskReminder(240)
vm.addReminder(picked)
vm.onDueChange(null)
vm.addReminder(added)
vm.onListChange(LIST_ID + 1)
assertThat(vm.state.value.reminders).containsExactly(added)
vm.onDueChange(due)
assertThat(vm.state.value.reminders).containsExactly(reminder, picked, added)
}
@Test
fun `reminders stored on a task without dates do not come back with a date`() {
val vm = editing(due = null)
vm.onDueChange(due)
assertThat(vm.state.value.reminders).doesNotContain(reminder)
}
@Test
fun `an all-day switch or another list does not bring them back`() {
val vm = editing()
vm.onDueChange(null)
vm.onAllDayChange(true)
vm.onListChange(LIST_ID + 1)
assertThat(vm.state.value.reminders).isEmpty()
}
@Test
fun `untouched reminders come back with a new date`() {
val vm = editing()
vm.onDueChange(null)
vm.onDueChange(due + 1.days)
assertThat(vm.state.value.reminders).contains(reminder)
}
@Test
fun `picked reminders come back with a new date`() {
val vm = editing()
val picked = TaskReminder(120)
vm.addReminder(picked)
vm.onDueChange(null)
vm.onDueChange(due + 1.days)
assertThat(vm.state.value.reminders).containsExactly(reminder, picked)
}
@Test
fun `clearing one of two dates keeps the reminders`() {
val vm = editing(start = due - 1.days)
vm.onDueChange(null)
assertThat(vm.state.value.reminders).containsExactly(reminder)
}
@Test
fun `a task stored without dates opens without its reminders`() {
val vm = editing(due = null)
assertThat(vm.state.value.reminders).isEmpty()
assertThat(vm.state.value.isDirty).isFalse()
}
private fun task(start: Instant?, due: Instant?) = Task(
taskId = TASK_ID,
listId = LIST_ID,
title = "Task",
description = null,
location = null,
url = null,
priority = Priority.NONE,
status = TaskStatus.NEEDS_ACTION,
percentComplete = null,
start = start,
due = due,
isAllDay = false,
timeZone = null,
completedAt = null,
listColor = 0,
taskColor = null,
listName = null,
accountName = null,
parentId = null,
isRecurring = false,
distanceFromCurrent = null,
created = null,
lastModified = null,
)
private class FakeRepository : TasksRepository by unsupported() {
var task: Task? = null
var reminders: List<TaskReminder> = emptyList()
var saved: TaskForm? = null
override fun taskLists() = flowOf(emptyList<TaskList>())
override fun tasks(filter: TaskFilter): Flow<List<Task>> = flowOf(emptyList())
override fun taskDetail(taskId: Long, occurrenceStart: Instant?) =
flowOf(task?.let { TaskDetail(it, emptyList()) })
override suspend fun remindersFor(taskId: Long) = reminders
override suspend fun updateTask(
taskId: Long,
form: TaskForm,
expectedLastModified: Instant?,
occurrenceStart: Instant?,
scope: RecurringScope,
) {
saved = form
}
}
private class MemoryDataStore : DataStore<Preferences> {
override val data = MutableStateFlow(emptyPreferences())
override suspend fun updateData(transform: suspend (t: Preferences) -> Preferences) =
transform(data.value).also { data.value = it }
}
private object NoProviders : ProviderEnvironment {
override fun packageDeclaring(authority: String): String? = null
override fun isGranted(permission: String) = false
override fun appLabel(packageName: String): String? = null
}
private fun settingsPrefs() = SettingsPrefs(MemoryDataStore(), ProviderResolver(NoProviders))
private companion object {
const val TASK_ID = 1L
const val LIST_ID = 7L
/** Fails any call the test does not expect. */
inline fun <reified T> unsupported(): T =
Proxy.newProxyInstance(T::class.java.classLoader, arrayOf(T::class.java)) { _, method, _ ->
throw UnsupportedOperationException("Unexpected call: ${method.name}")
} as T
}
}
@@ -172,6 +172,41 @@ class CollectionSyncerTest {
assertThat(remote.resources.values.single().body).contains("SUMMARY:New")
}
@Test fun `an edited task goes up with a raised SEQUENCE, which is kept`() {
remote.put("one.ics", vtodo("a", "Old"))
store.rows += task(id = 1, uid = "a", title = "New")
.copy(href = "http://server/dav/tasks/one.ics", etag = "e-one.ics", sequence = 2, isDirty = true)
sync()
assertThat(remote.resources.values.single().body).contains("SEQUENCE:3")
assertThat(store.rows.single().sequence).isEqualTo(3)
}
@Test fun `a new task goes up at its own SEQUENCE`() {
store.rows += task(id = 1, uid = "a", title = "Write it down").copy(isDirty = true)
sync()
assertThat(remote.resources.values.single().body).contains("SEQUENCE:0")
assertThat(store.rows.single().sequence).isEqualTo(0)
}
@Test fun `a scheduled task leaves SEQUENCE to its organiser`() {
remote.put("one.ics", vtodo("a", "Old"))
store.rows += task(id = 1, uid = "a", title = "New").copy(
href = "http://server/dav/tasks/one.ics",
etag = "e-one.ics",
sequence = 2,
isDirty = true,
unknownProperties = "ORGANIZER:mailto:boss@example.com",
)
sync()
assertThat(remote.resources.values.single().body).contains("SEQUENCE:2")
}
@Test fun `a failed validator fetch defers the update instead of writing blind`() {
remote.put("one.ics", vtodo("a", "Server"))
// No local etag: what StoredNeedsRefetch, and any server that serves none,
@@ -81,7 +81,12 @@ class FakeStore(rows: List<TaskEntity> = emptyList()) : SyncStore {
val index = this.rows.indexOfFirst { it.id == synced.id }
if (index >= 0) {
val current = this.rows[index]
this.rows[index] = current.copy(href = href, etag = eTag, isDirty = current.lastModified != synced.lastModified)
this.rows[index] = current.copy(
href = href,
etag = eTag,
isDirty = current.lastModified != synced.lastModified,
sequence = maxOf(current.sequence, synced.sequence),
)
}
}
}
@@ -0,0 +1,10 @@
### جديد
- اختر مقدار الوصف الذي تعرضه التذكيرات: لا شيء أو معاينة قصيرة (الافتراضي) أو الوصف كله.
### تغييرات
- القوائم ذات التذكيرات الافتراضية الخاصة مُعلَّمة في المحرر وفي الإعدادات.
### إصلاحات
- مع مزامنة CalDAV، ينقل تطبيق تذكيرات Apple أيضًا المهمة المتكررة المنجزة إلى موعدها التالي.
- حذف آخر تاريخ لمهمة يحذف تذكيراتها أيضًا.
- لم يعد شريط التنقل ولوحة المفاتيح يغطيان المحتوى.
@@ -0,0 +1,10 @@
### Novinky
- Zvolte, kolik z popisu připomínky ukazují: nic, náhled (výchozí) nebo celý popis.
### Změny
- Seznamy s vlastními výchozími připomínkami jsou označené v editoru i v nastavení.
### Opravy
- Se synchronizací CalDAV posunou i Připomínky od Apple odškrtnutý opakovaný úkol.
- Odstranění posledního data úkolu odstraní i jeho připomínky.
- Navigační lišta a klávesnice už nezakrývají obsah.
@@ -0,0 +1,10 @@
### Neu
- Wähle, wie viel der Beschreibung Erinnerungen zeigen: nichts, eine Vorschau (Standard) oder alles.
### Geändert
- Listen mit eigenen Standarderinnerungen sind im Editor und in den Einstellungen markiert.
### Behoben
- Mit CalDAV-Sync rückt auch Apple Erinnerungen abgehakte wiederkehrende Aufgaben vor.
- Ohne Datum verliert eine Aufgabe auch ihre Erinnerungen.
- Navigationsleiste und Tastatur verdecken keine Inhalte mehr.
@@ -0,0 +1,10 @@
### Added
- Choose how much of a task's description reminders show: none, a short preview (new default) or all of it.
### Changed
- Lists with their own default reminders are marked in the editor and in Settings.
### Fixed
- With CalDAV sync, Apple Reminders now moves a ticked repeating task on too.
- Removing a task's last date also removes its reminders.
- The navigation bar and keyboard no longer cover content.
@@ -0,0 +1,10 @@
### Added
- Choose how much of a task's description reminders show: none, a short preview (new default) or all of it.
### Changed
- Lists with their own default reminders are marked in the editor and in Settings.
### Fixed
- With CalDAV sync, Apple Reminders now moves a ticked repeating task on too.
- Removing a task's last date also removes its reminders.
- The navigation bar and keyboard no longer cover content.
@@ -0,0 +1,10 @@
### Nouveautés
- Choisissez ce que les rappels montrent de la description : rien, un aperçu (par défaut) ou tout.
### Modifications
- Les listes avec leurs propres rappels par défaut sont signalées dans l’éditeur et les réglages.
### Corrections
- Avec la synchro CalDAV, Rappels d’Apple avance aussi une tâche récurrente cochée.
- Retirer la dernière date d’une tâche retire ses rappels.
- La barre de navigation et le clavier ne masquent plus le contenu.
@@ -0,0 +1,10 @@
### Novidades
- Escolha quanto da descrição os lembretes mostram: nada, uma prévia (padrão) ou tudo.
### Alterações
- Listas com lembretes padrão próprios aparecem marcadas no editor e nas configurações.
### Correções
- Com a sincronização CalDAV, o Lembretes da Apple também avança uma tarefa recorrente concluída.
- Remover a última data de uma tarefa remove seus lembretes.
- A barra de navegação e o teclado não cobrem mais o conteúdo.
@@ -0,0 +1,10 @@
### Новое
- Выберите, сколько описания показывают напоминания: ничего, фрагмент (по умолчанию) или всё.
### Изменения
- Списки со своими напоминаниями по умолчанию отмечены в редакторе и в настройках.
### Исправления
- С синхронизацией CalDAV «Напоминания» Apple тоже переносят отмеченную повторяющуюся задачу.
- Удаление последней даты задачи удаляет и её напоминания.
- Панель навигации и клавиатура больше не закрывают содержимое.