Compare commits
5
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7afa2f41f0 | ||
|
|
4b1294341a | ||
|
|
2dfc676b8f | ||
|
|
109eda82b2 | ||
|
|
68495a936c |
No files matched your search
@@ -7,44 +7,6 @@ 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
|
||||
|
||||
@@ -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 = 1030299
|
||||
versionName = "1.3.2"
|
||||
versionCode = 1030199
|
||||
versionName = "1.3.1"
|
||||
|
||||
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
|
||||
|
||||
|
||||
@@ -1,775 +0,0 @@
|
||||
{
|
||||
"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')"
|
||||
]
|
||||
}
|
||||
}
|
||||
-175
@@ -14,7 +14,6 @@ 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
|
||||
|
||||
/**
|
||||
@@ -701,180 +700,6 @@ 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
|
||||
|
||||
-19
@@ -174,25 +174,6 @@ 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,14 +417,8 @@ class CollectionSyncer(
|
||||
return@forEach
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
val body = serialize(local) ?: return@forEach
|
||||
if (href == null) createResource(local, body) else updateResource(local, href, body)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1087,16 +1081,6 @@ 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,7 +135,6 @@ 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, TasksDatabase.MIGRATION_5_6)
|
||||
.addMigrations(TasksDatabase.MIGRATION_1_2, TasksDatabase.MIGRATION_2_3, TasksDatabase.MIGRATION_3_4, TasksDatabase.MIGRATION_4_5)
|
||||
.build()
|
||||
|
||||
/**
|
||||
|
||||
@@ -54,9 +54,6 @@ 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)
|
||||
|
||||
@@ -106,7 +103,6 @@ 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,
|
||||
@@ -142,14 +138,6 @@ 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. */
|
||||
@@ -183,9 +171,6 @@ 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,
|
||||
@@ -214,9 +199,6 @@ 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 }
|
||||
@@ -363,7 +345,6 @@ 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,14 +12,12 @@ 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
|
||||
@@ -32,7 +30,6 @@ 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
|
||||
@@ -89,9 +86,7 @@ class TaskNotifier @Inject constructor(
|
||||
),
|
||||
)
|
||||
}
|
||||
val description = reminderBody(settings.reminderDescription, lineChars()) {
|
||||
task.description?.readableDescription()
|
||||
}
|
||||
val description = task.description?.readableDescription()?.trim()?.takeIf { it.isNotBlank() }
|
||||
val tapIntent = PendingIntent.getActivity(
|
||||
context,
|
||||
task.taskId.toInt(),
|
||||
@@ -124,16 +119,6 @@ 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)
|
||||
}
|
||||
@@ -292,163 +277,3 @@ 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,
|
||||
)
|
||||
+58
-297
@@ -25,8 +25,6 @@ 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
|
||||
@@ -137,8 +135,21 @@ 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> =
|
||||
childRows(authority(), parentTaskId, projection = null) { it.getLong(Tasks.ID) }
|
||||
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()
|
||||
|
||||
/**
|
||||
* All columns and no sort: the instances view differs across provider
|
||||
@@ -186,18 +197,22 @@ 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> = inSelections(idColumn, ids, filter, filterArgs).flatMap { (selection, args) ->
|
||||
): 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()
|
||||
resolver.query(uri, projection, selection, args, sortOrder)?.use { c ->
|
||||
val reader = CursorColumnReader(c)
|
||||
buildList { while (c.moveToNext()) read(reader)?.let(::add) }
|
||||
@@ -330,7 +345,18 @@ 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()) TaskMapper.seriesSpec(CursorColumnReader(c)) else null
|
||||
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),
|
||||
)
|
||||
}
|
||||
|
||||
/** End the master's rule before [occurrenceStart], and drop the exceptions past it. */
|
||||
@@ -727,243 +753,31 @@ 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 series = runCatching { readSeries(authority, taskId) }.getOrNull()
|
||||
val before = series?.state
|
||||
val before = runCatching { seriesState(authority, taskId) }.getOrNull()
|
||||
return write().also { rows ->
|
||||
if (rows > 0) {
|
||||
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,
|
||||
)
|
||||
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())
|
||||
ticks.put(ticks.key(authority, taskId, occurrenceStart), tick)
|
||||
}.onFailure { Log.w(TAG, "Recording the tick failed", it) }
|
||||
}
|
||||
}
|
||||
}.onFailure { Log.w(TAG, "Looking up the detached copy 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. 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.
|
||||
* 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.
|
||||
*/
|
||||
private fun movedBack(taskId: Long, occurrenceStart: Instant?): Boolean = runCatching {
|
||||
val authority = authority()
|
||||
@@ -972,63 +786,31 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
?: return false
|
||||
val series = tick.seriesId ?: return false
|
||||
val before = tick.before ?: return false
|
||||
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 }
|
||||
if (seriesState(authority, series) != tick.after || subtaskIds(tick.copyId).isNotEmpty()) return false
|
||||
val restore = before.filter { (column, value) -> tick.after?.get(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)
|
||||
|
||||
/**
|
||||
* 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 ->
|
||||
/** 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 ->
|
||||
if (!c.moveToFirst()) return@use null
|
||||
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)) {
|
||||
SERIES_STATE.indices.associate { i ->
|
||||
SERIES_STATE[i] 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")
|
||||
@@ -1048,12 +830,7 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
}
|
||||
}?.singleOrNull()
|
||||
|
||||
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) }
|
||||
private val ticks = TickedCopies { context.getSharedPreferences(TICKED_COPIES, 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? =
|
||||
@@ -1162,28 +939,10 @@ private const val MIGRATIONS = "provider_migrations"
|
||||
|
||||
private const val TICKED_COPIES = "provider_ticked_copies"
|
||||
|
||||
/**
|
||||
* 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. */
|
||||
/** What a tick changes on a series, and an undo changes back. */
|
||||
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.IS_ALLDAY, Tasks.TZ,
|
||||
Tasks.STATUS, Tasks.COMPLETED, Tasks.PERCENT_COMPLETE,
|
||||
)
|
||||
|
||||
private const val TAG = "AndroidTasksDataSource"
|
||||
@@ -1191,3 +950,5 @@ 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, 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.
|
||||
* 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.
|
||||
*/
|
||||
interface ColumnReader {
|
||||
fun getLong(name: String): Long?
|
||||
|
||||
@@ -1,23 +0,0 @@
|
||||
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,31 +49,16 @@ internal object StoredReminders {
|
||||
zone: ZoneId,
|
||||
): List<TaskReminder> {
|
||||
val wanted = form.reminders.map { it.lead }.distinct()
|
||||
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 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 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;
|
||||
@@ -88,18 +73,15 @@ internal object StoredReminders {
|
||||
zone: ZoneId,
|
||||
): List<TaskReminder> {
|
||||
if (reminders.isEmpty()) return reminders
|
||||
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
|
||||
if (reminders.toSet() == settings.defaultRemindersFor(form.listId, !form.isAllDay).toSet()) {
|
||||
return defaultsFor(form, settings, now, zone)
|
||||
}
|
||||
val kept = if (form.isAllDay) {
|
||||
reminders.map { it.inWholeDays() }
|
||||
} else {
|
||||
reminders.filter { it.allDay.minuteOfDay == null }
|
||||
}
|
||||
return kept.distinct().ifEmpty { null }
|
||||
return kept.distinct().ifEmpty { defaultsFor(form, settings, now, zone) }
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -1,295 +0,0 @@
|
||||
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,7 +8,6 @@ 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. */
|
||||
@@ -78,20 +77,6 @@ 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.
|
||||
*
|
||||
|
||||
@@ -1,42 +0,0 @@
|
||||
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,8 +7,6 @@ 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,
|
||||
@@ -16,16 +14,10 @@ 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]. 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) {
|
||||
/** The provider keeps no record of its ticks, so they are kept here for [HORIZON_MS]. */
|
||||
internal class TickedCopies(private val prefs: () -> SharedPreferences) {
|
||||
|
||||
fun key(authority: String, taskId: Long, occurrenceStart: Instant) =
|
||||
"$authority|$taskId|${wholeSecond(occurrenceStart).epochSeconds}"
|
||||
@@ -39,53 +31,27 @@ internal class TickedCopies(private val prefs: () -> SharedPreferences, private
|
||||
(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, 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()
|
||||
val stale = prefs().all.filter { (_, value) ->
|
||||
val at = (value as? String)?.let(::decode)?.at ?: 0L
|
||||
tick.at - at > HORIZON_MS
|
||||
}.keys
|
||||
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 {
|
||||
@@ -100,7 +66,6 @@ internal class TickedCopies(private val prefs: () -> SharedPreferences, private
|
||||
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()
|
||||
|
||||
@@ -115,19 +80,5 @@ internal class TickedCopies(private val prefs: () -> SharedPreferences, private
|
||||
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
|
||||
// Raised by an upload (#137); kept as the server sent it otherwise.
|
||||
"SEQUENCE" -> entity.sequence != 0
|
||||
// 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.
|
||||
else -> false
|
||||
}
|
||||
}
|
||||
@@ -573,13 +573,6 @@ 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,8 +51,6 @@ 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) }
|
||||
|
||||
+2
-66
@@ -1,14 +1,6 @@
|
||||
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
|
||||
@@ -26,7 +18,6 @@ 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
|
||||
@@ -100,8 +91,6 @@ 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.
|
||||
*
|
||||
@@ -649,7 +638,6 @@ class RoomTasksDataSource @Inject constructor(
|
||||
isDirty = true,
|
||||
),
|
||||
)
|
||||
val (reset, resetLists) = resetSubtasks(master, newAnchor, now)
|
||||
val copyId = if (override != null) {
|
||||
detach(override, now, close)
|
||||
} else {
|
||||
@@ -675,65 +663,13 @@ 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) + resetLists)
|
||||
writes.onWritten(setOf(master.listId))
|
||||
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),
|
||||
@@ -818,7 +754,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) + restoreSubtasks(record, now))
|
||||
writes.onWritten(setOf(master.listId))
|
||||
return true
|
||||
}
|
||||
|
||||
|
||||
@@ -200,10 +200,6 @@ 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 = 6,
|
||||
version = 5,
|
||||
exportSchema = true,
|
||||
)
|
||||
@TypeConverters(Converters::class)
|
||||
@@ -204,12 +204,5 @@ 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 ''")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+5
-12
@@ -12,16 +12,6 @@ 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?,
|
||||
@@ -143,8 +133,11 @@ object RecurrenceExpander {
|
||||
return occurrences.indices.map { it - current }
|
||||
}
|
||||
|
||||
private fun zoneOf(spec: RecurrenceSpec, floatingZone: ZoneId): TimeZone =
|
||||
TimeZone.getTimeZone(dateZone(spec.isAllDay, spec.timeZone, floatingZone))
|
||||
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)
|
||||
}
|
||||
|
||||
/**
|
||||
* All-day series are date-anchored: pin the anchor to UTC midnight, as it is
|
||||
|
||||
@@ -18,7 +18,6 @@ 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
|
||||
@@ -269,9 +268,6 @@ 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()
|
||||
|
||||
@@ -1,32 +0,0 @@
|
||||
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,7 +57,6 @@ 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
|
||||
@@ -220,9 +219,7 @@ fun TaskEditScreen(
|
||||
viewModel = viewModel,
|
||||
scroll = scroll,
|
||||
onTitleBottom = { titleBottom = it },
|
||||
// Consumed so EditContent's imePadding adds only what the keyboard
|
||||
// covers beyond the bars.
|
||||
modifier = Modifier.padding(inner).consumeWindowInsets(inner),
|
||||
modifier = Modifier.padding(inner),
|
||||
)
|
||||
}
|
||||
|
||||
@@ -586,16 +583,6 @@ 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)
|
||||
@@ -1293,14 +1280,10 @@ private fun FieldPickerDialog(
|
||||
}
|
||||
|
||||
@Composable
|
||||
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) {
|
||||
private fun FieldError(messageRes: Int) {
|
||||
Text(
|
||||
text = text,
|
||||
color = color,
|
||||
text = stringResource(messageRes),
|
||||
color = MaterialTheme.colorScheme.error,
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
modifier = Modifier.padding(start = 4.dp),
|
||||
)
|
||||
|
||||
@@ -66,8 +66,6 @@ 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(),
|
||||
@@ -151,12 +149,6 @@ 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,
|
||||
@@ -169,7 +161,6 @@ class TaskEditViewModel @Inject constructor(
|
||||
if (bound) return
|
||||
bound = true
|
||||
editingTaskId = null
|
||||
setAside.clear()
|
||||
baselineLastModified = null
|
||||
viewModelScope.launch {
|
||||
val settings = settingsPrefs.settings.first()
|
||||
@@ -223,7 +214,6 @@ class TaskEditViewModel @Inject constructor(
|
||||
bound = true
|
||||
editingTaskId = taskId
|
||||
editingOccurrence = occurrenceStart
|
||||
setAside.clear()
|
||||
viewModelScope.launch {
|
||||
val settings = settingsPrefs.settings.first()
|
||||
this@TaskEditViewModel.settings = settings
|
||||
@@ -240,7 +230,6 @@ class TaskEditViewModel @Inject constructor(
|
||||
loadedStart = task.start
|
||||
loadedDue = task.due
|
||||
loadedAllDay = task.isAllDay
|
||||
loadedKindAllDay = task.isAllDay
|
||||
_state.value = withFields(
|
||||
TaskEditUiState(
|
||||
loading = false,
|
||||
@@ -266,12 +255,7 @@ 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
|
||||
}
|
||||
@@ -312,8 +296,7 @@ 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() +
|
||||
setOfNotNull(TaskFormField.Reminder.takeIf { state.listDefaultsHint != null })
|
||||
val visible = defaultFields + state.toForm().populatedFields()
|
||||
return state.copy(visibleFields = visible, hiddenFields = hiddenOf(visible))
|
||||
}
|
||||
|
||||
@@ -326,22 +309,15 @@ 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()).withDatedReminders() }
|
||||
update { it.copy(listId = listId, parentId = null, errors = emptySet()).withDefaultReminders() }
|
||||
viewModelScope.launch {
|
||||
val candidates = loadParents(listId, selfId = editingTaskId)
|
||||
update { it.copy(parentCandidates = candidates) }
|
||||
}
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
fun onStartChange(value: Instant?) = update { it.copy(start = value).withDefaultReminders() }
|
||||
fun onDueChange(value: Instant?) = update { it.copy(due = value).withDefaultReminders() }
|
||||
/**
|
||||
* 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 —
|
||||
@@ -358,16 +334,8 @@ class TaskEditViewModel @Inject constructor(
|
||||
due = it.due?.rebasedForAllDay(value),
|
||||
)
|
||||
if (!it.remindersTouched) {
|
||||
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
|
||||
}
|
||||
loadedReminders = carried(loadedReminders, switched)
|
||||
return@update switched.withDefaultReminders()
|
||||
}
|
||||
switched.copy(reminders = carried(it.reminders, switched).sortedForDisplay(switched))
|
||||
}
|
||||
@@ -378,40 +346,12 @@ class TaskEditViewModel @Inject constructor(
|
||||
val carried = if (previous != null && previous.second == reminders) {
|
||||
previous.first
|
||||
} else {
|
||||
switchedFor(reminders, switched)
|
||||
StoredReminders.switched(reminders, switched.toForm(), settings, nowMillis(), ZoneId.systemDefault())
|
||||
}
|
||||
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
|
||||
@@ -430,39 +370,13 @@ 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()
|
||||
@@ -474,12 +388,11 @@ 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, listDefaultsHint = null)
|
||||
it.copy(reminders = it.reminders - reminder, remindersTouched = true, remindersChosen = true)
|
||||
}
|
||||
fun onLocationChange(value: String) = update { it.copy(location = value) }
|
||||
fun onUrlChange(value: String) = update { it.copy(url = value) }
|
||||
@@ -560,15 +473,6 @@ 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,12 +29,7 @@ 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.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.statusBarsPadding
|
||||
import androidx.compose.foundation.layout.width
|
||||
import androidx.compose.foundation.lazy.LazyColumn
|
||||
import androidx.compose.foundation.lazy.LazyListScope
|
||||
@@ -65,7 +60,6 @@ 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
|
||||
@@ -519,7 +513,7 @@ private fun HomeTopBar(
|
||||
Row(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.windowInsetsPadding(TopAppBarDefaults.windowInsets)
|
||||
.statusBarsPadding()
|
||||
.height(72.dp)
|
||||
.padding(horizontal = 12.dp),
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
@@ -678,14 +672,10 @@ 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,22 +6,16 @@ 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
|
||||
@@ -50,20 +44,14 @@ 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)
|
||||
.windowInsetsPadding(ScaffoldDefaults.contentWindowInsets.only(WindowInsetsSides.Horizontal)),
|
||||
modifier = modifier.fillMaxSize().background(MaterialTheme.colorScheme.surface),
|
||||
contentAlignment = Alignment.TopCenter,
|
||||
) {
|
||||
Box(modifier = Modifier.fillMaxHeight().widthIn(max = MAX_CONTENT_WIDTH).fillMaxWidth()) { content() }
|
||||
Box(modifier = Modifier.fillMaxSize().widthIn(max = MAX_CONTENT_WIDTH)) { content() }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -86,50 +74,37 @@ 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()
|
||||
.windowInsetsPadding(start)
|
||||
.consumeWindowInsets(end),
|
||||
) { list(select) }
|
||||
Box(Modifier.weight(1f).fillMaxHeight()) { list(select) }
|
||||
Surface(
|
||||
color = MaterialTheme.colorScheme.surfaceContainerLow,
|
||||
shape = RoundedCornerShape(topStart = 28.dp, bottomStart = 28.dp),
|
||||
modifier = Modifier.weight(1.2f).fillMaxHeight(),
|
||||
) {
|
||||
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
|
||||
},
|
||||
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
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -33,17 +33,12 @@ 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
|
||||
@@ -118,7 +113,6 @@ 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>()) }
|
||||
@@ -128,9 +122,6 @@ 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),
|
||||
@@ -171,13 +162,13 @@ internal fun NotificationsScreen(
|
||||
}
|
||||
GroupedRow(
|
||||
title = stringResource(R.string.settings_default_reminder),
|
||||
summary = withOwnCount(reminderChoiceLabel(state.settings.defaultReminders), ownTimed),
|
||||
summary = reminderChoiceLabel(state.settings.defaultReminders),
|
||||
position = Position.Middle,
|
||||
onClick = { showOffset = true },
|
||||
)
|
||||
GroupedRow(
|
||||
title = stringResource(R.string.settings_default_reminder_allday),
|
||||
summary = withOwnCount(reminderChoiceLabel(state.settings.defaultAllDayReminders, allDay = true), ownAllDay),
|
||||
summary = reminderChoiceLabel(state.settings.defaultAllDayReminders, allDay = true),
|
||||
position = Position.Middle,
|
||||
onClick = { showAllDay = true },
|
||||
)
|
||||
@@ -187,14 +178,8 @@ internal fun NotificationsScreen(
|
||||
R.string.settings_allday_reminder_time_summary,
|
||||
formatMinuteOfDay(state.settings.allDayReminderMinuteOfDay, LocalUse24HourFormat.current),
|
||||
),
|
||||
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 },
|
||||
onClick = { showAllDayTime = true },
|
||||
)
|
||||
|
||||
Spacer(Modifier.height(24.dp))
|
||||
@@ -224,10 +209,7 @@ 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 = 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"),
|
||||
summary = stringResource(R.string.settings_list_reminders_hint),
|
||||
position = if (perListExpanded) Position.Top else Position.Alone,
|
||||
trailing = {
|
||||
Icon(
|
||||
@@ -250,8 +232,7 @@ 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 = AnnotatedString(list.name),
|
||||
summary = listSourceSummary(state.settings.hasOwnReminders(list.id)),
|
||||
title = list.name,
|
||||
position = if (last && !expanded) Position.Bottom else Position.Middle,
|
||||
leading = {
|
||||
Icon(Icons.Rounded.Circle, contentDescription = null, tint = pastelize(list.color, dark))
|
||||
@@ -337,17 +318,6 @@ 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(
|
||||
@@ -384,46 +354,9 @@ 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,7 +6,6 @@ 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
|
||||
@@ -260,7 +259,6 @@ 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,9 +22,6 @@ 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
|
||||
@@ -427,9 +424,7 @@ private fun TaskListBody(
|
||||
modifier = Modifier.fillMaxSize().then(viewport),
|
||||
contentPadding = PaddingValues(
|
||||
top = inner.calculateTopPadding() + 8.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,
|
||||
bottom = inner.calculateBottomPadding() + if (bottomBarShown) 16.dp else 96.dp,
|
||||
),
|
||||
) {
|
||||
if (state.tasks.isEmpty()) {
|
||||
@@ -623,11 +618,7 @@ private fun QuickAddBar(onAdd: (String) -> Unit) {
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.windowInsetsPadding(
|
||||
WindowInsets.ime
|
||||
.union(WindowInsets.navigationBars)
|
||||
.union(WindowInsets.displayCutout.only(WindowInsetsSides.Horizontal)),
|
||||
),
|
||||
.windowInsetsPadding(WindowInsets.ime.union(WindowInsets.navigationBars)),
|
||||
) {
|
||||
InlineAdd(onAdd = onAdd, elevated = true)
|
||||
}
|
||||
|
||||
@@ -763,95 +763,4 @@
|
||||
<string name="widget_config_background">الخلفية</string>
|
||||
<string name="widget_config_background_solid">سادة</string>
|
||||
<string name="widget_config_theme">السمة</string>
|
||||
<string name="app_name_tasks_alias">مهام</string>
|
||||
<string name="list_where">أين</string>
|
||||
<string name="settings_backup_subtitle">التصدير و الاستيراد</string>
|
||||
<string name="error_reminder_without_date">اضبط تاريخ بدء أو استحقاق لاستخدام تذكير.</string>
|
||||
<string name="reminder_at_start">في وقت البدء</string>
|
||||
<string name="reminder_at_due_time">في وقت الاستحقاق</string>
|
||||
<string name="reminder_on_start_date">عند موعد البدء</string>
|
||||
<string name="reminder_on_due_date">عند موعد الاستحقاق</string>
|
||||
<string name="reminder_at_time">%1$s عند %2$s</string>
|
||||
<string name="reminder_anchor_start">من البدء</string>
|
||||
<string name="reminder_anchor_due">من تاريخ الاستحقاق</string>
|
||||
<string name="reminder_time">الوقت</string>
|
||||
<string name="reminder_benefit_delivery_title">تنبيه عندما يكون الأمر مهمًا</string>
|
||||
<string name="reminder_benefit_reversible_title">يمكنك تغييره في أي وقت</string>
|
||||
<string name="settings_app_name_hint">اعرض Agendula كـ ”مهام“ في مشغّل التطبيقات الخاص بك. فقط الاسم في المشغّل يتغير؛ وقد ينتقل الرمز إلى مكان جديد. يُغلَق Agendula عندما تقوم بالتبديل، لذا أعِد فتحه من المشغّل.</string>
|
||||
<string name="settings_allday_reminder_time_summary">العد التنازلي لمهام التي تستمر طوال اليوم عند %1$s</string>
|
||||
<string name="settings_store_permission_denied_hint">مهام التطبيق الآخر تبقى غير قابلة للوصول حتى تسمح بالوصول. اضغط لفتح إعدادات التطبيق.</string>
|
||||
<string name="settings_copy_counting">جارٍ حساب ما هناك لنسخه…</string>
|
||||
<string name="settings_copy_confirm_empty">%1$s لا يحتوي على مهام لنسخها.</string>
|
||||
<string name="settings_copy_nothing">لم يكن هناك شيء للنسخ</string>
|
||||
<string name="export_hint">ملف .ics واحد لكل قائمة، قابل للقراءة بواسطة تطبيقات المهام والتقويم الأخرى. القوائم الموضوع عليها بعلامة صح تذهب إلى مجلد تختاره أنت، أو إلى ملف مضغوط (zip) واحد.</string>
|
||||
<string name="export_no_lists">لا توجد قوائم للتصدير</string>
|
||||
<string name="export_to_folder">الحفظ إلى مجلد</string>
|
||||
<string name="export_to_zip">حفظ كملف مضغوط (zip)</string>
|
||||
<plurals name="export_done">
|
||||
<item quantity="zero">تم تصدير (%1$d) لا قوائم</item>
|
||||
<item quantity="one">تم تصدير قائمة واحدة (%1$d)</item>
|
||||
<item quantity="two">تم تصدير قائمتان (%1$d)</item>
|
||||
<item quantity="few">تم تصدير %1$d قوائم</item>
|
||||
<item quantity="many">تم تصدير %1$d قائمة</item>
|
||||
<item quantity="other">تم تصدير %1$d قائمة</item>
|
||||
</plurals>
|
||||
<plurals name="reminder_minutes_before_start">
|
||||
<item quantity="zero">(%1$d) لا دقائق قبل البدء</item>
|
||||
<item quantity="one">%1$d دقيقة واحده قبل البدء</item>
|
||||
<item quantity="two">%1$d دقيقتان قبل البدء</item>
|
||||
<item quantity="few">%1$d دقائق قبل البدء</item>
|
||||
<item quantity="many">%1$d دقيقة قبل البدء</item>
|
||||
<item quantity="other">%1$d دقيقة قبل البدء</item>
|
||||
</plurals>
|
||||
<plurals name="reminder_hours_before_start">
|
||||
<item quantity="zero">(%1$d) لا ساعات قبل البدء</item>
|
||||
<item quantity="one">%1$d ساعة واحده قبل البدء</item>
|
||||
<item quantity="two">%1$d ساعتان قبل البدء</item>
|
||||
<item quantity="few">%1$d ساعات قبل البدء</item>
|
||||
<item quantity="many">%1$d ساعة قبل البدء</item>
|
||||
<item quantity="other">%1$d ساعة قبل البدء</item>
|
||||
</plurals>
|
||||
<plurals name="reminder_days_before_start">
|
||||
<item quantity="zero">(%1$d) لا أيام قبل البدء</item>
|
||||
<item quantity="one">%1$d يوم واحد قبل البدء</item>
|
||||
<item quantity="two">%1$d يومان قبل البدء</item>
|
||||
<item quantity="few">%1$d أيام قبل البدء</item>
|
||||
<item quantity="many">%1$d يوم قبل البدء</item>
|
||||
<item quantity="other">%1$d يوم قبل البدء</item>
|
||||
</plurals>
|
||||
<plurals name="reminder_weeks_before_start">
|
||||
<item quantity="zero">(%1$d) لا أسابيع قبل البدء</item>
|
||||
<item quantity="one">%1$d أسبوع واحد قبل البدء</item>
|
||||
<item quantity="two">%1$d أسبوعان قبل البدء</item>
|
||||
<item quantity="few">%1$d أسابيع قبل البدء</item>
|
||||
<item quantity="many">%1$d أسبوع قبل البدء</item>
|
||||
<item quantity="other">%1$d أسبوع قبل البدء</item>
|
||||
</plurals>
|
||||
<string name="settings_accounts_subtitle">مزامنة مهامك مع خادم CalDAV</string>
|
||||
<string name="accounts_add">إضافة حسابًا</string>
|
||||
<string name="accounts_sync_interval">المزامنة تلقائيًا</string>
|
||||
<string name="accounts_sync_interval_manual">فقط عند تقوم بالمزامنة</string>
|
||||
<string name="accounts_push_via">تصل التغييرات فورًا، عبر %1$s</string>
|
||||
<string name="widget_unavailable">افتح Agendula لإنهاء الإعداد</string>
|
||||
<string name="widget_today_all_done">انتهى كل شيء</string>
|
||||
<string name="widget_config_title">إظهار في الأداة المصغرة</string>
|
||||
<string name="widget_config_group_by_list">تجميع حسب القائمة</string>
|
||||
<string name="widget_config_group_by_list_hint">إظهار مهام كل قائمة ضمن عنوانها الخاص</string>
|
||||
<string name="widget_config_background_solid_hint">يملأ الأداة المصغّرة بلون سطح السمة</string>
|
||||
<string name="widget_config_background_tinted_hint">أكثر نعومة، تعبئة لونية متناغمة</string>
|
||||
<string name="widget_config_background_transparent">شفافة</string>
|
||||
<string name="widget_config_background_transparent_hint">لا تعبئة — تبقى المهام قابلة للقراءة في حاوياتها الخاصة</string>
|
||||
<string name="widget_config_row_color_neutral_hint">يستخدم كل صف نفس التعبئة اللونية المتناغمة</string>
|
||||
<string name="widget_config_row_color_by_list">حسب القائمة</string>
|
||||
<string name="widget_config_row_color_by_list_hint">كل صف متناغم باللون الخاص بقائمته</string>
|
||||
<string name="widget_today_description">حلقة تقدم لمهام اليوم</string>
|
||||
<string name="widget_up_next_description">مهمتك الوحيدة الأقرب لموعد الاستحقاق</string>
|
||||
<string name="widget_lists_label">قوائم</string>
|
||||
<string name="widget_lists_description">مربع اختصار لكل قائمة، مع عدد مرّات فتحه</string>
|
||||
<string name="widget_week_label">أسبوع</string>
|
||||
<string name="widget_week_description">شريط من سبعة أيام لعدد المهام</string>
|
||||
<string name="widget_config_background_tinted">ملونة</string>
|
||||
<string name="settings_theme_black">أسود</string>
|
||||
<string name="settings_theme_black_summary">داكن مع خلفيات سوداء نقية، لشاشات AMOLED</string>
|
||||
<string name="settings_app_name">اسم التطبيق</string>
|
||||
</resources>
|
||||
@@ -320,18 +320,4 @@
|
||||
<string name="reminder_at_due">V čase úkolu</string>
|
||||
<string name="reminder_on_the_day">V daný den</string>
|
||||
<string name="settings_list_reminders_title">Upozornění pro jednotlivé seznamy</string>
|
||||
<string name="shortcut_new_task">Nový úkol</string>
|
||||
<string name="shortcut_today">Dnes</string>
|
||||
<string name="qs_tile_new_task">Nový úkol</string>
|
||||
<string name="sort_title">Seřadit podle</string>
|
||||
<string name="view_options_title">Řazení a filtrování</string>
|
||||
<string name="view_filter_tags">Filtrovat podle štítku</string>
|
||||
<string name="view_filter_clear">Zrušit filtr</string>
|
||||
<string name="sort_due">Termín splnění</string>
|
||||
<string name="sort_title_alpha">Název</string>
|
||||
<string name="sort_created">Nedávno přidané</string>
|
||||
<string name="clear_completed_action">Zrušit</string>
|
||||
<string name="undo">Zpět</string>
|
||||
<string name="section_today">Dnes</string>
|
||||
<string name="section_upcoming">Nadcházející</string>
|
||||
</resources>
|
||||
@@ -28,11 +28,4 @@
|
||||
<string name="qs_tile_new_task">Новая задача</string>
|
||||
<string name="lists_reorder">Переопределить список</string>
|
||||
<string name="lists_reorder_done">Завершить переопределение</string>
|
||||
<string name="app_name_tasks_alias">Задачи</string>
|
||||
<string name="lists_reorder_handle">Перетащите, чтобы изменить порядок</string>
|
||||
<string name="sort_title">Сортировать по</string>
|
||||
<string name="view_options_title">Сортировать и фильтровать</string>
|
||||
<string name="view_filter_tags">Фильтр по тегу</string>
|
||||
<string name="view_filter_clear">Очистить фильтр</string>
|
||||
<string name="sort_due">Срок выполнения</string>
|
||||
</resources>
|
||||
@@ -127,16 +127,6 @@
|
||||
<string name="settings_list_notifications">Sound & 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>
|
||||
@@ -210,8 +200,6 @@
|
||||
<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>
|
||||
@@ -484,13 +472,6 @@
|
||||
<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>
|
||||
|
||||
@@ -1,167 +0,0 @@
|
||||
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)
|
||||
}
|
||||
}
|
||||
+1
-4
@@ -1,9 +1,6 @@
|
||||
package de.jeanlucmakiola.agendula.data.tasks
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
/** A [ColumnReader] backed by a Map, so mappers test without a real Cursor. */
|
||||
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()
|
||||
@@ -1,24 +0,0 @@
|
||||
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()
|
||||
}
|
||||
}
|
||||
@@ -1,332 +0,0 @@
|
||||
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()
|
||||
}
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
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,20 +218,13 @@ class VTodoMapperTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `SEQUENCE is written as the column holds it`() {
|
||||
// Raising it is the upload's job, not the mapper's.
|
||||
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.
|
||||
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(
|
||||
|
||||
@@ -1,93 +0,0 @@
|
||||
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()
|
||||
}
|
||||
}
|
||||
@@ -1,223 +0,0 @@
|
||||
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,41 +172,6 @@ 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,12 +81,7 @@ 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,
|
||||
sequence = maxOf(current.sequence, synced.sequence),
|
||||
)
|
||||
this.rows[index] = current.copy(href = href, etag = eTag, isDirty = current.lastModified != synced.lastModified)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,10 +0,0 @@
|
||||
### جديد
|
||||
- اختر مقدار الوصف الذي تعرضه التذكيرات: لا شيء أو معاينة قصيرة (الافتراضي) أو الوصف كله.
|
||||
|
||||
### تغييرات
|
||||
- القوائم ذات التذكيرات الافتراضية الخاصة مُعلَّمة في المحرر وفي الإعدادات.
|
||||
|
||||
### إصلاحات
|
||||
- مع مزامنة CalDAV، ينقل تطبيق تذكيرات Apple أيضًا المهمة المتكررة المنجزة إلى موعدها التالي.
|
||||
- حذف آخر تاريخ لمهمة يحذف تذكيراتها أيضًا.
|
||||
- لم يعد شريط التنقل ولوحة المفاتيح يغطيان المحتوى.
|
||||
@@ -1,10 +0,0 @@
|
||||
### 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.
|
||||
@@ -1,10 +0,0 @@
|
||||
### 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.
|
||||
@@ -1,10 +0,0 @@
|
||||
### 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.
|
||||
@@ -1,10 +0,0 @@
|
||||
### 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.
|
||||
@@ -1,10 +0,0 @@
|
||||
### 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.
|
||||
@@ -1,10 +0,0 @@
|
||||
### 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.
|
||||
@@ -1,10 +0,0 @@
|
||||
### Новое
|
||||
- Выберите, сколько описания показывают напоминания: ничего, фрагмент (по умолчанию) или всё.
|
||||
|
||||
### Изменения
|
||||
- Списки со своими напоминаниями по умолчанию отмечены в редакторе и в настройках.
|
||||
|
||||
### Исправления
|
||||
- С синхронизацией CalDAV «Напоминания» Apple тоже переносят отмеченную повторяющуюся задачу.
|
||||
- Удаление последней даты задачи удаляет и её напоминания.
|
||||
- Панель навигации и клавиатура больше не закрывают содержимое.
|
||||
+1
-1
Submodule floret-kit updated: 31281bb224...a26bea7871.
Reference in new issue
Block a user