Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 makiolaj
|
e12bbdce17 |
No files matched your search
@@ -7,58 +7,6 @@ All notable changes to this project are documented here. The format follows
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
## [1.3.1] - 2026-11-09
|
||||
|
||||
### Changed
|
||||
- Ticking off the current occurrence of a repeating task moves the series on
|
||||
to its next date and keeps a completed copy, as tasks.org and Apple
|
||||
Reminders do. Other apps and the web views of servers such as Infomaniak now
|
||||
see it as done instead of still open. Unticking it moves the series back,
|
||||
as long as the series hasn't moved on or changed its start since (#137).
|
||||
|
||||
### Fixed
|
||||
- With tasks.org as the storage provider, recurring tasks are recognised as
|
||||
recurring. Before, editing one removed its recurrence and ticking it off
|
||||
closed the whole series. With tasks.org and OpenTasks alike, the editor now
|
||||
shows the task's repeat rule instead of none, and an occurrence changed on
|
||||
its own stays part of its series (#135).
|
||||
- With tasks.org or OpenTasks as the storage provider, the order you give your
|
||||
lists is kept instead of snapping back (#136).
|
||||
|
||||
## [1.3.0] - 2026-11-02
|
||||
|
||||
### Added
|
||||
- Self-hosted servers with a self-signed certificate can be added: Agendula
|
||||
shows the certificate's fingerprint and asks whether to trust it. A server
|
||||
reached over plain http can be added too, after a warning. If a trusted
|
||||
certificate is later renewed, "Sign in again" on the account asks about the
|
||||
new one (#68).
|
||||
- An account can be given its own name (#105).
|
||||
- Pull down on the task list to sync (#73).
|
||||
- Task list sections can be collapsed (#91).
|
||||
- A pure black theme for AMOLED screens (#99).
|
||||
- Agendula can show up as "Tasks" in your launcher, picked from launcher
|
||||
previews as in Calendula (#104).
|
||||
- Reminder notifications show the task's description (#94).
|
||||
|
||||
### Changed
|
||||
- Adding or opening a task from a widget returns you to the home screen
|
||||
afterwards (#93).
|
||||
- A swipe that starts at the screen edge no longer swipes the task (#90).
|
||||
- Today also lists tasks that start today, and keeps the ones completed today
|
||||
in a Completed section (#123).
|
||||
|
||||
### Fixed
|
||||
- A task created from Today, or from a Today widget, is due today, so it shows
|
||||
up there (#122).
|
||||
- Completing a task from the list, a widget or another device now cancels its
|
||||
upcoming reminder and clears one already showing (#127, #129).
|
||||
- The splash screen follows the app's theme, including Black and dynamic
|
||||
colour, instead of flashing white in dark mode (#119).
|
||||
- A task saved without its default start or due reminder because it had
|
||||
already rung (a start of "now", say) gets it once that date is moved later,
|
||||
if the task has no reminder from that date (#121).
|
||||
|
||||
## [1.2.0] - 2026-10-26
|
||||
|
||||
### Added
|
||||
|
||||
@@ -33,8 +33,8 @@ android {
|
||||
// (1.0.x: 1.0.0 -> 10000; from 1.1.0: 1.1.0-beta.1 -> 1010001,
|
||||
// 1.1.0 -> 1010099), and CI fails if the committed one doesn't match.
|
||||
// See docs/RELEASING.md.
|
||||
versionCode = 1030199
|
||||
versionName = "1.3.1"
|
||||
versionCode = 1020099
|
||||
versionName = "1.2.0"
|
||||
|
||||
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
|
||||
|
||||
|
||||
@@ -1,553 +0,0 @@
|
||||
{
|
||||
"formatVersion": 1,
|
||||
"database": {
|
||||
"version": 4,
|
||||
"identityHash": "47f3bedbfbf4ddd1db32864c718de83a",
|
||||
"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"
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
"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, '47f3bedbfbf4ddd1db32864c718de83a')"
|
||||
]
|
||||
}
|
||||
}
|
||||
@@ -1,768 +0,0 @@
|
||||
{
|
||||
"formatVersion": 1,
|
||||
"database": {
|
||||
"version": 5,
|
||||
"identityHash": "fcb14ff68d892c72fa7459204276abb6",
|
||||
"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, 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"
|
||||
}
|
||||
],
|
||||
"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, 'fcb14ff68d892c72fa7459204276abb6')"
|
||||
]
|
||||
}
|
||||
}
|
||||
-76
@@ -1,76 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.data.tasks
|
||||
|
||||
import android.content.Context
|
||||
import androidx.test.core.app.ApplicationProvider
|
||||
import androidx.test.ext.junit.runners.AndroidJUnit4
|
||||
import com.google.common.truth.Truth.assertThat
|
||||
import org.junit.After
|
||||
import org.junit.Assume.assumeTrue
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import java.util.concurrent.CountDownLatch
|
||||
import java.util.concurrent.TimeUnit
|
||||
|
||||
/**
|
||||
* List order against a real external provider (#136). Skipped unless one is
|
||||
* installed and its permissions are granted.
|
||||
*/
|
||||
@RunWith(AndroidJUnit4::class)
|
||||
class ExternalProviderListOrderTest {
|
||||
|
||||
private val context = ApplicationProvider.getApplicationContext<Context>()
|
||||
private val resolver = ProviderResolver(AndroidProviderEnvironment(context)).apply {
|
||||
storageMode = StorageMode.EXTERNAL
|
||||
}
|
||||
private val source = AndroidTasksDataSource(context, resolver)
|
||||
private val created = mutableListOf<Long>()
|
||||
|
||||
@Before
|
||||
fun setUp() {
|
||||
val provider = resolver.resolve()
|
||||
assumeTrue("no external tasks provider, or not granted", provider != null && resolver.hasPermission(provider))
|
||||
listOf("Order A", "Order B", "Order C").forEach { created += source.createLocalList(it, 0) }
|
||||
}
|
||||
|
||||
@After
|
||||
fun tearDown() = created.forEach { runCatching { source.deleteList(it) } }
|
||||
|
||||
private fun ours() = source.taskLists().map { it.id }.filter { it in created }
|
||||
|
||||
/** Waits until the provider has gone quiet, so a change seen afterwards is the test's own. */
|
||||
private fun settle() {
|
||||
var last = System.currentTimeMillis()
|
||||
val observer = source.registerObserver { last = System.currentTimeMillis() }
|
||||
while (System.currentTimeMillis() - last < 1_500) Thread.sleep(100)
|
||||
observer.close()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aReorderIsKeptAndReported() {
|
||||
val (a, b, c) = created
|
||||
settle()
|
||||
val changed = CountDownLatch(1)
|
||||
val observer = source.registerObserver { changed.countDown() }
|
||||
|
||||
source.reorderLists(listOf(c, a, b))
|
||||
|
||||
assertThat(changed.await(5, TimeUnit.SECONDS)).isTrue()
|
||||
observer.close()
|
||||
assertThat(ours()).containsExactly(c, a, b).inOrder()
|
||||
assertThat(AndroidTasksDataSource(context, resolver).taskLists().map { it.id }.filter { it in created })
|
||||
.containsExactly(c, a, b).inOrder()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aDeletedListLeavesNoPositionBehind() {
|
||||
val (a, b, c) = created
|
||||
source.reorderLists(listOf(c, a, b))
|
||||
|
||||
source.deleteList(c)
|
||||
created -= c
|
||||
|
||||
source.taskLists()
|
||||
assertThat(source.storedListOrder().keys).doesNotContain(c)
|
||||
}
|
||||
}
|
||||
-361
@@ -1,361 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.data.tasks
|
||||
|
||||
import android.content.ContentValues
|
||||
import android.content.Context
|
||||
import androidx.test.core.app.ApplicationProvider
|
||||
import androidx.test.ext.junit.runners.AndroidJUnit4
|
||||
import com.google.common.truth.Truth.assertThat
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Tasks
|
||||
import de.jeanlucmakiola.agendula.domain.Task
|
||||
import de.jeanlucmakiola.agendula.domain.TaskForm
|
||||
import de.jeanlucmakiola.agendula.domain.TaskReminder
|
||||
import org.junit.After
|
||||
import org.junit.Assert.assertThrows
|
||||
import org.junit.Assume.assumeTrue
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import kotlin.time.Clock
|
||||
import kotlin.time.Duration.Companion.hours
|
||||
import kotlin.time.Duration.Companion.milliseconds
|
||||
import kotlin.time.Instant
|
||||
|
||||
/**
|
||||
* Recurrence against a real external provider (#135). Skipped unless one is
|
||||
* installed and its permissions are granted, so it only runs where set up:
|
||||
* `pm grant <app> org.tasks.permission.READ_TASKS` (and WRITE_TASKS).
|
||||
*/
|
||||
@RunWith(AndroidJUnit4::class)
|
||||
class ExternalProviderRecurrenceTest {
|
||||
|
||||
private val context = ApplicationProvider.getApplicationContext<Context>()
|
||||
private val resolver = ProviderResolver(AndroidProviderEnvironment(context)).apply {
|
||||
storageMode = StorageMode.EXTERNAL
|
||||
}
|
||||
private val source = AndroidTasksDataSource(context, resolver)
|
||||
private var listId = 0L
|
||||
|
||||
@Before
|
||||
fun setUp() {
|
||||
val provider = resolver.resolve()
|
||||
assumeTrue("no external tasks provider, or not granted", provider != null && resolver.hasPermission(provider))
|
||||
listId = source.createLocalList("Recurrence test", 0)
|
||||
}
|
||||
|
||||
@After
|
||||
fun tearDown() {
|
||||
if (listId != 0L) source.deleteList(listId)
|
||||
}
|
||||
|
||||
private fun dailyTask(): Long {
|
||||
// Milliseconds and all, as the "start today" default gives.
|
||||
val start = Clock.System.now() + 1.hours
|
||||
return source.insertTask(
|
||||
TaskForm(title = "Daily", listId = listId, start = start, due = start + 1.hours, rrule = "FREQ=DAILY"),
|
||||
reminders = null,
|
||||
)
|
||||
}
|
||||
|
||||
private fun storedRule(taskId: Long): String? = context.contentResolver.query(
|
||||
TasksContract.tasksUri(resolver.resolve()!!.authority),
|
||||
arrayOf(Tasks.RRULE),
|
||||
"${Tasks.ID} = ?",
|
||||
arrayOf(taskId.toString()),
|
||||
null,
|
||||
)?.use { c -> if (c.moveToFirst()) c.getString(0) else null }
|
||||
|
||||
private fun setRule(taskId: Long, rule: String) {
|
||||
context.contentResolver.update(
|
||||
TasksContract.tasksUri(resolver.resolve()!!.authority),
|
||||
ContentValues().apply { put(Tasks.RRULE, rule) },
|
||||
"${Tasks.ID} = ?",
|
||||
arrayOf(taskId.toString()),
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aSeriesReadsAsRecurringWithItsRule() {
|
||||
val id = dailyTask()
|
||||
|
||||
val listed = source.tasks(TaskQuery(listId = listId)).filter { it.taskId == id }.minBy { it.occurrenceStart!! }
|
||||
assertThat(listed.isRecurring).isTrue()
|
||||
assertThat(listed.isOccurrence).isTrue()
|
||||
assertThat(listed.recurrenceRule).isEqualTo("FREQ=DAILY")
|
||||
|
||||
val opened = source.task(id)!!
|
||||
assertThat(opened.recurrenceRule).isEqualTo("FREQ=DAILY")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun savingTheSeriesKeepsItsRule() {
|
||||
val id = dailyTask()
|
||||
val task = source.task(id)!!
|
||||
|
||||
source.updateSeries(
|
||||
id,
|
||||
task.occurrenceStart!!,
|
||||
TaskForm(title = "Daily, renamed", listId = listId, start = task.start, due = task.due, rrule = task.recurrenceRule),
|
||||
reminders = null,
|
||||
)
|
||||
|
||||
assertThat(storedRule(id)).isEqualTo("FREQ=DAILY")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun completingAnOccurrenceMovesTheSeriesOn() {
|
||||
val id = dailyTask()
|
||||
val task = source.task(id)!!
|
||||
|
||||
source.setCompletedInstance(id, task.occurrenceStart!!, completed = true)
|
||||
|
||||
assertSeriesMovedOn(id, task.occurrenceStart!!)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aTickedOccurrenceReadsAsItsCopy() {
|
||||
val id = dailyTask()
|
||||
val anchor = source.task(id)!!.occurrenceStart!!
|
||||
|
||||
source.setCompletedInstance(id, anchor, completed = true)
|
||||
|
||||
val read = source.task(id, anchor)!!
|
||||
assertThat(read.taskId).isNotEqualTo(id)
|
||||
assertThat(read.isClosed).isTrue()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun undoingATickMovesTheSeriesBack() {
|
||||
val id = dailyTask()
|
||||
val anchor = source.task(id)!!.occurrenceStart!!
|
||||
source.setCompletedInstance(id, anchor, completed = true)
|
||||
val copy = source.task(id, anchor)!!.taskId
|
||||
|
||||
source.setCompletedInstance(id, anchor, completed = false)
|
||||
|
||||
val read = source.task(id, anchor)!!
|
||||
assertThat(read.taskId).isEqualTo(id)
|
||||
assertThat(read.isClosed).isFalse()
|
||||
assertThat(source.task(copy)).isNull()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun reopeningTheCopyItselfMovesTheSeriesBack() {
|
||||
val id = dailyTask()
|
||||
val anchor = source.task(id)!!.occurrenceStart!!
|
||||
source.setCompletedInstance(id, anchor, completed = true)
|
||||
val copy = source.task(id, anchor)!!.taskId
|
||||
|
||||
source.setCompleted(copy, completed = false)
|
||||
|
||||
assertThat(source.task(id, anchor)!!.taskId).isEqualTo(id)
|
||||
assertThat(source.task(copy)).isNull()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aSeriesChangedSinceTheTickReopensOnlyTheCopy() {
|
||||
val id = dailyTask()
|
||||
val anchor = source.task(id)!!.occurrenceStart!!
|
||||
source.setCompletedInstance(id, anchor, completed = true)
|
||||
val copy = source.task(id, anchor)!!.taskId
|
||||
setRule(id, "FREQ=WEEKLY")
|
||||
|
||||
source.setCompletedInstance(id, anchor, completed = false)
|
||||
|
||||
assertThat(source.task(copy)!!.isClosed).isFalse()
|
||||
assertThat(storedRule(id)).isEqualTo("FREQ=WEEKLY")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun anOccurrenceThatIsGoneReadsAsNothing() {
|
||||
val id = dailyTask()
|
||||
val anchor = source.task(id)!!.occurrenceStart!!
|
||||
|
||||
assertThat(source.task(id, anchor + 30.hours)).isNull()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aSeriesStoredWithMillisecondsStillMovesOn() {
|
||||
val id = legacySeries()
|
||||
val task = source.task(id)!!
|
||||
|
||||
source.setCompletedInstance(id, task.occurrenceStart!!, completed = true)
|
||||
|
||||
assertSeriesMovedOn(id, task.occurrenceStart)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun anUnknownOccurrenceDoesNotCloseTheSeries() {
|
||||
val id = dailyTask()
|
||||
val anchor = source.task(id)!!.occurrenceStart!!
|
||||
|
||||
assertThrows(TaskWriteFailedException::class.java) {
|
||||
source.setCompletedInstance(id, anchor + 30.hours, completed = true)
|
||||
}
|
||||
|
||||
assertThat(source.task(id)!!.isClosed).isFalse()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun roundingALegacySeriesLeavesItUnmodified() {
|
||||
val id = legacySeries()
|
||||
val before = storedColumn(id, Tasks.LAST_MODIFIED)
|
||||
|
||||
source.task(id)
|
||||
|
||||
assertThat(storedStart(id)!! % 1000).isEqualTo(0L)
|
||||
assertThat(storedColumn(id, Tasks.LAST_MODIFIED)).isEqualTo(before)
|
||||
}
|
||||
|
||||
/** A daily series as builds before whole-second writes left it, already in sync with its server. */
|
||||
private fun legacySeries(): Long {
|
||||
val start = (Clock.System.now() + 1.hours).toEpochMilliseconds() / 1000 * 1000
|
||||
return insertAsSyncAdapter(
|
||||
Tasks.LIST_ID to listId,
|
||||
Tasks.TITLE to "Old daily",
|
||||
Tasks.DTSTART to start + 345,
|
||||
Tasks.DUE to start + 3_600_345,
|
||||
Tasks.TZ to "UTC",
|
||||
Tasks.RRULE to "FREQ=DAILY",
|
||||
).also {
|
||||
// The app's own reads may already have run the one-time rounding.
|
||||
context.getSharedPreferences("provider_migrations", Context.MODE_PRIVATE).edit().clear().commit()
|
||||
}
|
||||
}
|
||||
|
||||
private fun insertAsSyncAdapter(vararg values: Pair<String, Any>): Long {
|
||||
val uri = TasksContract.asSyncAdapter(
|
||||
TasksContract.tasksUri(resolver.resolve()!!.authority),
|
||||
TasksContract.LOCAL_ACCOUNT_NAME,
|
||||
TasksContract.LOCAL_ACCOUNT_TYPE,
|
||||
)
|
||||
val cv = ContentValues().apply {
|
||||
values.forEach { (k, v) -> if (v is Long) put(k, v) else put(k, v.toString()) }
|
||||
}
|
||||
return context.contentResolver.insert(uri, cv)!!.lastPathSegment!!.toLong()
|
||||
}
|
||||
|
||||
/** Edits the series' first occurrence on its own and returns the override that makes. */
|
||||
private fun overrideOf(id: Long): Task {
|
||||
val task = source.task(id)!!
|
||||
source.updateInstance(
|
||||
id,
|
||||
task.occurrenceStart!!,
|
||||
TaskForm(title = "Just this once", listId = listId, start = task.start, due = task.due),
|
||||
reminders = null,
|
||||
)
|
||||
return source.tasks(TaskQuery(listId = listId)).single { it.seriesId == id && it.taskId != id }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun anOverrideBelongsToItsSeries() {
|
||||
val id = dailyTask()
|
||||
val anchor = source.task(id)!!.occurrenceStart
|
||||
|
||||
val override = overrideOf(id)
|
||||
|
||||
assertThat(override.title).isEqualTo("Just this once")
|
||||
assertThat(override.isOccurrence).isTrue()
|
||||
assertThat(override.occurrenceStart).isEqualTo(anchor)
|
||||
assertThat(override.recurrenceRule).isEqualTo("FREQ=DAILY")
|
||||
assertThat(source.task(override.taskId, override.occurrenceStart)?.taskId).isEqualTo(override.taskId)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun anAllDayDueAddedToTheSeriesStaysOnItsDay() {
|
||||
val day = Clock.System.now().toEpochMilliseconds() / 86_400_000 * 86_400_000
|
||||
val id = source.insertTask(
|
||||
TaskForm(title = "All day", listId = listId, start = Instant.fromEpochMilliseconds(day), isAllDay = true, rrule = "FREQ=DAILY"),
|
||||
reminders = null,
|
||||
)
|
||||
val task = source.task(id)!!
|
||||
// Local midnight the next day, as the date picker hands it over.
|
||||
val localMidnight = Instant.fromEpochMilliseconds(day + 86_400_000 - java.util.TimeZone.getDefault().getOffset(day))
|
||||
|
||||
source.updateSeries(
|
||||
id,
|
||||
task.occurrenceStart!!,
|
||||
TaskForm(title = "All day", listId = listId, start = task.start, due = localMidnight, isAllDay = true, rrule = "FREQ=DAILY"),
|
||||
reminders = null,
|
||||
)
|
||||
|
||||
assertThat(storedColumn(id, Tasks.DUE)!!.toLong() % 86_400_000).isEqualTo(0L)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun savingAllFromAnOverrideKeepsTheSeriesWhereItIs() {
|
||||
val id = dailyTask()
|
||||
val before = storedStart(id)
|
||||
val override = overrideOf(id)
|
||||
|
||||
source.updateSeries(
|
||||
id,
|
||||
override.occurrenceStart!!,
|
||||
TaskForm(title = "Renamed", listId = listId, start = override.start, due = override.due, rrule = override.recurrenceRule),
|
||||
reminders = null,
|
||||
)
|
||||
|
||||
assertThat(storedStart(id)).isEqualTo(before)
|
||||
assertThat(storedRule(id)).isEqualTo("FREQ=DAILY")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun deletingAnOverrideExcludesItsOccurrence() {
|
||||
val id = dailyTask()
|
||||
val override = overrideOf(id)
|
||||
|
||||
source.deleteOverride(override.taskId, override.occurrenceStart!!)
|
||||
|
||||
// Excluded on the master, not just the override dropped.
|
||||
assertThat(storedColumn(id, Tasks.EXDATE)).isNotNull()
|
||||
val open = source.tasks(TaskQuery(listId = listId)).filter { it.seriesId == id }
|
||||
assertThat(open.map { it.occurrenceStart }).doesNotContain(override.occurrenceStart)
|
||||
assertThat(storedRule(id)).isEqualTo("FREQ=DAILY")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun editingAnOverrideAgainKeepsItsNewTagsAndReminders() {
|
||||
val id = dailyTask()
|
||||
val override = overrideOf(id)
|
||||
val form = TaskForm(
|
||||
title = override.title,
|
||||
listId = listId,
|
||||
start = override.start,
|
||||
due = override.due,
|
||||
tags = listOf("urgent"),
|
||||
reminders = listOf(TaskReminder(minutesBefore = 15)),
|
||||
)
|
||||
|
||||
source.updateInstance(override.taskId, override.occurrenceStart!!, form, form.reminders)
|
||||
|
||||
assertThat(source.task(override.taskId)!!.tags).containsExactly("urgent")
|
||||
assertThat(source.reminders()[override.taskId]).containsExactly(TaskReminder(minutesBefore = 15))
|
||||
assertThat(source.task(id)?.tags.orEmpty()).isEmpty()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun anOccurrenceIsFoundByItsAnchorToTheSecond() {
|
||||
val id = dailyTask()
|
||||
val override = overrideOf(id)
|
||||
|
||||
val found = source.task(id, override.occurrenceStart!! + 345.milliseconds)
|
||||
|
||||
assertThat(found?.taskId).isEqualTo(override.taskId)
|
||||
}
|
||||
|
||||
private fun storedStart(taskId: Long): Long? = storedColumn(taskId, Tasks.DTSTART)?.toLong()
|
||||
|
||||
private fun storedColumn(taskId: Long, column: String): String? = context.contentResolver.query(
|
||||
TasksContract.tasksUri(resolver.resolve()!!.authority),
|
||||
arrayOf(column),
|
||||
"${Tasks.ID} = ?",
|
||||
arrayOf(taskId.toString()),
|
||||
null,
|
||||
)?.use { c -> if (c.moveToFirst()) c.getString(0) else null }
|
||||
|
||||
private fun assertSeriesMovedOn(id: Long, completed: Instant) {
|
||||
assertThat(storedRule(id)).isNotNull()
|
||||
val open = source.tasks(TaskQuery(listId = listId)).filter { it.seriesId == id }
|
||||
assertThat(open).isNotEmpty()
|
||||
assertThat(open.minOf { it.occurrenceStart!! }).isGreaterThan(completed)
|
||||
}
|
||||
}
|
||||
-5
@@ -124,7 +124,6 @@ class AgendulaTaskProviderTest {
|
||||
|
||||
@Test
|
||||
fun aBadWriteReachesTheClientAsIllegalArgument() {
|
||||
assumeTrue("Agendula is running on an external provider", ownStore())
|
||||
// No list has this id, so nothing in the app's real store is touched.
|
||||
val values = ContentValues().apply {
|
||||
put("list_id", Long.MAX_VALUE)
|
||||
@@ -136,7 +135,6 @@ class AgendulaTaskProviderTest {
|
||||
|
||||
@Test
|
||||
fun aFailingBatchWritesNothing() {
|
||||
assumeTrue("Agendula is running on an external provider", ownStore())
|
||||
val missingList = Long.MAX_VALUE
|
||||
val operations = arrayListOf(
|
||||
ContentProviderOperation.newInsert(uri("tasks")).withValue("list_id", missingList).withValue("title", "a").build(),
|
||||
@@ -147,9 +145,6 @@ class AgendulaTaskProviderTest {
|
||||
.use { assertThat(it.count).isEqualTo(0) }
|
||||
}
|
||||
|
||||
/** Whether the app's own store is active: only then does the provider take writes at all. */
|
||||
private fun ownStore() = runCatching { resolver.delete(uri("tasks"), "_id = -1", null) }.isSuccess
|
||||
|
||||
/** stdout and stderr of [command]; the denial lands on stderr. */
|
||||
private fun shell(command: String): String {
|
||||
val (stdout, stdin, stderr) = InstrumentationRegistry.getInstrumentation().uiAutomation
|
||||
|
||||
+2
-18
@@ -734,11 +734,9 @@ class ProviderWriterTest {
|
||||
val series = db.tasks().insert(
|
||||
TaskEntity(listId = home, uid = "f", title = "Floating", due = today, rrule = "FREQ=DAILY;COUNT=3", timezone = null),
|
||||
)
|
||||
// The second occurrence: ticking the first moves the series on instead.
|
||||
val second = today + 1.days
|
||||
val row = readRow(ProviderTable.INSTANCES, instanceId(second))
|
||||
val row = readRow(ProviderTable.INSTANCES, instanceId(today))
|
||||
|
||||
writer.update(ProviderTable.INSTANCES, row + (Tasks.STATUS to 2), byId(ProviderTable.INSTANCES, instanceId(second)), null)
|
||||
writer.update(ProviderTable.INSTANCES, row + (Tasks.STATUS to 2), byId(ProviderTable.INSTANCES, instanceId(today)), null)
|
||||
writer.update(ProviderTable.TASKS, mapOf(Tasks.TITLE to "Still floating"), byId(ProviderTable.TASKS, series), null)
|
||||
|
||||
assertThat(db.tasks().overrides(series).single().status).isEqualTo(TaskStatus.COMPLETED)
|
||||
@@ -797,20 +795,6 @@ class ProviderWriterTest {
|
||||
|
||||
private fun store() = RoomTasksDataSource(db)
|
||||
|
||||
@Test
|
||||
fun reopeningATickedOccurrencesCopyMovesTheSeriesBack() {
|
||||
val series = db.tasks().insert(
|
||||
TaskEntity(listId = home, uid = "w", title = "Weekly", dtstart = today, rrule = "FREQ=WEEKLY", timezone = "UTC"),
|
||||
)
|
||||
store().setCompletedInstance(series, today, true)
|
||||
val copy = db.tasks().allIn(home).single { it.id != series }
|
||||
|
||||
writer.update(ProviderTable.TASKS, mapOf(Tasks.STATUS to 0), byId(ProviderTable.TASKS, copy.id), null)
|
||||
|
||||
assertThat(task(series)!!.dtstart).isEqualTo(today)
|
||||
assertThat(task(copy.id)).isNull()
|
||||
}
|
||||
|
||||
/** Every column of one published row, as a client that read it would write it back. */
|
||||
private fun readRow(table: ProviderTable, id: Long): Map<String, Any?> {
|
||||
val columns = table.columns.map { it.first }
|
||||
|
||||
+5
-625
@@ -211,8 +211,7 @@ class RoomTasksDataSourceTest {
|
||||
@Test
|
||||
fun completingOneOccurrenceLeavesTheRestOfTheSeriesOpen() {
|
||||
val id = source.insertTask(form(title = "Water the plants"))
|
||||
// Overdue occurrences before it, so it is not the first and forks an override.
|
||||
makeRecurring(id, now - 14.days)
|
||||
makeRecurring(id, now)
|
||||
val open = { source.tasks(TaskQuery(listId = listId)).filter { it.taskId == id } }
|
||||
val before = open()
|
||||
val target = before.first { it.distanceFromCurrent == 0 }
|
||||
@@ -238,8 +237,7 @@ class RoomTasksDataSourceTest {
|
||||
@Test
|
||||
fun reopeningACompletedOccurrenceReusesItsOverride() {
|
||||
val id = source.insertTask(form(title = "Water the plants"))
|
||||
// Overdue occurrences before it, so it is not the first and forks an override.
|
||||
makeRecurring(id, now - 14.days)
|
||||
makeRecurring(id, now)
|
||||
val target = source.tasks(TaskQuery(listId = listId))
|
||||
.first { it.taskId == id && it.distanceFromCurrent == 0 }
|
||||
|
||||
@@ -256,8 +254,7 @@ class RoomTasksDataSourceTest {
|
||||
@Test
|
||||
fun cancellingOneOccurrenceLeavesTheRestOfTheSeriesOpen() {
|
||||
val id = source.insertTask(form(title = "Water the plants"))
|
||||
// Overdue occurrences before it, so it is not the first and forks an override.
|
||||
makeRecurring(id, now - 14.days)
|
||||
makeRecurring(id, now)
|
||||
val target = source.tasks(TaskQuery(listId = listId))
|
||||
.first { it.taskId == id && it.distanceFromCurrent == 0 }
|
||||
|
||||
@@ -272,621 +269,6 @@ class RoomTasksDataSourceTest {
|
||||
assertThat(db.tasks().override(id, target.occurrenceStart)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun completingTheFirstOccurrenceMovesTheSeriesOnAndKeepsACopy() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Water the plants"))
|
||||
makeRecurring(id, at, rule = "FREQ=WEEKLY;COUNT=4")
|
||||
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
|
||||
val master = db.tasks().entity(id)!!
|
||||
assertThat(master.status).isEqualTo(TaskStatus.NEEDS_ACTION)
|
||||
assertThat(master.dtstart).isEqualTo(at + 7.days)
|
||||
assertThat(master.due).isEqualTo(at + 8.days)
|
||||
assertThat(master.rrule).isEqualTo("FREQ=WEEKLY;COUNT=3")
|
||||
assertThat(master.isDirty).isTrue()
|
||||
assertThat(db.tasks().overrides(id)).isEmpty()
|
||||
val copy = db.tasks().allIn(listId).single { it.id != id }
|
||||
assertThat(copy.status).isEqualTo(TaskStatus.COMPLETED)
|
||||
assertThat(copy.uid).isNotEqualTo(master.uid)
|
||||
assertThat(copy.rrule).isNull()
|
||||
assertThat(copy.masterId).isNull()
|
||||
assertThat(copy.dtstart).isEqualTo(at)
|
||||
assertThat(copy.title).isEqualTo("Water the plants")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun reopeningTheOccurrenceMovesTheSeriesBack() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Water the plants"))
|
||||
makeRecurring(id, at, rule = "FREQ=WEEKLY;COUNT=4")
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
|
||||
source.setCompletedInstance(id, at, completed = false)
|
||||
|
||||
val master = db.tasks().entity(id)!!
|
||||
assertThat(master.dtstart).isEqualTo(at)
|
||||
assertThat(master.rrule).isEqualTo("FREQ=WEEKLY;COUNT=4")
|
||||
assertThat(db.tasks().allIn(listId).filter { !it.isDeleted }.map { it.id }).containsExactly(id)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun completingAnEditedFirstOccurrenceKeepsItsEdits() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Water the plants"))
|
||||
makeRecurring(id, at)
|
||||
source.updateInstance(id, at, TaskForm(title = "Water the cactus", listId = listId, start = at, due = at + 1.days), reminders = null)
|
||||
val override = db.tasks().override(id, at)!!
|
||||
|
||||
source.setCompletedInstance(override.id, at, completed = true)
|
||||
|
||||
assertThat(db.tasks().overrides(id)).isEmpty()
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at + 7.days)
|
||||
val copy = db.tasks().allIn(listId).single { it.id != id }
|
||||
assertThat(copy.title).isEqualTo("Water the cactus")
|
||||
assertThat(copy.status).isEqualTo(TaskStatus.COMPLETED)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun completingTheLastOccurrenceClosesTheSeries() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Water the plants"))
|
||||
makeRecurring(id, at, rule = "FREQ=WEEKLY;COUNT=1")
|
||||
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.status).isEqualTo(TaskStatus.COMPLETED)
|
||||
assertThat(db.tasks().allIn(listId).map { it.id }).containsExactly(id)
|
||||
|
||||
source.setCompletedInstance(id, at, completed = false)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun cancellingTheFirstOccurrenceMovesTheSeriesOn() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Water the plants"))
|
||||
makeRecurring(id, at)
|
||||
|
||||
source.setCancelledInstance(id, at, cancelled = true)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at + 7.days)
|
||||
assertThat(db.tasks().allIn(listId).single { it.id != id }.status).isEqualTo(TaskStatus.CANCELLED)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aSeriesWhoseStartWasDeletedMovesPastTheTickedOne() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.deleteOccurrence(id, at)
|
||||
|
||||
source.setCompletedInstance(id, at + 7.days, completed = true)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at + 14.days)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun countSpendsExcludedOccurrencesAndReopeningRestoresThem() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Daily"))
|
||||
makeRecurring(id, at, rule = "FREQ=DAILY;COUNT=4")
|
||||
source.deleteOccurrence(id, at + 1.days)
|
||||
val before = db.tasks().entity(id)!!
|
||||
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
|
||||
val moved = db.tasks().entity(id)!!
|
||||
assertThat(moved.dtstart).isEqualTo(at + 2.days)
|
||||
assertThat(moved.rrule).isEqualTo("FREQ=DAILY;COUNT=2")
|
||||
|
||||
source.setCompletedInstance(id, at, completed = false)
|
||||
|
||||
val back = db.tasks().entity(id)!!
|
||||
assertThat(back.dtstart).isEqualTo(before.dtstart)
|
||||
assertThat(back.rrule).isEqualTo(before.rrule)
|
||||
assertThat(back.exdate).isEqualTo(before.exdate)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun reopeningTheCopyItselfMovesTheSeriesBack() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
val copy = db.tasks().allIn(listId).single { it.id != id }
|
||||
|
||||
source.setCompleted(copy.id, completed = false)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at)
|
||||
assertThat(db.tasks().allIn(listId).filter { !it.isDeleted }.map { it.id }).containsExactly(id)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun undoingAnEditedOccurrenceBringsItsOverrideBack() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.updateInstance(id, at, TaskForm(title = "Just this once", listId = listId, start = at, due = at + 1.days), reminders = null)
|
||||
val override = db.tasks().override(id, at)!!
|
||||
source.setCompletedInstance(override.id, at, completed = true)
|
||||
|
||||
source.setCompletedInstance(override.id, at, completed = false)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at)
|
||||
val back = db.tasks().override(id, at)!!
|
||||
assertThat(back.title).isEqualTo("Just this once")
|
||||
assertThat(back.status).isEqualTo(TaskStatus.NEEDS_ACTION)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aStaleTickOfAnOccurrenceMovedPastForksNothing() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
|
||||
assertThat(db.tasks().overrides(id)).isEmpty()
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at + 7.days)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun occurrencesClosedBeforeTheUpdateNoLongerHoldTheSeriesBack() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
val master = db.tasks().entity(id)!!
|
||||
db.tasks().insert(
|
||||
master.copy(id = 0, masterId = id, recurrenceId = at, rrule = null, status = TaskStatus.COMPLETED, completedAt = at),
|
||||
)
|
||||
|
||||
source.setCompletedInstance(id, at + 7.days, completed = true)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at + 14.days)
|
||||
assertThat(db.tasks().overrides(id)).isEmpty()
|
||||
assertThat(db.tasks().allIn(listId).count { it.id != id && it.status == TaskStatus.COMPLETED }).isEqualTo(2)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun theTickedOccurrenceStillResolvesToItsCopy() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
val occurrence = source.task(id, at)!!.occurrenceStart!!
|
||||
|
||||
source.setCompletedInstance(id, occurrence, completed = true)
|
||||
|
||||
val found = source.task(id, occurrence)!!
|
||||
assertThat(found.taskId).isNotEqualTo(id)
|
||||
assertThat(found.isCompleted).isTrue()
|
||||
assertThat(found.occurrenceStart).isEqualTo(occurrence)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun theNextOccurrenceStartsWithoutTheLastOnesProgress() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
db.tasks().update(db.tasks().entity(id)!!.copy(status = TaskStatus.IN_PROCESS, percentComplete = 60))
|
||||
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
|
||||
val master = db.tasks().entity(id)!!
|
||||
assertThat(master.status).isEqualTo(TaskStatus.NEEDS_ACTION)
|
||||
assertThat(master.percentComplete).isNull()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun theCopyOfAnEditedOccurrenceKeepsItsOwnProperties() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
val master = db.tasks().entity(id)!!
|
||||
val override = db.tasks().insert(
|
||||
master.copy(id = 0, masterId = id, recurrenceId = at, rrule = null, unknownProperties = "COMMENT:only this one"),
|
||||
)
|
||||
|
||||
source.setCompletedInstance(override, at, completed = true)
|
||||
|
||||
assertThat(db.tasks().entity(override)!!.unknownProperties!!.lines()).contains("COMMENT:only this one")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aRuleWithAGapOfMoreThanTenYearsKeepsGoing() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Rare"))
|
||||
makeRecurring(id, at, rule = "FREQ=YEARLY;INTERVAL=11")
|
||||
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
|
||||
val master = db.tasks().entity(id)!!
|
||||
assertThat(master.status).isEqualTo(TaskStatus.NEEDS_ACTION)
|
||||
assertThat(master.dtstart!!).isGreaterThan(at + (366 * 10).days)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun reopeningKeepsWhatChangedOnTheSeriesSince() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
source.deleteOccurrence(id, at + 28.days)
|
||||
|
||||
source.setCompletedInstance(id, at, completed = false)
|
||||
|
||||
val master = db.tasks().entity(id)!!
|
||||
assertThat(master.dtstart).isEqualTo(at)
|
||||
assertThat(master.exdate).isNotNull()
|
||||
assertThat(source.tasks(TaskQuery(listId = listId)).map { it.occurrenceStart?.epochSeconds })
|
||||
.doesNotContain((at + 28.days).epochSeconds)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aSeriesWithExtraDatesKeepsTheOverrideModel() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
db.tasks().update(db.tasks().entity(id)!!.copy(rdate = "20991231T090000Z"))
|
||||
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at)
|
||||
assertThat(db.tasks().overrides(id).single().status).isEqualTo(TaskStatus.COMPLETED)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aDeletedSeriesIsNotBroughtBackByItsCopy() {
|
||||
val at = now
|
||||
val work = syncedList()
|
||||
val id = source.insertTask(form(title = "Weekly").copy(listId = work))
|
||||
makeRecurring(id, at)
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
val copy = db.tasks().allIn(work).single { it.id != id }
|
||||
source.deleteWithSubtasks(id)
|
||||
|
||||
source.setCompleted(copy.id, completed = false)
|
||||
|
||||
assertThat(db.tasks().entity(copy.id)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
|
||||
assertThat(db.tasks().entity(copy.id)!!.isDeleted).isFalse()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aSeriesEndedOnItsLastOpenOccurrenceReopens() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Three"))
|
||||
makeRecurring(id, at, rule = "FREQ=WEEKLY;COUNT=3")
|
||||
val master = db.tasks().entity(id)!!
|
||||
listOf(at, at + 7.days).forEach { done ->
|
||||
db.tasks().insert(master.copy(id = 0, masterId = id, recurrenceId = done, rrule = null, status = TaskStatus.COMPLETED))
|
||||
}
|
||||
|
||||
source.setCompletedInstance(id, at + 14.days, completed = true)
|
||||
assertThat(db.tasks().entity(id)!!.status).isEqualTo(TaskStatus.COMPLETED)
|
||||
// Nothing to move past: the closed occurrences stay the series' own.
|
||||
assertThat(db.tasks().overrides(id)).hasSize(2)
|
||||
|
||||
source.setCompletedInstance(id, at + 14.days, completed = false)
|
||||
assertThat(db.tasks().entity(id)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun reopeningAnOlderCopyReopensItOnItsOwn() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
source.setCompletedInstance(id, at + 7.days, completed = true)
|
||||
|
||||
source.setCompletedInstance(id, at, completed = false)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at + 14.days)
|
||||
val reopened = db.tasks().allIn(listId).single { it.id != id && it.dtstart == at }
|
||||
assertThat(reopened.status).isEqualTo(TaskStatus.NEEDS_ACTION)
|
||||
assertThat(db.advancedOccurrences().forCopy(reopened.id)!!.undoable).isFalse()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aSeriesMovesPastOccurrencesAlreadyClosedAfterIt() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
val master = db.tasks().entity(id)!!
|
||||
db.tasks().insert(master.copy(id = 0, masterId = id, recurrenceId = at + 7.days, rrule = null, status = TaskStatus.COMPLETED))
|
||||
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at + 14.days)
|
||||
assertThat(db.tasks().overrides(id)).isEmpty()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aDetachedOccurrenceDeletedSinceStaysExcluded() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
val master = db.tasks().entity(id)!!
|
||||
val earlier = db.tasks().insert(master.copy(id = 0, masterId = id, recurrenceId = at, rrule = null, status = TaskStatus.COMPLETED))
|
||||
source.setCompletedInstance(id, at + 7.days, completed = true)
|
||||
source.deleteTask(earlier)
|
||||
|
||||
source.setCompletedInstance(id, at + 7.days, completed = false)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at)
|
||||
assertThat(source.tasks(TaskQuery(listId = listId)).map { it.occurrenceStart?.epochSeconds })
|
||||
.doesNotContain(at.epochSeconds)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aNestedComponentKeepsItsOwnUid() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
val master = db.tasks().entity(id)!!
|
||||
val override = db.tasks().insert(
|
||||
master.copy(
|
||||
id = 0, masterId = id, recurrenceId = at, rrule = null,
|
||||
unknownProperties = "BEGIN:VALARM\r\nUID:alarm-1\r\nACTION:AUDIO\r\nEND:VALARM",
|
||||
),
|
||||
)
|
||||
|
||||
source.setCompletedInstance(override, at, completed = true)
|
||||
|
||||
assertThat(db.tasks().entity(override)!!.unknownProperties!!.lines()).contains("UID:alarm-1")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun reopeningTheCopyInTheEditorMovesTheSeriesBack() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
val copy = db.tasks().allIn(listId).single { it.id != id }
|
||||
|
||||
source.updateTask(
|
||||
copy.id,
|
||||
TaskForm(title = copy.title.orEmpty(), listId = listId, start = copy.dtstart, due = copy.due, percentComplete = 0),
|
||||
reminders = null,
|
||||
)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun anEditedCopyReopensAsATaskOfItsOwn() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
val copy = db.tasks().allIn(listId).single { it.id != id }
|
||||
db.tasks().update(copy.copy(description = "notes"))
|
||||
source.updateTask(copy.id, TaskForm(title = "Renamed", listId = listId, start = copy.dtstart, due = copy.due, percentComplete = 100), null)
|
||||
|
||||
source.setCompleted(copy.id, completed = false)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at + 7.days)
|
||||
assertThat(db.tasks().entity(copy.id)!!.title).isEqualTo("Renamed")
|
||||
assertThat(db.tasks().entity(copy.id)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aCopyWithASubtaskReopensOnItsOwn() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
val copy = db.tasks().allIn(listId).single { it.id != id }
|
||||
source.insertTask(form(title = "Part").copy(parentId = copy.id))
|
||||
|
||||
source.setCompleted(copy.id, completed = false)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at + 7.days)
|
||||
assertThat(db.tasks().entity(copy.id)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aRecurringSubtaskKeepsTheOverrideModel() {
|
||||
val at = now
|
||||
val parent = source.insertTask(form(title = "Parent"))
|
||||
val id = source.insertTask(form(title = "Daily part").copy(parentId = parent))
|
||||
makeRecurring(id, at, rule = "FREQ=DAILY")
|
||||
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at)
|
||||
assertThat(db.tasks().overrides(id)).hasSize(1)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aSeriesReshapedSinceIsNotMovedBack() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Ten"))
|
||||
makeRecurring(id, at, rule = "FREQ=WEEKLY;COUNT=10")
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
db.tasks().update(db.tasks().entity(id)!!.copy(rrule = "FREQ=DAILY;COUNT=5"))
|
||||
|
||||
source.setCompletedInstance(id, at, completed = false)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at + 7.days)
|
||||
assertThat(db.tasks().entity(id)!!.rrule).isEqualTo("FREQ=DAILY;COUNT=5")
|
||||
assertThat(db.tasks().allIn(listId).single { it.id != id }.status).isEqualTo(TaskStatus.NEEDS_ACTION)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun tickingTheSameOccurrenceAgainKeepsOneRecord() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
source.setCompletedInstance(id, at, completed = false)
|
||||
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
|
||||
assertThat(db.advancedOccurrences().forMaster(id)).hasSize(1)
|
||||
source.setCompletedInstance(id, at, completed = false)
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun anEditedCopyStillStandsForItsOccurrence() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
val copy = db.tasks().allIn(listId).single { it.id != id }
|
||||
|
||||
db.tasks().update(copy.copy(title = "Watered"))
|
||||
|
||||
assertThat(source.task(id, at)!!.taskId).isEqualTo(copy.id)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aDetachedOccurrenceWithALifeOfItsOwnStaysOut() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
val master = db.tasks().entity(id)!!
|
||||
val earlier = db.tasks().insert(master.copy(id = 0, masterId = id, recurrenceId = at, rrule = null, status = TaskStatus.COMPLETED))
|
||||
source.setCompletedInstance(id, at + 7.days, completed = true)
|
||||
source.insertTask(form(title = "Follow-up").copy(parentId = earlier))
|
||||
|
||||
source.setCompletedInstance(id, at + 7.days, completed = false)
|
||||
|
||||
assertThat(db.tasks().entity(earlier)!!.masterId).isNull()
|
||||
assertThat(source.tasks(TaskQuery(listId = listId)).map { it.occurrenceStart?.epochSeconds })
|
||||
.doesNotContain(at.epochSeconds)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun reopeningAnotherOverrideOfAFinishedSeriesLeavesItsLastOccurrenceClosed() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Three"))
|
||||
makeRecurring(id, at, rule = "FREQ=WEEKLY;COUNT=3")
|
||||
val master = db.tasks().entity(id)!!
|
||||
val last = db.tasks().insert(master.copy(id = 0, masterId = id, recurrenceId = at + 14.days, rrule = null, status = TaskStatus.COMPLETED))
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
source.setCompletedInstance(id, at + 7.days, completed = true)
|
||||
assertThat(db.tasks().entity(id)!!.status).isEqualTo(TaskStatus.COMPLETED)
|
||||
|
||||
source.setCompletedInstance(last, at + 14.days, completed = false)
|
||||
|
||||
assertThat(db.tasks().entity(last)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
|
||||
assertThat(db.tasks().entity(id)!!.status).isEqualTo(TaskStatus.COMPLETED)
|
||||
assertThat(source.task(id, at + 7.days)!!.isClosed).isTrue()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun reopeningTheCopyWithNewRemindersKeepsThem() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
val copy = db.tasks().allIn(listId).single { it.id != id }
|
||||
|
||||
source.updateTask(
|
||||
copy.id,
|
||||
TaskForm(title = copy.title.orEmpty(), listId = listId, start = copy.dtstart, due = copy.due, percentComplete = 0),
|
||||
reminders = listOf(TaskReminder(minutesBefore = 30)),
|
||||
)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at + 7.days)
|
||||
assertThat(db.tasks().entity(copy.id)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
|
||||
assertThat(db.alarms().forTask(copy.id)).hasSize(1)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aDetachedOccurrenceReopenedSinceStaysOut() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
val master = db.tasks().entity(id)!!
|
||||
val earlier = db.tasks().insert(master.copy(id = 0, masterId = id, recurrenceId = at, rrule = null, status = TaskStatus.COMPLETED))
|
||||
source.setCompletedInstance(id, at + 7.days, completed = true)
|
||||
source.setCompleted(earlier, completed = false)
|
||||
|
||||
source.setCompletedInstance(id, at + 7.days, completed = false)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at)
|
||||
assertThat(db.tasks().entity(earlier)!!.masterId).isNull()
|
||||
assertThat(source.tasks(TaskQuery(listId = listId)).filter { it.taskId == id }.map { it.occurrenceStart?.epochSeconds })
|
||||
.doesNotContain(at.epochSeconds)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun anOccurrenceWhoseCopyIsGoneReadsAsNothing() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
source.deleteTask(db.tasks().allIn(listId).single { it.id != id }.id)
|
||||
|
||||
assertThat(source.task(id, at)).isNull()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun catchingUpOnAnOverdueSeriesKeepsEachTickUndoable() {
|
||||
val at = now - 56.days
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
val first = db.tasks().allIn(listId).single { it.id != id }
|
||||
source.setCompletedInstance(id, at + 7.days, completed = true)
|
||||
|
||||
assertThat(db.advancedOccurrences().forCopy(first.id)).isNotNull()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aRuleTheServerReorderedStillMovesBack() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Ten"))
|
||||
makeRecurring(id, at, rule = "FREQ=WEEKLY;COUNT=10")
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
db.tasks().update(db.tasks().entity(id)!!.copy(rrule = "count=9;FREQ=WEEKLY"))
|
||||
|
||||
source.setCompletedInstance(id, at, completed = false)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun reopeningWithProgressKeepsIt() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
val copy = db.tasks().allIn(listId).single { it.id != id }
|
||||
|
||||
source.updateTask(
|
||||
copy.id,
|
||||
TaskForm(title = copy.title.orEmpty(), listId = listId, start = copy.dtstart, due = copy.due, percentComplete = 40),
|
||||
reminders = null,
|
||||
)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at)
|
||||
assertThat(db.tasks().override(id, at)!!.percentComplete).isEqualTo(40)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun theEditorsTidyingDoesNotCountAsAnEdit() {
|
||||
val at = now
|
||||
val id = source.insertTask(form(title = "Weekly"))
|
||||
makeRecurring(id, at)
|
||||
db.tasks().update(db.tasks().entity(id)!!.copy(description = "From the server\n"))
|
||||
source.setCompletedInstance(id, at, completed = true)
|
||||
val copy = db.tasks().allIn(listId).single { it.id != id }
|
||||
|
||||
source.updateTask(
|
||||
copy.id,
|
||||
TaskForm(title = copy.title.orEmpty(), listId = listId, description = copy.description, start = copy.dtstart, due = copy.due, percentComplete = 0),
|
||||
reminders = null,
|
||||
)
|
||||
|
||||
assertThat(db.tasks().entity(id)!!.dtstart).isEqualTo(at)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun completingANonRecurringTaskThroughTheInstancePathWritesTheRowItself() {
|
||||
val id = source.insertTask(form(title = "Buy milk", due = now + 1.days))
|
||||
@@ -1275,12 +657,10 @@ class RoomTasksDataSourceTest {
|
||||
val outOfWindow = db.tasks().insert(
|
||||
TaskEntity(listId = listId, uid = "old", title = "old", dtstart = longAgo, rrule = "FREQ=DAILY;COUNT=2", parentId = parent),
|
||||
)
|
||||
val at = now
|
||||
val series = db.tasks().insert(
|
||||
TaskEntity(listId = listId, uid = "s", title = "s", dtstart = at, rrule = "FREQ=DAILY;COUNT=3", parentId = parent),
|
||||
TaskEntity(listId = listId, uid = "s", title = "s", dtstart = now, rrule = "FREQ=DAILY;COUNT=3", parentId = parent),
|
||||
)
|
||||
// Not the first occurrence, so it forks an override rather than a copy.
|
||||
source.setCompletedInstance(series, at + 1.days, true)
|
||||
source.setCompletedInstance(series, now, true)
|
||||
val plain = source.insertTask(form("plain").copy(parentId = parent))
|
||||
|
||||
assertThat(source.subtaskIds(parent)).containsExactly(outOfWindow, series, plain)
|
||||
|
||||
-27
@@ -147,33 +147,6 @@ class TasksDatabaseMigrationTest {
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun addsAnEmptyAccountLabel() {
|
||||
helper.createDatabase(TEST_DB, 3).use { db ->
|
||||
db.execSQL("INSERT INTO accounts (id, display_name) VALUES (1, 'me@example.org')")
|
||||
}
|
||||
|
||||
helper.runMigrationsAndValidate(TEST_DB, 4, true, TasksDatabase.MIGRATION_3_4).use { db ->
|
||||
db.query("SELECT display_name, label FROM accounts").use { c ->
|
||||
assertThat(c.moveToFirst()).isTrue()
|
||||
assertThat(c.getString(0)).isEqualTo("me@example.org")
|
||||
assertThat(c.isNull(1)).isTrue()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun addsTheAdvancedOccurrencesTable() {
|
||||
helper.createDatabase(TEST_DB, 4).close()
|
||||
|
||||
helper.runMigrationsAndValidate(TEST_DB, 5, true, TasksDatabase.MIGRATION_4_5).use { db ->
|
||||
db.query("SELECT COUNT(*) FROM advanced_occurrences").use { c ->
|
||||
assertThat(c.moveToFirst()).isTrue()
|
||||
assertThat(c.getInt(0)).isEqualTo(0)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private companion object {
|
||||
const val TEST_DB = "migration-test.db"
|
||||
}
|
||||
|
||||
-90
@@ -1,90 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.data.sync
|
||||
|
||||
import android.content.Context
|
||||
import androidx.room.Room
|
||||
import androidx.test.core.app.ApplicationProvider
|
||||
import androidx.test.ext.junit.runners.AndroidJUnit4
|
||||
import com.google.common.truth.Truth.assertThat
|
||||
import de.jeanlucmakiola.agendula.data.tasks.room.RoomTasksDataSource
|
||||
import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
|
||||
import de.jeanlucmakiola.agendula.data.tasks.room.TaskListEntity
|
||||
import de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase
|
||||
import org.junit.After
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import kotlin.time.Clock
|
||||
import kotlin.time.Duration.Companion.seconds
|
||||
import kotlin.time.Instant
|
||||
|
||||
/** A server version replacing a moved series takes the moves' copies with it (#137). */
|
||||
@RunWith(AndroidJUnit4::class)
|
||||
class RoomSyncStoreAdvancesTest {
|
||||
|
||||
private val db = Room.inMemoryDatabaseBuilder(ApplicationProvider.getApplicationContext<Context>(), TasksDatabase::class.java)
|
||||
.allowMainThreadQueries().build()
|
||||
|
||||
@After
|
||||
fun tearDown() = db.close()
|
||||
|
||||
@Test
|
||||
fun droppingAdvancesDeletesTheirCopies() {
|
||||
val list = db.taskLists().insert(TaskListEntity(name = "Home", color = 0))
|
||||
val at = Instant.fromEpochSeconds(Clock.System.now().epochSeconds)
|
||||
val series = db.tasks().insert(TaskEntity(listId = list, uid = "s", title = "Weekly", dtstart = at, rrule = "FREQ=WEEKLY"))
|
||||
RoomTasksDataSource(db).setCompletedInstance(series, at, true)
|
||||
val copy = db.tasks().allIn(list).single { it.id != series }
|
||||
db.tasks().update(copy.copy(href = "copy.ics"))
|
||||
|
||||
RoomSyncStore(db).dropAdvances(series)
|
||||
|
||||
assertThat(db.advancedOccurrences().forMaster(series)).isEmpty()
|
||||
assertThat(db.tasks().entity(copy.id)!!.isDeleted).isTrue()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun movesTheServerAlreadyHasStay() {
|
||||
val list = db.taskLists().insert(TaskListEntity(name = "Home", color = 0))
|
||||
val at = Instant.fromEpochSeconds(Clock.System.now().epochSeconds)
|
||||
val series = db.tasks().insert(TaskEntity(listId = list, uid = "s", title = "Weekly", dtstart = at, rrule = "FREQ=WEEKLY"))
|
||||
RoomTasksDataSource(db).setCompletedInstance(series, at, true)
|
||||
val copy = db.tasks().allIn(list).single { it.id != series }
|
||||
val store = RoomSyncStore(db)
|
||||
store.markSynced(listOf(db.tasks().entity(series)!!), "s.ics", "1")
|
||||
|
||||
store.dropAdvances(series)
|
||||
|
||||
assertThat(db.tasks().entity(copy.id)!!.isDeleted).isFalse()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aCopyGivenASubtaskSurvivesTheServerWinning() {
|
||||
val list = db.taskLists().insert(TaskListEntity(name = "Home", color = 0))
|
||||
val at = Instant.fromEpochSeconds(Clock.System.now().epochSeconds)
|
||||
val series = db.tasks().insert(TaskEntity(listId = list, uid = "s", title = "Weekly", dtstart = at, rrule = "FREQ=WEEKLY"))
|
||||
RoomTasksDataSource(db).setCompletedInstance(series, at, true)
|
||||
val copy = db.tasks().allIn(list).single { it.id != series }
|
||||
db.tasks().insert(TaskEntity(listId = list, uid = "p", title = "Part", parentId = copy.id))
|
||||
|
||||
RoomSyncStore(db).dropAdvances(series)
|
||||
|
||||
assertThat(db.tasks().entity(copy.id)).isNotNull()
|
||||
assertThat(db.tasks().entity(copy.id)!!.isDeleted).isFalse()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aTickDuringTheUploadIsNotSettled() {
|
||||
val list = db.taskLists().insert(TaskListEntity(name = "Home", color = 0))
|
||||
val at = Instant.fromEpochSeconds(Clock.System.now().epochSeconds)
|
||||
val series = db.tasks().insert(
|
||||
TaskEntity(listId = list, uid = "s", title = "Weekly", dtstart = at, rrule = "FREQ=WEEKLY", lastModified = at - 1.seconds),
|
||||
)
|
||||
val uploaded = db.tasks().entity(series)!!
|
||||
RoomTasksDataSource(db).setCompletedInstance(series, at, true)
|
||||
val store = RoomSyncStore(db)
|
||||
|
||||
store.markSynced(listOf(uploaded), "s.ics", "1")
|
||||
|
||||
assertThat(db.tasks().entity(series)!!.isDirty).isTrue()
|
||||
assertThat(db.advancedOccurrences().forMaster(series).single().settled).isFalse()
|
||||
}
|
||||
}
|
||||
@@ -13,13 +13,10 @@ import dagger.hilt.components.SingletonComponent
|
||||
import dagger.multibindings.IntoSet
|
||||
import de.jeanlucmakiola.agendula.data.sync.AccountCreator
|
||||
import de.jeanlucmakiola.agendula.data.sync.AccountRepository
|
||||
import de.jeanlucmakiola.agendula.data.sync.AccountSyncRequests
|
||||
import de.jeanlucmakiola.agendula.data.sync.CalDavGateway
|
||||
import de.jeanlucmakiola.agendula.data.sync.LoginFlowRecord
|
||||
import de.jeanlucmakiola.agendula.data.sync.ManualSync
|
||||
import de.jeanlucmakiola.agendula.data.sync.OkHttpCalDavGateway
|
||||
import de.jeanlucmakiola.agendula.data.sync.PendingLoginFlowStore
|
||||
import de.jeanlucmakiola.agendula.data.sync.PullSync
|
||||
import de.jeanlucmakiola.agendula.data.sync.RemoteListRepository
|
||||
import de.jeanlucmakiola.agendula.data.sync.RemoteLists
|
||||
import de.jeanlucmakiola.agendula.data.sync.SyncNoticeNotifier
|
||||
@@ -82,11 +79,7 @@ abstract class SyncBindModule {
|
||||
|
||||
@Binds
|
||||
@Singleton
|
||||
abstract fun bindSyncRequests(impl: AccountSyncRequests): SyncRequests
|
||||
|
||||
@Binds
|
||||
@Singleton
|
||||
abstract fun bindManualSync(impl: PullSync): ManualSync
|
||||
abstract fun bindSyncRequests(impl: SyncTrigger): SyncRequests
|
||||
|
||||
@Binds
|
||||
@IntoSet
|
||||
|
||||
@@ -7,7 +7,6 @@ import de.jeanlucmakiola.agendula.data.tasks.room.AccountEntity
|
||||
import de.jeanlucmakiola.agendula.data.tasks.room.TaskListEntity
|
||||
import de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase
|
||||
import de.jeanlucmakiola.caldav.CalDavDiscovery
|
||||
import de.jeanlucmakiola.caldav.ServerTrust
|
||||
import de.jeanlucmakiola.caldav.TaskCollection
|
||||
import kotlinx.coroutines.CancellationException
|
||||
import kotlinx.coroutines.CoroutineDispatcher
|
||||
@@ -17,7 +16,6 @@ import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.withContext
|
||||
import okhttp3.HttpUrl
|
||||
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
|
||||
import java.io.IOException
|
||||
import javax.inject.Inject
|
||||
import javax.inject.Singleton
|
||||
|
||||
@@ -37,12 +35,7 @@ interface AccountCreator {
|
||||
selected: Set<TaskCollection>,
|
||||
/** An existing account to sign in again, instead of creating one. */
|
||||
reauthenticating: Long? = null,
|
||||
/** What the user agreed to trust on the way here; saved with the account. */
|
||||
trust: ServerTrust = ServerTrust.DEFAULT,
|
||||
): AccountRepository.Outcome
|
||||
|
||||
/** What [accountId] was set up trusting, so signing in again starts from it. */
|
||||
suspend fun trustFor(accountId: Long): ServerTrust
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -66,7 +59,6 @@ class AccountRepository @Inject constructor(
|
||||
private val quarantine: QuarantineStore,
|
||||
private val notices: SyncNoticeStore,
|
||||
private val collectionSupport: CollectionSupportStore,
|
||||
private val serverTrust: ServerTrustStore,
|
||||
private val gateway: CalDavGateway,
|
||||
private val availability: SyncAvailability,
|
||||
private val settings: SettingsPrefs,
|
||||
@@ -105,11 +97,6 @@ class AccountRepository @Inject constructor(
|
||||
/** The accounts, observed, so a sync landing updates a screen that is open. */
|
||||
fun observeAll(): Flow<List<AccountEntity>> = database.accounts().observeAll()
|
||||
|
||||
/** Names the account on screen; blank goes back to the default (#105). */
|
||||
suspend fun setLabel(accountId: Long, label: String) = withContext(io) {
|
||||
database.accounts().setLabel(accountId, label.trim().ifEmpty { null })
|
||||
}
|
||||
|
||||
/** Every account's synced lists. */
|
||||
fun observeSyncedLists(): Flow<List<TaskListEntity>> = database.taskLists().observeSynced()
|
||||
|
||||
@@ -128,7 +115,6 @@ class AccountRepository @Inject constructor(
|
||||
found: CalDavDiscovery.Outcome.Found,
|
||||
selected: Set<TaskCollection>,
|
||||
reauthenticating: Long?,
|
||||
trust: ServerTrust,
|
||||
): Outcome = withContext(io) {
|
||||
if (!availability.accountsUsable()) return@withContext Outcome.ExternalStorage
|
||||
// "Sign in again" names its account, so a login name the server spells
|
||||
@@ -136,7 +122,7 @@ class AccountRepository @Inject constructor(
|
||||
// Only on the same server: anything else is a different account.
|
||||
val target = reauthenticating?.let { database.accounts().account(it) }
|
||||
if (target != null && sameServer(target, found)) {
|
||||
return@withContext reauthenticate(target, target.displayName, username, appPassword, found, selected, trust)
|
||||
return@withContext reauthenticate(target, target.displayName, username, appPassword, found, selected)
|
||||
}
|
||||
// Both stores, not just one. There is no unique index on
|
||||
// accounts.display_name and nothing prunes Room when the system account
|
||||
@@ -153,7 +139,7 @@ class AccountRepository @Inject constructor(
|
||||
// same name is still a duplicate, so this can never silently overwrite a
|
||||
// working credential.
|
||||
if (existing != null && accountState.needsSignIn(existing.id)) {
|
||||
return@withContext reauthenticate(existing, displayName, username, appPassword, found, selected, trust)
|
||||
return@withContext reauthenticate(existing, displayName, username, appPassword, found, selected)
|
||||
}
|
||||
|
||||
if (existing != null) return@withContext Outcome.AlreadyExists
|
||||
@@ -194,15 +180,6 @@ class AccountRepository @Inject constructor(
|
||||
inserted += attach(id, selected)
|
||||
id
|
||||
}
|
||||
// Inside the rollback's reach: a DataStore failure here would otherwise
|
||||
// leave the row with no credential, the hazard the comment above names.
|
||||
if (!saveTrust(accountId, trust)) {
|
||||
rollback(accountId, inserted)
|
||||
return@withContext Outcome.CredentialFailed(
|
||||
Outcome.Cause.NOT_SAVED,
|
||||
"the server trust could not be stored",
|
||||
)
|
||||
}
|
||||
|
||||
if (!credentials.put(accountId, appPassword)) {
|
||||
// Never leave a half-made account behind: without a credential it
|
||||
@@ -230,8 +207,6 @@ class AccountRepository @Inject constructor(
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun trustFor(accountId: Long): ServerTrust = serverTrust.get(accountId)
|
||||
|
||||
/**
|
||||
* Points [selected] at [accountId], re-attaching what a previous removal
|
||||
* left behind rather than inserting a second copy.
|
||||
@@ -323,7 +298,6 @@ class AccountRepository @Inject constructor(
|
||||
val outcome = gateway.discover(
|
||||
principal.toString(),
|
||||
CalDavGateway.Credentials(username, password, principal),
|
||||
serverTrust.get(accountId),
|
||||
)
|
||||
) {
|
||||
is CalDavDiscovery.Outcome.Found -> Collections.Found(outcome.collections, attached)
|
||||
@@ -332,10 +306,6 @@ class AccountRepository @Inject constructor(
|
||||
-> Collections.NeedsSignIn
|
||||
is CalDavDiscovery.Outcome.NotCalDav -> Collections.Failed(outcome.cause)
|
||||
is CalDavDiscovery.Outcome.Failed -> Collections.Failed(outcome.cause)
|
||||
// A certificate that changed since it was trusted. The account offers
|
||||
// "Sign in again" for a certificate failure, and that flow re-asks.
|
||||
is CalDavDiscovery.Outcome.UntrustedCertificate ->
|
||||
Collections.Failed(CalDavDiscovery.Outcome.Cause.TLS)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -416,7 +386,6 @@ class AccountRepository @Inject constructor(
|
||||
appPassword: String,
|
||||
found: CalDavDiscovery.Outcome.Found,
|
||||
selected: Set<TaskCollection>,
|
||||
trust: ServerTrust,
|
||||
): Outcome {
|
||||
val accountId = existing.id
|
||||
if (!credentials.put(accountId, appPassword)) {
|
||||
@@ -425,11 +394,6 @@ class AccountRepository @Inject constructor(
|
||||
"the device keystore would not store the password",
|
||||
)
|
||||
}
|
||||
// Before anything else changes, so a failure leaves the account stopped
|
||||
// and the sign-in retryable rather than signed in with the old trust.
|
||||
if (!withContext(NonCancellable) { saveTrust(accountId, trust) }) {
|
||||
return Outcome.CredentialFailed(Outcome.Cause.NOT_SAVED, "the server trust could not be stored")
|
||||
}
|
||||
withContext(NonCancellable) {
|
||||
database.runInTransaction {
|
||||
database.accounts().update(
|
||||
@@ -473,23 +437,11 @@ class AccountRepository @Inject constructor(
|
||||
* and holds the user's tasks; `SET NULL` returns it to being device-only,
|
||||
* which is exactly where it came from.
|
||||
*/
|
||||
private suspend fun rollback(accountId: Long, inserted: List<Long>) {
|
||||
database.runInTransaction {
|
||||
inserted.forEach { database.taskLists().delete(it) }
|
||||
database.accounts().delete(accountId)
|
||||
}
|
||||
// Ids are never reused, and a later create overwrites the keys anyway.
|
||||
runCatching { serverTrust.forget(accountId) }
|
||||
private fun rollback(accountId: Long, inserted: List<Long>) = database.runInTransaction {
|
||||
inserted.forEach { database.taskLists().delete(it) }
|
||||
database.accounts().delete(accountId)
|
||||
}
|
||||
|
||||
private suspend fun saveTrust(accountId: Long, trust: ServerTrust): Boolean =
|
||||
try {
|
||||
serverTrust.put(accountId, trust)
|
||||
true
|
||||
} catch (_: IOException) {
|
||||
false
|
||||
}
|
||||
|
||||
/**
|
||||
* Puts every existing account back on the periodic schedule.
|
||||
*
|
||||
@@ -578,7 +530,6 @@ class AccountRepository @Inject constructor(
|
||||
// The same reasoning, for what the server said it would let us
|
||||
// create: keyed by an id nothing will ever mention again.
|
||||
collectionSupport.forget(accountId)
|
||||
serverTrust.forget(accountId)
|
||||
credentials.clear(accountId)
|
||||
database.accounts().delete(accountId)
|
||||
accounts.find(displayName)?.let { accounts.remove(it) }
|
||||
@@ -606,7 +557,6 @@ class AccountRepository @Inject constructor(
|
||||
try {
|
||||
gateway.revokeAppPassword(
|
||||
CalDavGateway.Credentials(username, password, origin),
|
||||
serverTrust.get(accountId),
|
||||
)
|
||||
} catch (_: CancellationException) {
|
||||
// Deliberately swallowed. If the caller went away mid-revoke we still
|
||||
|
||||
@@ -1,20 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.data.sync
|
||||
|
||||
import de.jeanlucmakiola.agendula.data.di.IoDispatcher
|
||||
import de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase
|
||||
import kotlinx.coroutines.CoroutineDispatcher
|
||||
import kotlinx.coroutines.withContext
|
||||
import javax.inject.Inject
|
||||
|
||||
/** [SyncRequests] by account id; [SyncTrigger] keys on the account's stable display name. */
|
||||
class AccountSyncRequests @Inject constructor(
|
||||
private val database: TasksDatabase,
|
||||
private val trigger: SyncTrigger,
|
||||
@IoDispatcher private val io: CoroutineDispatcher,
|
||||
) : SyncRequests {
|
||||
|
||||
override suspend fun syncNow(accountId: Long) {
|
||||
val name = withContext(io) { database.accounts().account(accountId)?.displayName } ?: return
|
||||
trigger.enqueue(name)
|
||||
}
|
||||
}
|
||||
@@ -5,7 +5,6 @@ import de.jeanlucmakiola.caldav.AppPassword
|
||||
import de.jeanlucmakiola.caldav.CalDavDiscovery
|
||||
import de.jeanlucmakiola.caldav.CalDavHttp
|
||||
import de.jeanlucmakiola.caldav.NextcloudLoginFlow
|
||||
import de.jeanlucmakiola.caldav.ServerTrust
|
||||
import kotlinx.coroutines.CoroutineDispatcher
|
||||
import kotlinx.coroutines.job
|
||||
import kotlinx.coroutines.withContext
|
||||
@@ -26,22 +25,12 @@ import javax.inject.Singleton
|
||||
interface CalDavGateway {
|
||||
|
||||
/** Discovery against [target], optionally carrying credentials. */
|
||||
suspend fun discover(
|
||||
target: String,
|
||||
credentials: Credentials? = null,
|
||||
trust: ServerTrust = ServerTrust.DEFAULT,
|
||||
): CalDavDiscovery.Outcome
|
||||
suspend fun discover(target: String, credentials: Credentials? = null): CalDavDiscovery.Outcome
|
||||
|
||||
/** Starts Nextcloud Login Flow v2, or returns null if this is not a Nextcloud. */
|
||||
suspend fun startLoginFlow(
|
||||
server: HttpUrl,
|
||||
trust: ServerTrust = ServerTrust.DEFAULT,
|
||||
): NextcloudLoginFlow.Flow?
|
||||
suspend fun startLoginFlow(server: HttpUrl): NextcloudLoginFlow.Flow?
|
||||
|
||||
suspend fun pollLoginFlow(
|
||||
flow: NextcloudLoginFlow.Flow,
|
||||
trust: ServerTrust = ServerTrust.DEFAULT,
|
||||
): NextcloudLoginFlow.PollResult
|
||||
suspend fun pollLoginFlow(flow: NextcloudLoginFlow.Flow): NextcloudLoginFlow.PollResult
|
||||
|
||||
/**
|
||||
* Hands an app password back to the server, best effort.
|
||||
@@ -49,10 +38,7 @@ interface CalDavGateway {
|
||||
* Without it, uninstalling never revokes anything — the credential we minted
|
||||
* outlives the app in the user's device list.
|
||||
*/
|
||||
suspend fun revokeAppPassword(
|
||||
credentials: Credentials,
|
||||
trust: ServerTrust = ServerTrust.DEFAULT,
|
||||
): Boolean
|
||||
suspend fun revokeAppPassword(credentials: Credentials): Boolean
|
||||
|
||||
/**
|
||||
* The same, for a password the login flow just minted.
|
||||
@@ -63,10 +49,7 @@ interface CalDavGateway {
|
||||
* principal, and a subpath install's `https://host/nextcloud/` would collapse
|
||||
* to `https://host/` — a DELETE that 404s on every one of them.
|
||||
*/
|
||||
suspend fun revokeIssuedAppPassword(
|
||||
credentials: Credentials,
|
||||
trust: ServerTrust = ServerTrust.DEFAULT,
|
||||
): Boolean
|
||||
suspend fun revokeIssuedAppPassword(credentials: Credentials): Boolean
|
||||
|
||||
/** Credentials, and the origin whose registrable domain they are scoped to. */
|
||||
data class Credentials(val username: String, val password: String, val origin: HttpUrl)
|
||||
@@ -88,19 +71,17 @@ class OkHttpCalDavGateway @Inject constructor(
|
||||
override suspend fun discover(
|
||||
target: String,
|
||||
credentials: CalDavGateway.Credentials?,
|
||||
trust: ServerTrust,
|
||||
): CalDavDiscovery.Outcome = withContext(io) {
|
||||
val client = credentials?.let {
|
||||
CalDavHttp.authenticated(userAgent, it.username, it.password, it.origin, trust)
|
||||
} ?: CalDavHttp.anonymous(userAgent, trust)
|
||||
CalDavHttp.authenticated(userAgent, it.username, it.password, it.origin)
|
||||
} ?: CalDavHttp.anonymous(userAgent)
|
||||
val job = coroutineContext.job
|
||||
CalDavDiscovery(client, SystemDnsResolver { !job.isActive }, allowCleartext = trust.allowCleartext)
|
||||
.discover(target)
|
||||
CalDavDiscovery(client, SystemDnsResolver { !job.isActive }).discover(target)
|
||||
}
|
||||
|
||||
override suspend fun startLoginFlow(server: HttpUrl, trust: ServerTrust): NextcloudLoginFlow.Flow? =
|
||||
override suspend fun startLoginFlow(server: HttpUrl): NextcloudLoginFlow.Flow? =
|
||||
withContext(io) {
|
||||
NextcloudLoginFlow(CalDavHttp.anonymous(userAgent, trust), userAgent)
|
||||
NextcloudLoginFlow(CalDavHttp.anonymous(userAgent), userAgent)
|
||||
.start(server, now())
|
||||
.getOrNull()
|
||||
}
|
||||
@@ -112,12 +93,9 @@ class OkHttpCalDavGateway @Inject constructor(
|
||||
* the shared client's ceiling is sized for a multiget, not for a two-second
|
||||
* poll loop against a server that answered a moment ago.
|
||||
*/
|
||||
override suspend fun pollLoginFlow(
|
||||
flow: NextcloudLoginFlow.Flow,
|
||||
trust: ServerTrust,
|
||||
): NextcloudLoginFlow.PollResult =
|
||||
override suspend fun pollLoginFlow(flow: NextcloudLoginFlow.Flow): NextcloudLoginFlow.PollResult =
|
||||
withContext(io) {
|
||||
val client = CalDavHttp.anonymous(userAgent, trust).newBuilder()
|
||||
val client = CalDavHttp.anonymous(userAgent).newBuilder()
|
||||
.callTimeout(POLL_TIMEOUT_SECONDS, TimeUnit.SECONDS)
|
||||
.build()
|
||||
NextcloudLoginFlow(client, userAgent).poll(flow, now())
|
||||
@@ -125,20 +103,18 @@ class OkHttpCalDavGateway @Inject constructor(
|
||||
|
||||
override suspend fun revokeAppPassword(
|
||||
credentials: CalDavGateway.Credentials,
|
||||
trust: ServerTrust,
|
||||
): Boolean = withContext(io) {
|
||||
val client = CalDavHttp.authenticated(
|
||||
userAgent, credentials.username, credentials.password, credentials.origin, trust,
|
||||
userAgent, credentials.username, credentials.password, credentials.origin,
|
||||
)
|
||||
AppPassword.revoke(client, credentials.origin)
|
||||
}
|
||||
|
||||
override suspend fun revokeIssuedAppPassword(
|
||||
credentials: CalDavGateway.Credentials,
|
||||
trust: ServerTrust,
|
||||
): Boolean = withContext(io) {
|
||||
val client = CalDavHttp.authenticated(
|
||||
userAgent, credentials.username, credentials.password, credentials.origin, trust,
|
||||
userAgent, credentials.username, credentials.password, credentials.origin,
|
||||
)
|
||||
AppPassword.revokeAt(client, credentials.origin)
|
||||
}
|
||||
|
||||
@@ -609,7 +609,7 @@ class CollectionSyncer(
|
||||
// via `master_id`.
|
||||
val (buried, kept) = local.rows.partition { it.isDeleted && it.recurrenceId != null }
|
||||
if (buried.isNotEmpty()) store.deleteAll(buried.map { it.id })
|
||||
store.markSynced(kept, key, eTag)
|
||||
store.markSynced(kept.map { it.id }, key, eTag)
|
||||
// Both, because a resource that failed as a create was counted under
|
||||
// its UID and is now counted under its href. Clearing one would leak
|
||||
// the other into the store forever.
|
||||
@@ -825,7 +825,6 @@ class CollectionSyncer(
|
||||
}
|
||||
|
||||
pendingDiscard.remove(href)?.let { cause ->
|
||||
store.dropAdvances(masterId)
|
||||
report = report.copy(
|
||||
discardedEdits = report.discardedEdits +
|
||||
DiscardedEdit(uid, losing?.title, cause),
|
||||
|
||||
@@ -7,7 +7,6 @@ import androidx.datastore.preferences.core.longPreferencesKey
|
||||
import androidx.datastore.preferences.core.stringPreferencesKey
|
||||
import de.jeanlucmakiola.agendula.data.di.SyncStateDataStore
|
||||
import de.jeanlucmakiola.caldav.NextcloudLoginFlow
|
||||
import de.jeanlucmakiola.caldav.ServerTrust
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.sync.Mutex
|
||||
import kotlinx.coroutines.sync.withLock
|
||||
@@ -24,8 +23,8 @@ import javax.inject.Singleton
|
||||
*/
|
||||
interface LoginFlowRecord {
|
||||
|
||||
/** Called **before** the browser is handed the URL; [trust] is what reaching it took. */
|
||||
suspend fun remember(flow: NextcloudLoginFlow.Flow, trust: ServerTrust = ServerTrust.DEFAULT)
|
||||
/** Called **before** the browser is handed the URL. */
|
||||
suspend fun remember(flow: NextcloudLoginFlow.Flow)
|
||||
|
||||
/** The flow is over, however it ended. */
|
||||
suspend fun forget()
|
||||
@@ -59,13 +58,12 @@ class PendingLoginFlowStore @Inject constructor(
|
||||
private var reclaimed = false
|
||||
|
||||
/** Records [flow] so a process that dies mid-approval can still finish with it. */
|
||||
override suspend fun remember(flow: NextcloudLoginFlow.Flow, trust: ServerTrust) {
|
||||
override suspend fun remember(flow: NextcloudLoginFlow.Flow) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[LOGIN_URL] = flow.loginUrl.toString()
|
||||
prefs[POLL_ENDPOINT] = flow.pollEndpoint.toString()
|
||||
prefs[POLL_TOKEN] = flow.pollToken
|
||||
prefs[DEADLINE] = flow.deadlineEpochSeconds
|
||||
TRUST.write(prefs, trust)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -76,7 +74,6 @@ class PendingLoginFlowStore @Inject constructor(
|
||||
prefs.remove(POLL_ENDPOINT)
|
||||
prefs.remove(POLL_TOKEN)
|
||||
prefs.remove(DEADLINE)
|
||||
TRUST.remove(prefs)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -101,8 +98,7 @@ class PendingLoginFlowStore @Inject constructor(
|
||||
reclaimed = true
|
||||
}
|
||||
val flow = pending() ?: return
|
||||
val trust = trust()
|
||||
when (val result = gateway.pollLoginFlow(flow, trust)) {
|
||||
when (val result = gateway.pollLoginFlow(flow)) {
|
||||
is NextcloudLoginFlow.PollResult.Approved -> {
|
||||
// Cleared first: a revocation that fails must not leave a token
|
||||
// that would be polled again, and the 200 is already spent.
|
||||
@@ -113,7 +109,6 @@ class PendingLoginFlowStore @Inject constructor(
|
||||
password = result.credentials.appPassword,
|
||||
origin = result.credentials.server,
|
||||
),
|
||||
trust,
|
||||
)
|
||||
}
|
||||
|
||||
@@ -141,13 +136,10 @@ class PendingLoginFlowStore @Inject constructor(
|
||||
)
|
||||
}
|
||||
|
||||
private suspend fun trust(): ServerTrust = TRUST.read(dataStore.data.first())
|
||||
|
||||
private companion object {
|
||||
val LOGIN_URL = stringPreferencesKey("login_flow_url")
|
||||
val POLL_ENDPOINT = stringPreferencesKey("login_flow_poll_endpoint")
|
||||
val POLL_TOKEN = stringPreferencesKey("login_flow_poll_token")
|
||||
val DEADLINE = longPreferencesKey("login_flow_deadline")
|
||||
val TRUST = ServerTrustKeys("login_flow_trusted_certificates", "login_flow_cleartext")
|
||||
}
|
||||
}
|
||||
@@ -1,76 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.data.sync
|
||||
|
||||
import android.content.Context
|
||||
import androidx.work.WorkInfo
|
||||
import androidx.work.WorkManager
|
||||
import dagger.hilt.android.qualifiers.ApplicationContext
|
||||
import de.jeanlucmakiola.agendula.data.di.ApplicationScope
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import kotlinx.coroutines.flow.StateFlow
|
||||
import kotlinx.coroutines.flow.combine
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.flow.map
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.withTimeoutOrNull
|
||||
import javax.inject.Inject
|
||||
import javax.inject.Singleton
|
||||
import kotlin.time.Duration.Companion.minutes
|
||||
import kotlin.time.Duration.Companion.seconds
|
||||
|
||||
/**
|
||||
* Pull to sync over [SyncTrigger]: an expedited sync per account, and
|
||||
* [syncing] held until they finish.
|
||||
*
|
||||
* A sync waiting on its network constraint never starts, so if none is running
|
||||
* after [START_GRACE] the indicator lets go; the work stays queued and runs
|
||||
* once the device is back online.
|
||||
*/
|
||||
@Singleton
|
||||
class PullSync @Inject constructor(
|
||||
@ApplicationContext private val context: Context,
|
||||
private val accounts: AccountRepository,
|
||||
private val trigger: SyncTrigger,
|
||||
availability: SyncAvailability,
|
||||
@ApplicationScope private val scope: CoroutineScope,
|
||||
) : ManualSync {
|
||||
|
||||
override val available: Flow<Boolean> =
|
||||
combine(availability.observe(), accounts.observeAll()) { usable, all -> usable && all.isNotEmpty() }
|
||||
|
||||
private val _syncing = MutableStateFlow(false)
|
||||
override val syncing: StateFlow<Boolean> = _syncing
|
||||
|
||||
override fun syncAll() {
|
||||
if (_syncing.value) return
|
||||
_syncing.value = true
|
||||
scope.launch {
|
||||
try {
|
||||
val names = accounts.syncable().map { trigger.enqueue(it.displayName, expedited = true) }
|
||||
if (names.isNotEmpty()) awaitSyncs(names)
|
||||
} finally {
|
||||
_syncing.value = false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun awaitSyncs(names: List<String>) {
|
||||
val workManager = WorkManager.getInstance(context)
|
||||
val states = combine(names.map { workManager.getWorkInfosForUniqueWorkFlow(it) }) { infos ->
|
||||
infos.flatMap { it }.map { it.state }
|
||||
}
|
||||
withTimeoutOrNull(MAX_WAIT) {
|
||||
val started = withTimeoutOrNull(START_GRACE) {
|
||||
states.first { all -> WorkInfo.State.RUNNING in all || all.all { it.isFinished } }
|
||||
} ?: return@withTimeoutOrNull
|
||||
if (started.all { it.isFinished }) return@withTimeoutOrNull
|
||||
states.map { all -> WorkInfo.State.RUNNING in all }.first { running -> !running }
|
||||
}
|
||||
}
|
||||
|
||||
private companion object {
|
||||
val START_GRACE = 3.seconds
|
||||
val MAX_WAIT = 2.minutes
|
||||
}
|
||||
}
|
||||
@@ -14,7 +14,6 @@ import de.jeanlucmakiola.caldav.CollectionOutcome
|
||||
import de.jeanlucmakiola.caldav.CollectionSupport
|
||||
import de.jeanlucmakiola.caldav.DavCollectionAdmin
|
||||
import de.jeanlucmakiola.caldav.ResourceNames
|
||||
import de.jeanlucmakiola.caldav.ServerTrust
|
||||
import kotlinx.coroutines.CoroutineDispatcher
|
||||
import kotlinx.coroutines.NonCancellable
|
||||
import kotlinx.coroutines.async
|
||||
@@ -54,7 +53,6 @@ class RemoteListRepository @Inject constructor(
|
||||
private val accountState: AccountStateStore,
|
||||
private val resolver: ProviderResolver,
|
||||
private val push: PushStore,
|
||||
private val trust: ServerTrustStore,
|
||||
@IoDispatcher private val io: CoroutineDispatcher,
|
||||
) : RemoteLists {
|
||||
|
||||
@@ -254,11 +252,11 @@ class RemoteListRepository @Inject constructor(
|
||||
val origin = account.principalUrl?.toHttpUrlOrNull() ?: return null
|
||||
val password = (credentials.get(account.id) as? CredentialStore.Secret.Present)?.value
|
||||
?: return null
|
||||
return DavCollectionAdmin(client(username, password, origin, trust.get(account.id)))
|
||||
return DavCollectionAdmin(client(username, password, origin))
|
||||
}
|
||||
|
||||
private fun client(username: String, password: String, origin: HttpUrl, trust: ServerTrust): OkHttpClient =
|
||||
CalDavHttp.authenticated(USER_AGENT, username, password, origin, trust)
|
||||
private fun client(username: String, password: String, origin: HttpUrl): OkHttpClient =
|
||||
CalDavHttp.authenticated(USER_AGENT, username, password, origin)
|
||||
|
||||
private suspend fun forgetPerListState(listId: Long) {
|
||||
val ids = setOf(listId)
|
||||
|
||||
@@ -1,44 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.data.sync
|
||||
|
||||
import androidx.datastore.preferences.core.MutablePreferences
|
||||
import androidx.datastore.preferences.core.Preferences
|
||||
import androidx.datastore.preferences.core.booleanPreferencesKey
|
||||
import androidx.datastore.preferences.core.stringSetPreferencesKey
|
||||
import androidx.lifecycle.SavedStateHandle
|
||||
import de.jeanlucmakiola.caldav.ServerTrust
|
||||
|
||||
/**
|
||||
* The one mapping between a [ServerTrust] and the key-value stores it is kept
|
||||
* in, so a field added to it cannot be dropped by one of them.
|
||||
*/
|
||||
class ServerTrustKeys(private val certificatesName: String, private val cleartextName: String) {
|
||||
|
||||
private val certificates = stringSetPreferencesKey(certificatesName)
|
||||
private val cleartext = booleanPreferencesKey(cleartextName)
|
||||
|
||||
fun read(prefs: Preferences) = ServerTrust(
|
||||
pinnedCertificates = prefs[certificates].orEmpty(),
|
||||
allowCleartext = prefs[cleartext] ?: false,
|
||||
)
|
||||
|
||||
fun write(prefs: MutablePreferences, trust: ServerTrust) {
|
||||
if (trust.pinnedCertificates.isEmpty()) {
|
||||
prefs.remove(certificates)
|
||||
} else {
|
||||
prefs[certificates] = trust.pinnedCertificates
|
||||
}
|
||||
if (trust.allowCleartext) prefs[cleartext] = true else prefs.remove(cleartext)
|
||||
}
|
||||
|
||||
fun remove(prefs: MutablePreferences) = write(prefs, ServerTrust.DEFAULT)
|
||||
|
||||
fun read(handle: SavedStateHandle) = ServerTrust(
|
||||
pinnedCertificates = handle.get<ArrayList<String>>(certificatesName).orEmpty().toSet(),
|
||||
allowCleartext = handle[cleartextName] ?: false,
|
||||
)
|
||||
|
||||
fun write(handle: SavedStateHandle, trust: ServerTrust) {
|
||||
handle[certificatesName] = ArrayList(trust.pinnedCertificates)
|
||||
handle[cleartextName] = trust.allowCleartext
|
||||
}
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.data.sync
|
||||
|
||||
import androidx.datastore.core.DataStore
|
||||
import androidx.datastore.preferences.core.Preferences
|
||||
import androidx.datastore.preferences.core.edit
|
||||
import de.jeanlucmakiola.agendula.data.di.SyncStateDataStore
|
||||
import de.jeanlucmakiola.caldav.ServerTrust
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.distinctUntilChanged
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.flow.map
|
||||
import javax.inject.Inject
|
||||
import javax.inject.Singleton
|
||||
|
||||
/** What each account's user agreed to trust: pinned certificates and plain http. */
|
||||
@Singleton
|
||||
class ServerTrustStore @Inject constructor(
|
||||
@SyncStateDataStore private val dataStore: DataStore<Preferences>,
|
||||
) {
|
||||
|
||||
suspend fun get(accountId: Long): ServerTrust = read(dataStore.data.first(), accountId)
|
||||
|
||||
fun observe(accountId: Long): Flow<ServerTrust> =
|
||||
dataStore.data.map { read(it, accountId) }.distinctUntilChanged()
|
||||
|
||||
suspend fun put(accountId: Long, trust: ServerTrust) {
|
||||
dataStore.edit { keys(accountId).write(it, trust) }
|
||||
}
|
||||
|
||||
suspend fun forget(accountId: Long) {
|
||||
dataStore.edit { keys(accountId).remove(it) }
|
||||
}
|
||||
|
||||
private fun read(prefs: Preferences, accountId: Long) = keys(accountId).read(prefs)
|
||||
|
||||
private fun keys(accountId: Long) =
|
||||
ServerTrustKeys("server_trust_certs_$accountId", "server_trust_cleartext_$accountId")
|
||||
}
|
||||
@@ -33,7 +33,6 @@ class SyncEngine @Inject constructor(
|
||||
private val notices: SyncNoticeStore,
|
||||
private val availability: SyncAvailability,
|
||||
private val push: PushRegistrar,
|
||||
private val trust: ServerTrustStore,
|
||||
@IoDispatcher private val io: CoroutineDispatcher,
|
||||
) {
|
||||
|
||||
@@ -91,7 +90,7 @@ class SyncEngine @Inject constructor(
|
||||
}
|
||||
}
|
||||
|
||||
val client = CalDavHttp.authenticated(USER_AGENT, username, password, origin, trust.get(account.id))
|
||||
val client = CalDavHttp.authenticated(USER_AGENT, username, password, origin)
|
||||
val subscriptions = push.subscriptionsByHref(account.id)
|
||||
val reports = syncCollections(account) { url ->
|
||||
CalendarCollection(client, url, pushRegistration = subscriptions[url.toString()])
|
||||
|
||||
@@ -49,7 +49,6 @@ data class SyncFailure(val kind: Kind, val httpCode: Int? = null) {
|
||||
private val TLS = listOf(
|
||||
"SSLHandshakeException",
|
||||
"SSLPeerUnverifiedException",
|
||||
"UntrustedHostException",
|
||||
"CertPathValidatorException",
|
||||
"CertificateException",
|
||||
"SSLException",
|
||||
|
||||
@@ -3,9 +3,6 @@ package de.jeanlucmakiola.agendula.data.sync
|
||||
import de.jeanlucmakiola.agendula.data.tasks.room.TaskAlarmEntity
|
||||
import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
|
||||
import de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase
|
||||
import de.jeanlucmakiola.agendula.data.tasks.room.recurrenceAnchor
|
||||
import de.jeanlucmakiola.agendula.data.tasks.wholeSecond
|
||||
import kotlin.time.Duration.Companion.seconds
|
||||
import javax.inject.Inject
|
||||
|
||||
/**
|
||||
@@ -45,21 +42,12 @@ interface SyncStore {
|
||||
fun deleteAll(taskIds: List<Long>)
|
||||
|
||||
/**
|
||||
* Forgets how ticking occurrences moved [masterId]'s series, and deletes the
|
||||
* copies that left: the server's version replaced the moved series, and its
|
||||
* own overrides stand for those occurrences again. A row given a life of its
|
||||
* own since stays.
|
||||
*/
|
||||
fun dropAdvances(masterId: Long) = Unit
|
||||
|
||||
/**
|
||||
* Records href and ETag on a resource's [rows], as they were serialised,
|
||||
* clearing `is_dirty` on those that did not change since.
|
||||
* Records href and ETag on a resource's rows, clearing `is_dirty`.
|
||||
*
|
||||
* The caller excludes any row it left out of the body — that row is deleted,
|
||||
* not marked synced.
|
||||
*/
|
||||
fun markSynced(rows: List<TaskEntity>, href: String?, eTag: String?)
|
||||
fun markSynced(taskIds: List<Long>, href: String?, eTag: String?)
|
||||
|
||||
fun setParent(taskId: Long, parentId: Long?)
|
||||
|
||||
@@ -109,42 +97,8 @@ class RoomSyncStore @Inject constructor(
|
||||
if (taskIds.isNotEmpty()) database.tasks().deleteAll(taskIds)
|
||||
}
|
||||
|
||||
override fun dropAdvances(masterId: Long) = database.runInTransaction {
|
||||
val advanced = database.advancedOccurrences()
|
||||
val tasks = database.tasks()
|
||||
val master = tasks.entity(masterId)
|
||||
// Only moves the server never saw, on copies that are still just that.
|
||||
advanced.forMaster(masterId).filter { !it.settled && it.undoable }.forEach { record ->
|
||||
// An edited detached row was unlinked already, so only untouched ones are named.
|
||||
val rows = advanced.detachedFor(record.copyId).mapNotNull { it.taskId } + record.copyId
|
||||
advanced.delete(record.copyId)
|
||||
rows.mapNotNull { tasks.entity(it) }
|
||||
.filter { row ->
|
||||
!row.isDeleted && tasks.subtasks(row.id).isEmpty() &&
|
||||
(master == null || row.listId == master.listId && row.parentId == master.parentId)
|
||||
}
|
||||
.forEach { row ->
|
||||
// Never uploaded: nobody to tell. Uploaded: a tombstone the next run deletes.
|
||||
if (row.href == null) tasks.delete(row.id)
|
||||
else tasks.update(row.copy(isDeleted = true, isDirty = true))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun markSynced(rows: List<TaskEntity>, href: String?, eTag: String?) {
|
||||
if (rows.isEmpty()) return
|
||||
database.runInTransaction {
|
||||
database.tasks().markSynced(rows.map { it.id }, href, eTag)
|
||||
// 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
|
||||
// since is still the device's own.
|
||||
rows.filter { it.recurrenceId == null }.forEach { row ->
|
||||
val anchor = row.recurrenceAnchor
|
||||
if (anchor == null) database.advancedOccurrences().settle(listOf(row.id))
|
||||
else database.advancedOccurrences().settleUpTo(row.id, wholeSecond(anchor) + 1.seconds)
|
||||
}
|
||||
}
|
||||
override fun markSynced(taskIds: List<Long>, href: String?, eTag: String?) {
|
||||
if (taskIds.isNotEmpty()) database.tasks().markSynced(taskIds, href, eTag)
|
||||
}
|
||||
|
||||
override fun setParent(taskId: Long, parentId: Long?) {
|
||||
|
||||
@@ -35,7 +35,11 @@ import kotlin.time.Duration.Companion.seconds
|
||||
@Singleton
|
||||
class SyncTrigger @Inject constructor(
|
||||
@ApplicationContext private val context: Context,
|
||||
) {
|
||||
) : SyncRequests {
|
||||
|
||||
override fun syncNow(accountName: String) {
|
||||
enqueue(accountName)
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts a sync now.
|
||||
|
||||
@@ -56,8 +56,8 @@ class SyncWorker @AssistedInject constructor(
|
||||
// log line is the same as saying nothing. Only what is new: the
|
||||
// store has already dropped whatever the user has been told.
|
||||
noticeNotifier.post(accountName, outcome.notices)
|
||||
// Here rather than left to ReminderRefresher's debounce: once
|
||||
// the worker returns, nothing keeps the process alive for it.
|
||||
// Nothing else re-arms reminders for what a sync pulled in: in our
|
||||
// own store no provider broadcast fires.
|
||||
if (outcome.reports.any { it.hadWork || it.discardedEdits.isNotEmpty() }) {
|
||||
runCatching { reminderScheduler.sync() }
|
||||
}
|
||||
|
||||
@@ -12,7 +12,6 @@ import dagger.hilt.android.qualifiers.ApplicationContext
|
||||
import de.jeanlucmakiola.agendula.data.di.IoDispatcher
|
||||
import de.jeanlucmakiola.agendula.data.sync.AccountStateStore
|
||||
import de.jeanlucmakiola.agendula.data.sync.CredentialStore
|
||||
import de.jeanlucmakiola.agendula.data.sync.ServerTrustStore
|
||||
import de.jeanlucmakiola.agendula.data.sync.SyncAvailability
|
||||
import de.jeanlucmakiola.agendula.data.sync.SyncReport
|
||||
import de.jeanlucmakiola.agendula.data.tasks.room.AccountEntity
|
||||
@@ -49,7 +48,6 @@ class PushRegistrar @Inject constructor(
|
||||
private val credentials: CredentialStore,
|
||||
private val accountState: AccountStateStore,
|
||||
private val availability: SyncAvailability,
|
||||
private val trust: ServerTrustStore,
|
||||
@IoDispatcher private val io: CoroutineDispatcher,
|
||||
) {
|
||||
|
||||
@@ -233,7 +231,7 @@ class PushRegistrar @Inject constructor(
|
||||
val username = account.username ?: return null
|
||||
val origin = account.principalUrl?.toHttpUrlOrNull() ?: return null
|
||||
val password = (credentials.get(account.id) as? CredentialStore.Secret.Present)?.value ?: return null
|
||||
return CalDavHttp.authenticated(USER_AGENT, username, password, origin, trust.get(account.id))
|
||||
return CalDavHttp.authenticated(USER_AGENT, username, password, origin)
|
||||
.newBuilder()
|
||||
.callTimeout(CALL_TIMEOUT_SECONDS, TimeUnit.SECONDS)
|
||||
.build()
|
||||
|
||||
@@ -15,12 +15,9 @@ import androidx.compose.material.icons.rounded.Check
|
||||
import androidx.compose.material.icons.rounded.Bolt
|
||||
import androidx.compose.material.icons.rounded.CloudSync
|
||||
import androidx.compose.material.icons.rounded.DeleteOutline
|
||||
import androidx.compose.material.icons.rounded.Edit
|
||||
import androidx.compose.material.icons.rounded.GppMaybe
|
||||
import androidx.compose.material.icons.rounded.History
|
||||
import androidx.compose.material.icons.rounded.HistoryToggleOff
|
||||
import androidx.compose.material.icons.rounded.Inventory2
|
||||
import androidx.compose.material.icons.rounded.LockOpen
|
||||
import androidx.compose.material.icons.rounded.Refresh
|
||||
import androidx.compose.material.icons.rounded.SyncProblem
|
||||
import androidx.compose.material3.Button
|
||||
@@ -29,7 +26,6 @@ import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.IconButton
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.material3.TextButton
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.getValue
|
||||
@@ -50,13 +46,9 @@ import de.jeanlucmakiola.agendula.data.sync.DiscardedEdit
|
||||
import de.jeanlucmakiola.agendula.data.sync.SyncNotice
|
||||
import de.jeanlucmakiola.agendula.data.tasks.room.AccountEntity
|
||||
import de.jeanlucmakiola.agendula.ui.accounts.add.message
|
||||
import de.jeanlucmakiola.agendula.ui.common.NameField
|
||||
import de.jeanlucmakiola.agendula.ui.common.OnResume
|
||||
import de.jeanlucmakiola.caldav.ServerCertificate
|
||||
import de.jeanlucmakiola.caldav.ServerTrust
|
||||
import de.jeanlucmakiola.floret.components.CollapsingScaffold
|
||||
import de.jeanlucmakiola.floret.components.FullScreenPicker
|
||||
import de.jeanlucmakiola.floret.components.GroupedHint
|
||||
import de.jeanlucmakiola.floret.components.GroupedListInset
|
||||
import de.jeanlucmakiola.floret.components.GroupedRow
|
||||
import de.jeanlucmakiola.floret.components.Position
|
||||
@@ -83,8 +75,6 @@ internal fun AccountDetailScreen(
|
||||
val accounts by viewModel.accounts.collectAsStateWithLifecycle()
|
||||
val usable by viewModel.accountsUsable.collectAsStateWithLifecycle()
|
||||
val push by viewModel.push.collectAsStateWithLifecycle()
|
||||
val trust by remember(accountId) { viewModel.trust(accountId) }
|
||||
.collectAsStateWithLifecycle(ServerTrust.DEFAULT)
|
||||
OnResume(viewModel::refreshPush)
|
||||
val row = accounts?.firstOrNull { it.account.id == accountId }
|
||||
|
||||
@@ -100,34 +90,12 @@ internal fun AccountDetailScreen(
|
||||
// The confirmation sheet. The removal it starts outlives this screen, and is
|
||||
// shown on the accounts list rather than here.
|
||||
var confirming by remember { mutableStateOf(false) }
|
||||
var renaming by remember { mutableStateOf(false) }
|
||||
|
||||
if (renaming) {
|
||||
AccountNamePicker(
|
||||
current = account.label.orEmpty(),
|
||||
defaultTitle = account.defaultTitle(),
|
||||
onSave = { name ->
|
||||
viewModel.rename(account, name)
|
||||
renaming = false
|
||||
},
|
||||
onDismiss = { renaming = false },
|
||||
)
|
||||
}
|
||||
|
||||
CollapsingScaffold(title = identity.title, onBack = onBack, predictiveBack = true, visible = visible) {
|
||||
AccountHero(identity)
|
||||
Spacer(Modifier.height(24.dp))
|
||||
|
||||
val actions = buildList<@Composable (Position) -> Unit> {
|
||||
add { position ->
|
||||
GroupedRow(
|
||||
title = stringResource(R.string.accounts_name),
|
||||
summary = identity.title,
|
||||
position = position,
|
||||
leading = { Icon(Icons.Rounded.Edit, contentDescription = null) },
|
||||
onClick = { renaming = true },
|
||||
)
|
||||
}
|
||||
add { position ->
|
||||
GroupedRow(
|
||||
title = stringResource(R.string.accounts_last_sync),
|
||||
@@ -136,28 +104,6 @@ internal fun AccountDetailScreen(
|
||||
leading = { Icon(Icons.Rounded.History, contentDescription = null) },
|
||||
)
|
||||
}
|
||||
if (trust.allowCleartext) {
|
||||
add { position ->
|
||||
GroupedRow(
|
||||
title = stringResource(R.string.accounts_connection),
|
||||
summary = stringResource(R.string.accounts_connection_cleartext),
|
||||
position = position,
|
||||
leading = { Icon(Icons.Rounded.LockOpen, contentDescription = null) },
|
||||
)
|
||||
}
|
||||
}
|
||||
if (trust.pinnedCertificates.isNotEmpty()) {
|
||||
add { position ->
|
||||
GroupedRow(
|
||||
title = stringResource(R.string.accounts_trusted_certificate),
|
||||
summary = trust.pinnedCertificates.sorted().joinToString("\n") {
|
||||
ServerCertificate.formatFingerprint(it.take(PINNED_PREFIX_CHARS)) + ":\u2026"
|
||||
},
|
||||
position = position,
|
||||
leading = { Icon(Icons.Rounded.GppMaybe, contentDescription = null) },
|
||||
)
|
||||
}
|
||||
}
|
||||
if (!usable) return@buildList
|
||||
push?.let { pushState ->
|
||||
add { position ->
|
||||
@@ -169,7 +115,7 @@ internal fun AccountDetailScreen(
|
||||
)
|
||||
}
|
||||
}
|
||||
if (shown.offersSignIn) {
|
||||
if (shown.needsSignIn) {
|
||||
add { position ->
|
||||
GroupedRow(
|
||||
title = stringResource(R.string.accounts_sign_in_again),
|
||||
@@ -178,8 +124,7 @@ internal fun AccountDetailScreen(
|
||||
onClick = { onSignInAgain(account) },
|
||||
)
|
||||
}
|
||||
}
|
||||
if (!shown.needsSignIn) {
|
||||
} else {
|
||||
add { position ->
|
||||
GroupedRow(
|
||||
title = stringResource(R.string.accounts_sync_now),
|
||||
@@ -535,33 +480,3 @@ private fun errorTitle(text: String): AnnotatedString {
|
||||
buildAnnotatedString { withStyle(SpanStyle(color = error)) { append(text) } }
|
||||
}
|
||||
}
|
||||
|
||||
/** Names an account on screen (#105); left empty, it goes back to [defaultTitle]. */
|
||||
@Composable
|
||||
private fun AccountNamePicker(
|
||||
current: String,
|
||||
defaultTitle: String,
|
||||
onSave: (String) -> Unit,
|
||||
onDismiss: () -> Unit,
|
||||
) {
|
||||
var name by remember { mutableStateOf(current) }
|
||||
FullScreenPicker(
|
||||
title = stringResource(R.string.accounts_name),
|
||||
onDismiss = onDismiss,
|
||||
actions = {
|
||||
TextButton(onClick = { onSave(name) }) { Text(stringResource(R.string.save)) }
|
||||
},
|
||||
) {
|
||||
NameField(
|
||||
name = name,
|
||||
placeholder = defaultTitle,
|
||||
autoFocus = true,
|
||||
onNameChange = { name = it },
|
||||
onImeAction = { onSave(name) },
|
||||
)
|
||||
GroupedHint(stringResource(R.string.accounts_name_hint, defaultTitle))
|
||||
}
|
||||
}
|
||||
|
||||
/** The first eight bytes of a pinned fingerprint, enough to compare at a glance. */
|
||||
private const val PINNED_PREFIX_CHARS = 16
|
||||
@@ -44,14 +44,6 @@ internal data class AccountIdentity(
|
||||
val user: String?,
|
||||
)
|
||||
|
||||
/** The title an account has without a [AccountEntity.label]. */
|
||||
internal fun AccountEntity.defaultTitle(): String {
|
||||
val url = principalUrl?.toHttpUrlOrNull()
|
||||
val provider = url?.let { CalDavProvider.forPrincipal(it) }
|
||||
val host = url?.host?.removePrefix("www.")
|
||||
return if (provider?.hosted == true) provider.label else host ?: displayName
|
||||
}
|
||||
|
||||
internal fun AccountEntity.identity(): AccountIdentity {
|
||||
val url = principalUrl?.toHttpUrlOrNull()
|
||||
val provider = url?.let { CalDavProvider.forPrincipal(it) }
|
||||
@@ -61,7 +53,7 @@ internal fun AccountEntity.identity(): AccountIdentity {
|
||||
provider = provider,
|
||||
// The fallback is the stored name: an account with no principal URL
|
||||
// never got past discovery, so there is nothing better to call it.
|
||||
title = label ?: defaultTitle(),
|
||||
title = if (hosted) provider.label else host ?: displayName,
|
||||
secondary = if (hosted) host else provider?.label,
|
||||
user = username?.takeIf { it.isNotBlank() },
|
||||
)
|
||||
|
||||
@@ -119,7 +119,7 @@ internal fun AccountsScreen(
|
||||
when {
|
||||
row.removing -> CircularProgressIndicator(Modifier.size(20.dp))
|
||||
!usable -> Unit
|
||||
row.offersSignIn -> IconButton(onClick = { onSignInAgain(account) }) {
|
||||
row.needsSignIn -> IconButton(onClick = { onSignInAgain(account) }) {
|
||||
Icon(
|
||||
Icons.AutoMirrored.Rounded.Login,
|
||||
contentDescription = stringResource(R.string.accounts_sign_in_again),
|
||||
|
||||
@@ -8,9 +8,7 @@ import de.jeanlucmakiola.agendula.data.prefs.DEFAULT_SYNC_INTERVAL_MINUTES
|
||||
import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
|
||||
import de.jeanlucmakiola.agendula.data.sync.AccountRepository
|
||||
import de.jeanlucmakiola.agendula.data.sync.AccountStateStore
|
||||
import de.jeanlucmakiola.agendula.data.sync.ServerTrustStore
|
||||
import de.jeanlucmakiola.agendula.data.sync.SyncAvailability
|
||||
import de.jeanlucmakiola.agendula.data.sync.SyncFailure
|
||||
import de.jeanlucmakiola.agendula.data.sync.SyncNotice
|
||||
import de.jeanlucmakiola.agendula.data.sync.SyncNoticeStore
|
||||
import de.jeanlucmakiola.agendula.data.sync.SyncTrigger
|
||||
@@ -32,7 +30,6 @@ import kotlinx.coroutines.flow.stateIn
|
||||
import kotlinx.coroutines.flow.update
|
||||
import kotlinx.coroutines.launch
|
||||
import de.jeanlucmakiola.caldav.CalDavDiscovery
|
||||
import de.jeanlucmakiola.caldav.ServerTrust
|
||||
import de.jeanlucmakiola.caldav.TaskCollection
|
||||
import okhttp3.HttpUrl
|
||||
import javax.inject.Inject
|
||||
@@ -46,7 +43,6 @@ class AccountsViewModel @Inject constructor(
|
||||
private val settings: SettingsPrefs,
|
||||
private val distributors: PushDistributors,
|
||||
private val pushRegistrar: PushRegistrar,
|
||||
private val serverTrust: ServerTrustStore,
|
||||
pushStore: PushStore,
|
||||
availability: SyncAvailability,
|
||||
@IoDispatcher io: CoroutineDispatcher,
|
||||
@@ -192,18 +188,7 @@ class AccountsViewModel @Inject constructor(
|
||||
*/
|
||||
val notices: List<SyncNotice> = emptyList(),
|
||||
val lists: ListPush = ListPush.NONE,
|
||||
) {
|
||||
/**
|
||||
* The last sync was refused over the server's certificate — typically a
|
||||
* pinned one that was renewed. Nothing sets [needsSignIn] for that, yet
|
||||
* signing in again is the only route that can trust the new one.
|
||||
*/
|
||||
val certificateRefused: Boolean
|
||||
get() = account.lastSyncError?.let { SyncFailure.of(it).kind == SyncFailure.Kind.CERTIFICATE } == true
|
||||
|
||||
/** Whether "Sign in again" is the way forward for this account. */
|
||||
val offersSignIn: Boolean get() = needsSignIn || certificateRefused
|
||||
}
|
||||
)
|
||||
|
||||
/**
|
||||
* Accounts whose removal has started and not finished.
|
||||
@@ -263,13 +248,6 @@ class AccountsViewModel @Inject constructor(
|
||||
syncTrigger.enqueue(account.displayName, expedited = true)
|
||||
}
|
||||
|
||||
fun rename(account: AccountEntity, label: String) {
|
||||
viewModelScope.launch { repository.setLabel(account.id, label) }
|
||||
}
|
||||
|
||||
/** What the user agreed to trust for [accountId] beyond the platform's defaults. */
|
||||
fun trust(accountId: Long): Flow<ServerTrust> = serverTrust.observe(accountId)
|
||||
|
||||
/** The user has read what the last sync changed. */
|
||||
fun dismissNotices(account: AccountEntity) {
|
||||
viewModelScope.launch { notices.dismiss(account.id) }
|
||||
|
||||
@@ -17,9 +17,7 @@ import androidx.compose.material.icons.automirrored.rounded.ArrowBack
|
||||
import androidx.compose.material.icons.rounded.Checklist
|
||||
import androidx.compose.material.icons.rounded.CloudOff
|
||||
import androidx.compose.material.icons.rounded.CloudSync
|
||||
import androidx.compose.material.icons.rounded.GppMaybe
|
||||
import androidx.compose.material.icons.rounded.Lock
|
||||
import androidx.compose.material.icons.rounded.LockOpen
|
||||
import androidx.compose.material.icons.rounded.OpenInBrowser
|
||||
import androidx.compose.material.icons.rounded.Warning
|
||||
import androidx.compose.material3.Icon
|
||||
@@ -181,8 +179,6 @@ internal fun AddAccountScreen(
|
||||
is AddAccountStep.Working -> WorkingStep(step)
|
||||
is AddAccountStep.EnterCredentials -> CredentialsStep(step, viewModel)
|
||||
is AddAccountStep.ConfirmBrowser -> ConfirmBrowserStep(step)
|
||||
is AddAccountStep.ConfirmCleartext -> ConfirmCleartextStep(step)
|
||||
is AddAccountStep.TrustCertificate -> TrustCertificateStep(step)
|
||||
is AddAccountStep.WaitingForBrowser -> BrowserStep(step)
|
||||
is AddAccountStep.ChooseLists -> ListsStep(step, viewModel)
|
||||
is AddAccountStep.Summary -> SummaryStep(step)
|
||||
@@ -232,11 +228,7 @@ private fun AddAccountStep.position(hasSetup: Boolean): Int? {
|
||||
return when (this) {
|
||||
is AddAccountStep.ChooseProvider -> 1
|
||||
is AddAccountStep.PrepareAccess -> 2
|
||||
// Both are about reaching the server, so they keep the address's slot.
|
||||
is AddAccountStep.EnterAddress,
|
||||
is AddAccountStep.ConfirmCleartext,
|
||||
is AddAccountStep.TrustCertificate,
|
||||
-> 2 + errand
|
||||
is AddAccountStep.EnterAddress -> 2 + errand
|
||||
// One slot, because only one of the three ever happens: a server either
|
||||
// hands the sign-in to a browser — asking first, where the URL needs
|
||||
// confirming — or asks for a password.
|
||||
@@ -280,8 +272,6 @@ private fun StepHero(state: AddAccountUiState) {
|
||||
// The warning is the screen, so it is the mark too — the browser icon
|
||||
// would say "this is going fine", which is the opposite of the point.
|
||||
state.step is AddAccountStep.ConfirmBrowser -> Icons.Rounded.Warning
|
||||
state.step is AddAccountStep.ConfirmCleartext -> Icons.Rounded.LockOpen
|
||||
state.step is AddAccountStep.TrustCertificate -> Icons.Rounded.GppMaybe
|
||||
state.step is AddAccountStep.WaitingForBrowser -> Icons.Rounded.OpenInBrowser
|
||||
state.step is AddAccountStep.ChooseLists -> Icons.Rounded.Checklist
|
||||
else -> Icons.Rounded.CloudSync
|
||||
@@ -321,10 +311,6 @@ private fun StepTitle(step: AddAccountStep) {
|
||||
R.string.add_account_credentials_title to R.string.add_account_credentials_body
|
||||
is AddAccountStep.ConfirmBrowser ->
|
||||
R.string.add_account_browser_confirm_title to R.string.add_account_browser_confirm_body
|
||||
is AddAccountStep.ConfirmCleartext ->
|
||||
R.string.add_account_cleartext_title to R.string.add_account_cleartext_body
|
||||
is AddAccountStep.TrustCertificate ->
|
||||
R.string.add_account_certificate_title to R.string.add_account_certificate_body
|
||||
is AddAccountStep.ChooseLists ->
|
||||
R.string.add_account_lists_title to R.string.add_account_lists_body
|
||||
is AddAccountStep.Summary ->
|
||||
@@ -426,34 +412,6 @@ private fun ColumnScope.StepActions(state: AddAccountUiState, viewModel: AddAcco
|
||||
) { Text(stringResource(R.string.add_account_browser_use_password)) }
|
||||
}
|
||||
|
||||
// Plain http stays a deliberate choice: going forward is primary, as it
|
||||
// is for the browser warning, and changing the address is right below.
|
||||
is AddAccountStep.ConfirmCleartext -> {
|
||||
PrimaryAction(
|
||||
label = stringResource(R.string.add_account_cleartext_connect),
|
||||
enabled = true,
|
||||
onClick = viewModel::onCleartextConfirmed,
|
||||
)
|
||||
TextButton(
|
||||
onClick = { viewModel.onBackWithin() },
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
) { Text(stringResource(R.string.add_account_change_address)) }
|
||||
}
|
||||
|
||||
// The safe answer stays visible, as it does for plain http: back is
|
||||
// not something every user knows to look for on a security prompt.
|
||||
is AddAccountStep.TrustCertificate -> {
|
||||
PrimaryAction(
|
||||
label = stringResource(R.string.add_account_certificate_trust),
|
||||
enabled = true,
|
||||
onClick = viewModel::onCertificateTrusted,
|
||||
)
|
||||
TextButton(
|
||||
onClick = { viewModel.onBackWithin() },
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
) { Text(stringResource(R.string.add_account_certificate_decline)) }
|
||||
}
|
||||
|
||||
is AddAccountStep.WaitingForBrowser -> {
|
||||
// A failed flow is retried by default. With no browser a retry
|
||||
// cannot help; while the server throttles or is in maintenance an
|
||||
|
||||
@@ -21,7 +21,6 @@ internal val CalDavDiscovery.Outcome.Cause.message: Int
|
||||
CalDavDiscovery.Outcome.Cause.NOT_A_DAV_SERVER -> R.string.add_account_error_not_dav
|
||||
CalDavDiscovery.Outcome.Cause.NO_CALENDAR_SUPPORT -> R.string.add_account_error_no_calendar
|
||||
CalDavDiscovery.Outcome.Cause.UNREACHABLE -> R.string.add_account_error_unreachable
|
||||
CalDavDiscovery.Outcome.Cause.TLS -> R.string.add_account_error_tls
|
||||
CalDavDiscovery.Outcome.Cause.INSECURE -> R.string.add_account_error_insecure
|
||||
CalDavDiscovery.Outcome.Cause.NO_CALENDARS -> R.string.add_account_error_no_calendars
|
||||
CalDavDiscovery.Outcome.Cause.SERVER_ERROR -> R.string.add_account_error_server
|
||||
|
||||
+50
-230
@@ -8,18 +8,13 @@ import de.jeanlucmakiola.agendula.data.sync.AccountCreator
|
||||
import de.jeanlucmakiola.agendula.data.sync.AccountRepository
|
||||
import de.jeanlucmakiola.agendula.data.sync.CalDavGateway
|
||||
import de.jeanlucmakiola.agendula.data.sync.LoginFlowRecord
|
||||
import de.jeanlucmakiola.agendula.data.sync.ServerTrustKeys
|
||||
import de.jeanlucmakiola.caldav.CalDavDiscovery
|
||||
import de.jeanlucmakiola.caldav.CalDavProvider
|
||||
import de.jeanlucmakiola.caldav.NextcloudLoginFlow
|
||||
import de.jeanlucmakiola.caldav.ServerCertificate
|
||||
import de.jeanlucmakiola.caldav.ServerQuirk
|
||||
import de.jeanlucmakiola.caldav.ServerTrust
|
||||
import de.jeanlucmakiola.caldav.ServiceDiscovery
|
||||
import de.jeanlucmakiola.caldav.TaskCollection
|
||||
import de.jeanlucmakiola.agendula.data.di.ApplicationScope
|
||||
import kotlinx.coroutines.CancellationException
|
||||
import kotlinx.coroutines.CompletableDeferred
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.NonCancellable
|
||||
import kotlinx.coroutines.withContext
|
||||
@@ -121,12 +116,6 @@ sealed interface AddAccountStep {
|
||||
val insecure: Boolean = false,
|
||||
) : AddAccountStep
|
||||
|
||||
/** The typed address is plain http; the user has to accept that before anything is sent. */
|
||||
data class ConfirmCleartext(val address: String) : AddAccountStep
|
||||
|
||||
/** The server's certificate is not trusted by the platform; the user may pin it. */
|
||||
data class TrustCertificate(val certificate: ServerCertificate) : AddAccountStep
|
||||
|
||||
/**
|
||||
* The browser has the flow. We poll until the user approves, and offer an
|
||||
* explicit way out — Custom Tabs return **no result** when dismissed, and
|
||||
@@ -338,36 +327,6 @@ class AddAccountViewModel @Inject constructor(
|
||||
/** The flow the browser was last sent to, for a retry while it is still open. */
|
||||
private var browserFlow: NextcloudLoginFlow.Flow? = null
|
||||
|
||||
/** What the user agreed to trust in this flow, handed to every gateway call. */
|
||||
private var trust: ServerTrust
|
||||
get() = TRUST_KEYS.read(handle)
|
||||
set(value) = TRUST_KEYS.write(handle, value)
|
||||
|
||||
/**
|
||||
* The address [trust] was given for. Pins and plain http both belong to it,
|
||||
* so submitting any other address starts from nothing.
|
||||
*/
|
||||
private var trustAddress: String?
|
||||
get() = handle[KEY_TRUST_ADDRESS]
|
||||
set(value) { handle[KEY_TRUST_ADDRESS] = value }
|
||||
|
||||
/**
|
||||
* The pins in [trust] came from the account being signed in to, not from
|
||||
* this flow. The first certificate trusted now replaces them, so a renewed
|
||||
* certificate retires the one it renews instead of joining it.
|
||||
*/
|
||||
private var inheritedPins: Boolean
|
||||
get() = handle[KEY_INHERITED_PINS] ?: false
|
||||
set(value) { handle[KEY_INHERITED_PINS] = value }
|
||||
|
||||
/** Loading a re-authenticated account's stored trust, which discovery waits for. */
|
||||
private var trustLoad: Job? = null
|
||||
|
||||
/** The open [AddAccountStep.TrustCertificate] question, and where declining it goes. */
|
||||
private class TrustPrompt(val answer: CompletableDeferred<Unit>, val back: AddAccountStep)
|
||||
|
||||
private var trustPrompt: TrustPrompt? = null
|
||||
|
||||
/** Which hosts asked for credentials, for the cross-domain diagnostic. */
|
||||
private var hostsNeedingAuth: List<String>
|
||||
get() = handle.get<ArrayList<String>>(KEY_HOSTS_NEEDING_AUTH).orEmpty()
|
||||
@@ -465,15 +424,6 @@ class AddAccountViewModel @Inject constructor(
|
||||
reauthenticating = true,
|
||||
)
|
||||
}
|
||||
// Starts from what the account already trusts, so a renewed certificate
|
||||
// is the only thing asked about again.
|
||||
val address = addressInput
|
||||
trustLoad = viewModelScope.launch {
|
||||
val stored = runCatching { repository.trustFor(accountId) }.getOrDefault(ServerTrust.DEFAULT)
|
||||
trust = stored
|
||||
trustAddress = address
|
||||
inheritedPins = stored.pinnedCertificates.isNotEmpty()
|
||||
}
|
||||
}
|
||||
|
||||
/** The errand is read; on to the address. */
|
||||
@@ -548,25 +498,10 @@ class AddAccountViewModel @Inject constructor(
|
||||
}
|
||||
|
||||
serverRoot = ServiceDiscovery.serverRootFor(input)
|
||||
discoverAddress()
|
||||
}
|
||||
|
||||
/** Discovery for the submitted address, without credentials. */
|
||||
private fun discoverAddress() {
|
||||
working(AddAccountMessage.Progress.Discovering)
|
||||
viewModelScope.launch {
|
||||
// ⚠️ After the stored trust has landed, not before: reset first and
|
||||
// the load would put the old address's trust back on top.
|
||||
trustLoad?.join()
|
||||
if (typedInput != trustAddress) {
|
||||
trust = ServerTrust.DEFAULT
|
||||
inheritedPins = false
|
||||
trustAddress = typedInput
|
||||
}
|
||||
val outcome = discoverTrusting(addressStep(typedInput), AddAccountMessage.Progress.Discovering) {
|
||||
gateway.discover(typedInput, trust = trust)
|
||||
} ?: return@launch
|
||||
when (outcome) {
|
||||
when (val outcome = gateway.discover(typedInput)) {
|
||||
is CalDavDiscovery.Outcome.Found -> onDiscovered(outcome)
|
||||
|
||||
is CalDavDiscovery.Outcome.NeedsAuthentication -> {
|
||||
@@ -582,71 +517,11 @@ class AddAccountViewModel @Inject constructor(
|
||||
|
||||
is CalDavDiscovery.Outcome.NotCalDav -> backToAddressOrServer(outcome.cause)
|
||||
|
||||
is CalDavDiscovery.Outcome.Failed -> if (needsCleartextConsent(outcome.cause)) {
|
||||
updateState { it.copy(step = AddAccountStep.ConfirmCleartext(typedInput)) }
|
||||
} else {
|
||||
backToAddressOrServer(outcome.cause)
|
||||
}
|
||||
|
||||
// Asked about inside discoverTrusting, which only returns it declined.
|
||||
is CalDavDiscovery.Outcome.UntrustedCertificate -> Unit
|
||||
is CalDavDiscovery.Outcome.Failed -> backToAddressOrServer(outcome.cause)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** A typed http:// address the user has not yet accepted as unencrypted. */
|
||||
private fun needsCleartextConsent(cause: CalDavDiscovery.Outcome.Cause): Boolean =
|
||||
cause == CalDavDiscovery.Outcome.Cause.INSECURE && !trust.allowCleartext &&
|
||||
typedInput.toHttpUrlOrNull()?.isHttps == false
|
||||
|
||||
/** The warning is read and plain http is wanted anyway. */
|
||||
fun onCleartextConfirmed() {
|
||||
if (current.step !is AddAccountStep.ConfirmCleartext) return
|
||||
trust = trust.copy(allowCleartext = true)
|
||||
trustAddress = typedInput
|
||||
discoverAddress()
|
||||
}
|
||||
|
||||
/** The fingerprint is checked; pin it and re-run what it stopped. */
|
||||
fun onCertificateTrusted() {
|
||||
val step = current.step as? AddAccountStep.TrustCertificate ?: return
|
||||
val prompt = trustPrompt ?: return
|
||||
trustPrompt = null
|
||||
val fingerprint = step.certificate.fingerprint
|
||||
trust = if (inheritedPins) {
|
||||
trust.copy(pinnedCertificates = setOf(fingerprint.lowercase()))
|
||||
} else {
|
||||
trust.withCertificate(fingerprint)
|
||||
}
|
||||
inheritedPins = false
|
||||
prompt.answer.complete(Unit)
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs [discover], and on a certificate the user could trust asks about it
|
||||
* and runs it again once they have. Null when they declined; the step is
|
||||
* then already [back].
|
||||
*/
|
||||
private suspend fun discoverTrusting(
|
||||
back: AddAccountStep,
|
||||
progress: AddAccountMessage.Progress,
|
||||
discover: suspend () -> CalDavDiscovery.Outcome,
|
||||
): CalDavDiscovery.Outcome? {
|
||||
while (true) {
|
||||
val outcome = discover()
|
||||
if (outcome !is CalDavDiscovery.Outcome.UntrustedCertificate) return outcome
|
||||
val prompt = TrustPrompt(CompletableDeferred(), back)
|
||||
trustPrompt = prompt
|
||||
updateState { it.copy(step = AddAccountStep.TrustCertificate(outcome.certificate), openInBrowser = null) }
|
||||
try {
|
||||
prompt.answer.await()
|
||||
} catch (_: CancellationException) {
|
||||
return null
|
||||
}
|
||||
working(progress)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* An email address whose domain has no CalDAV server goes straight to the
|
||||
* server field rather than an error with nowhere to go; the email stays as
|
||||
@@ -687,10 +562,7 @@ class AddAccountViewModel @Inject constructor(
|
||||
if (step.username.isBlank() || step.password.isEmpty()) return
|
||||
username = step.username.trim()
|
||||
appPassword = step.password
|
||||
discoverWithCredentials()
|
||||
}
|
||||
|
||||
private fun discoverWithCredentials() {
|
||||
working(AddAccountMessage.Progress.SigningIn)
|
||||
viewModelScope.launch {
|
||||
// ⚠️ An error, not a silent unauthenticated retry. serverRootFor
|
||||
@@ -701,11 +573,7 @@ class AddAccountViewModel @Inject constructor(
|
||||
val root = serverRoot
|
||||
?: return@launch backToAddress(CalDavDiscovery.Outcome.Cause.NOT_AN_ADDRESS)
|
||||
val credentials = CalDavGateway.Credentials(username, appPassword, root)
|
||||
val outcome = discoverTrusting(
|
||||
AddAccountStep.EnterCredentials(username = username),
|
||||
AddAccountMessage.Progress.SigningIn,
|
||||
) { gateway.discover(typedInput, credentials, trust) } ?: return@launch
|
||||
when (outcome) {
|
||||
when (val outcome = gateway.discover(typedInput, credentials)) {
|
||||
is CalDavDiscovery.Outcome.Found -> onDiscovered(outcome)
|
||||
|
||||
// A second rejection is the point at which naming the provider's
|
||||
@@ -727,7 +595,6 @@ class AddAccountViewModel @Inject constructor(
|
||||
|
||||
is CalDavDiscovery.Outcome.NotCalDav -> backToAddressOrServer(outcome.cause)
|
||||
is CalDavDiscovery.Outcome.Failed -> backToAddressOrServer(outcome.cause)
|
||||
is CalDavDiscovery.Outcome.UntrustedCertificate -> Unit
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -746,7 +613,7 @@ class AddAccountViewModel @Inject constructor(
|
||||
/** Step 3b → the browser flow, if this looks like a Nextcloud. */
|
||||
private suspend fun offerSignIn() {
|
||||
val root = serverRoot ?: return backToAddress(CalDavDiscovery.Outcome.Cause.NOT_AN_ADDRESS)
|
||||
val flow = gateway.startLoginFlow(root, trust)
|
||||
val flow = gateway.startLoginFlow(root)
|
||||
|
||||
if (flow == null) {
|
||||
// Not a Nextcloud, or its login flow is unavailable. Ask for a
|
||||
@@ -807,7 +674,7 @@ class AddAccountViewModel @Inject constructor(
|
||||
*/
|
||||
private suspend fun launchBrowser(flow: NextcloudLoginFlow.Flow) {
|
||||
browserFlow = flow
|
||||
runCatching { pendingFlow.remember(flow, trust) }
|
||||
runCatching { pendingFlow.remember(flow) }
|
||||
updateState {
|
||||
it.copy(
|
||||
step = AddAccountStep.WaitingForBrowser(hostMismatch = flow.hostMismatch),
|
||||
@@ -836,7 +703,7 @@ class AddAccountViewModel @Inject constructor(
|
||||
// later poll can only report expiry. Bounded by the gateway's
|
||||
// own per-call budget, and the delay above stays cancellable, so
|
||||
// the loop still stops promptly.
|
||||
val result = withContext(NonCancellable) { gateway.pollLoginFlow(flow, trust) }
|
||||
val result = withContext(NonCancellable) { gateway.pollLoginFlow(flow) }
|
||||
when (result) {
|
||||
is NextcloudLoginFlow.PollResult.Approved -> {
|
||||
// ⚠️ Uncancellable. The 200 that carried this password is
|
||||
@@ -875,7 +742,47 @@ class AddAccountViewModel @Inject constructor(
|
||||
result.hostMismatch?.let { mismatch ->
|
||||
updateState { it.copy(originMismatch = mismatch) }
|
||||
}
|
||||
discoverApproved(result.credentials.server)
|
||||
working(AddAccountMessage.Progress.ReadingLists)
|
||||
val outcome = gateway.discover(
|
||||
// The server the credentials were *issued by*, not the
|
||||
// host the user typed — the two differ in exactly the
|
||||
// host-mismatch case this flow already models, and
|
||||
// getting it wrong burns the one-shot app password.
|
||||
target = result.credentials.server.toString(),
|
||||
credentials = CalDavGateway.Credentials(
|
||||
username,
|
||||
appPassword,
|
||||
result.credentials.server,
|
||||
),
|
||||
)
|
||||
when (outcome) {
|
||||
is CalDavDiscovery.Outcome.Found -> onDiscovered(outcome)
|
||||
// ⚠️ Forward what actually happened. Reporting every
|
||||
// outcome as NO_CALENDARS tells someone whose server
|
||||
// named an unresolvable host that their account holds
|
||||
// no task lists, which is both wrong and unactionable.
|
||||
is CalDavDiscovery.Outcome.Failed -> backToAddress(outcome.cause)
|
||||
is CalDavDiscovery.Outcome.NotCalDav -> backToAddress(outcome.cause)
|
||||
// ⚠️ These two carry no Cause, so they used to land
|
||||
// on "signed in, but no task lists" — said of a
|
||||
// credential the server had just rejected. A 401 here
|
||||
// is either a home set outside the domain the
|
||||
// credential is scoped to, which retrying cannot fix
|
||||
// and which only mints a second password, or the
|
||||
// server having a moment.
|
||||
is CalDavDiscovery.Outcome.NeedsAuthentication -> {
|
||||
hostsNeedingAuth = outcome.hosts
|
||||
val stranger = outsideCredentialScope(outcome.hosts)
|
||||
if (stranger != null) {
|
||||
fatal(AddAccountMessage.OutsideCredentialScope(stranger))
|
||||
} else {
|
||||
backToAddress(CalDavDiscovery.Outcome.Cause.SERVER_ERROR)
|
||||
}
|
||||
}
|
||||
|
||||
CalDavDiscovery.Outcome.Unauthenticated ->
|
||||
backToAddress(CalDavDiscovery.Outcome.Cause.SERVER_ERROR)
|
||||
}
|
||||
return@launch
|
||||
}
|
||||
|
||||
@@ -908,52 +815,6 @@ class AddAccountViewModel @Inject constructor(
|
||||
}
|
||||
}
|
||||
|
||||
/** Discovery with a password the login flow just minted, at the server that issued it. */
|
||||
private suspend fun discoverApproved(server: HttpUrl) {
|
||||
working(AddAccountMessage.Progress.ReadingLists)
|
||||
val outcome = discoverTrusting(addressStep(typedInput), AddAccountMessage.Progress.ReadingLists) {
|
||||
gateway.discover(
|
||||
// The server the credentials were *issued by*, not the
|
||||
// host the user typed — the two differ in exactly the
|
||||
// host-mismatch case this flow already models, and
|
||||
// getting it wrong burns the one-shot app password.
|
||||
target = server.toString(),
|
||||
credentials = CalDavGateway.Credentials(username, appPassword, server),
|
||||
trust = trust,
|
||||
)
|
||||
} ?: return
|
||||
when (outcome) {
|
||||
is CalDavDiscovery.Outcome.Found -> onDiscovered(outcome)
|
||||
// ⚠️ Forward what actually happened. Reporting every
|
||||
// outcome as NO_CALENDARS tells someone whose server
|
||||
// named an unresolvable host that their account holds
|
||||
// no task lists, which is both wrong and unactionable.
|
||||
is CalDavDiscovery.Outcome.Failed -> backToAddress(outcome.cause)
|
||||
is CalDavDiscovery.Outcome.NotCalDav -> backToAddress(outcome.cause)
|
||||
// ⚠️ These two carry no Cause, so they used to land
|
||||
// on "signed in, but no task lists" — said of a
|
||||
// credential the server had just rejected. A 401 here
|
||||
// is either a home set outside the domain the
|
||||
// credential is scoped to, which retrying cannot fix
|
||||
// and which only mints a second password, or the
|
||||
// server having a moment.
|
||||
is CalDavDiscovery.Outcome.NeedsAuthentication -> {
|
||||
hostsNeedingAuth = outcome.hosts
|
||||
val stranger = outsideCredentialScope(outcome.hosts)
|
||||
if (stranger != null) {
|
||||
fatal(AddAccountMessage.OutsideCredentialScope(stranger))
|
||||
} else {
|
||||
backToAddress(CalDavDiscovery.Outcome.Cause.SERVER_ERROR)
|
||||
}
|
||||
}
|
||||
|
||||
CalDavDiscovery.Outcome.Unauthenticated ->
|
||||
backToAddress(CalDavDiscovery.Outcome.Cause.SERVER_ERROR)
|
||||
|
||||
is CalDavDiscovery.Outcome.UntrustedCertificate -> Unit
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Another go after the browser sign-in failed.
|
||||
*
|
||||
@@ -1037,7 +898,6 @@ class AddAccountViewModel @Inject constructor(
|
||||
found = discovered,
|
||||
selected = chosen,
|
||||
reauthenticating = reauthAccountId,
|
||||
trust = trust,
|
||||
)
|
||||
}.getOrElse {
|
||||
// A constraint violation or an IO failure in DataStore must not
|
||||
@@ -1144,19 +1004,6 @@ class AddAccountViewModel @Inject constructor(
|
||||
true
|
||||
}
|
||||
|
||||
is AddAccountStep.ConfirmCleartext -> {
|
||||
updateState { it.copy(step = addressStep(typedInput), fatal = null) }
|
||||
true
|
||||
}
|
||||
|
||||
is AddAccountStep.TrustCertificate -> {
|
||||
val prompt = trustPrompt
|
||||
trustPrompt = null
|
||||
prompt?.answer?.cancel()
|
||||
updateState { it.copy(step = prompt?.back ?: addressStep(typedInput), fatal = null) }
|
||||
true
|
||||
}
|
||||
|
||||
else -> false
|
||||
}
|
||||
|
||||
@@ -1198,13 +1045,6 @@ class AddAccountViewModel @Inject constructor(
|
||||
reauthAccountId = null
|
||||
suggestedUsername = ""
|
||||
fallbackEmail = null
|
||||
trustLoad?.cancel()
|
||||
trustLoad = null
|
||||
trust = ServerTrust.DEFAULT
|
||||
trustAddress = null
|
||||
inheritedPins = false
|
||||
trustPrompt?.answer?.cancel()
|
||||
trustPrompt = null
|
||||
current = AddAccountUiState()
|
||||
}
|
||||
|
||||
@@ -1228,10 +1068,9 @@ class AddAccountViewModel @Inject constructor(
|
||||
private fun discardMintedPassword() {
|
||||
val credentials = minted ?: return
|
||||
minted = null
|
||||
val trust = trust
|
||||
// The scope has no exception handler, so anything escaping here takes the
|
||||
// app down — for a courtesy call whose failures are deliberately silent.
|
||||
appScope.launch { runCatching { gateway.revokeIssuedAppPassword(credentials, trust) } }
|
||||
appScope.launch { runCatching { gateway.revokeIssuedAppPassword(credentials) } }
|
||||
}
|
||||
|
||||
// -------------------------------------------------------- saved state
|
||||
@@ -1256,8 +1095,6 @@ class AddAccountViewModel @Inject constructor(
|
||||
// what deals with that on the next open. Recording them as
|
||||
// themselves would only mean deciding the same thing twice.
|
||||
is AddAccountStep.ConfirmBrowser, is AddAccountStep.WaitingForBrowser -> STEP_ADDRESS
|
||||
// Both re-ask on the next submit, which is where a restore puts them.
|
||||
is AddAccountStep.ConfirmCleartext, is AddAccountStep.TrustCertificate -> STEP_ADDRESS
|
||||
is AddAccountStep.Working -> STEP_WORKING
|
||||
is AddAccountStep.ChooseLists -> STEP_LISTS
|
||||
is AddAccountStep.Summary -> STEP_SUMMARY
|
||||
@@ -1363,10 +1200,7 @@ class AddAccountViewModel @Inject constructor(
|
||||
)
|
||||
viewModelScope.launch {
|
||||
val credentials = CalDavGateway.Credentials(username, appPassword, root)
|
||||
val outcome = discoverTrusting(addressStep(addressInput), AddAccountMessage.Progress.ReadingLists) {
|
||||
gateway.discover(target, credentials, trust)
|
||||
} ?: return@launch
|
||||
when (outcome) {
|
||||
when (val outcome = gateway.discover(target, credentials)) {
|
||||
is CalDavDiscovery.Outcome.Found -> onDiscovered(outcome, selection)
|
||||
is CalDavDiscovery.Outcome.NotCalDav -> backToAddressOrServer(outcome.cause)
|
||||
is CalDavDiscovery.Outcome.Failed -> backToAddressOrServer(outcome.cause)
|
||||
@@ -1377,7 +1211,6 @@ class AddAccountViewModel @Inject constructor(
|
||||
credentialsRejected()
|
||||
}
|
||||
CalDavDiscovery.Outcome.Unauthenticated -> credentialsRejected()
|
||||
is CalDavDiscovery.Outcome.UntrustedCertificate -> Unit
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1553,14 +1386,10 @@ class AddAccountViewModel @Inject constructor(
|
||||
}
|
||||
}
|
||||
|
||||
// The port is part of the name: two servers on one host are two accounts (#105).
|
||||
private fun accountName(): String =
|
||||
username.takeIf { it.isNotBlank() }?.let { "$it@${serverRoot?.authority().orEmpty()}" }
|
||||
username.takeIf { it.isNotBlank() }?.let { "$it@${serverRoot?.host.orEmpty()}" }
|
||||
?: typedInput
|
||||
|
||||
private fun HttpUrl.authority(): String =
|
||||
if (port == HttpUrl.defaultPort(scheme)) host else "$host:$port"
|
||||
|
||||
internal companion object {
|
||||
const val POLL_INTERVAL_MILLIS = 2_000L
|
||||
|
||||
@@ -1605,21 +1434,12 @@ class AddAccountViewModel @Inject constructor(
|
||||
const val KEY_REAUTH_ACCOUNT = "add_account.reauth_account"
|
||||
const val KEY_SUGGESTED_USERNAME = "add_account.suggested_username"
|
||||
const val KEY_FALLBACK_EMAIL = "add_account.fallback_email"
|
||||
const val KEY_TRUSTED_CERTIFICATES = "add_account.trusted_certificates"
|
||||
const val KEY_CLEARTEXT = "add_account.cleartext"
|
||||
const val KEY_TRUST_ADDRESS = "add_account.trust_address"
|
||||
const val KEY_INHERITED_PINS = "add_account.inherited_pins"
|
||||
|
||||
val TRUST_KEYS = ServerTrustKeys(KEY_TRUSTED_CERTIFICATES, KEY_CLEARTEXT)
|
||||
|
||||
/** What sends an email to the server field: no CalDAV on its domain, or nothing answering for it. */
|
||||
val NO_SERVER_FOUND = setOf(
|
||||
CalDavDiscovery.Outcome.Cause.NOT_A_DAV_SERVER,
|
||||
CalDavDiscovery.Outcome.Cause.NO_CALENDAR_SUPPORT,
|
||||
CalDavDiscovery.Outcome.Cause.UNREACHABLE,
|
||||
// The domain's own host would not set up TLS: usually its website,
|
||||
// not a CalDAV server, so the server field is the way on.
|
||||
CalDavDiscovery.Outcome.Cause.TLS,
|
||||
)
|
||||
|
||||
/**
|
||||
|
||||
@@ -1,76 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.ui.accounts.add
|
||||
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.Spacer
|
||||
import androidx.compose.foundation.layout.height
|
||||
import androidx.compose.foundation.text.selection.SelectionContainer
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.rounded.Badge
|
||||
import androidx.compose.material.icons.rounded.Event
|
||||
import androidx.compose.material.icons.rounded.Fingerprint
|
||||
import androidx.compose.material.icons.rounded.LockOpen
|
||||
import androidx.compose.material.icons.rounded.Verified
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.platform.LocalConfiguration
|
||||
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.font.FontFamily
|
||||
import androidx.compose.ui.text.withStyle
|
||||
import androidx.compose.ui.unit.dp
|
||||
import de.jeanlucmakiola.agendula.R
|
||||
import de.jeanlucmakiola.floret.components.GroupedRow
|
||||
import de.jeanlucmakiola.floret.components.Position
|
||||
import de.jeanlucmakiola.floret.components.positionOf
|
||||
import java.text.DateFormat
|
||||
import java.util.Date
|
||||
|
||||
/** The typed address is plain http: what that exposes, before anything is sent. */
|
||||
@Composable
|
||||
internal fun ConfirmCleartextStep(step: AddAccountStep.ConfirmCleartext) {
|
||||
GroupedRow(
|
||||
title = step.address,
|
||||
position = Position.Alone,
|
||||
leading = { Icon(Icons.Rounded.LockOpen, contentDescription = null) },
|
||||
)
|
||||
Spacer(Modifier.height(16.dp))
|
||||
QuirkNote(text = stringResource(R.string.add_account_cleartext_note))
|
||||
}
|
||||
|
||||
/**
|
||||
* A certificate the phone does not trust, laid out for comparing against the
|
||||
* server's own. The fingerprint is the part that matters, so it comes first and
|
||||
* can be selected.
|
||||
*/
|
||||
@Composable
|
||||
internal fun TrustCertificateStep(step: AddAccountStep.TrustCertificate) {
|
||||
val certificate = step.certificate
|
||||
val locale = LocalConfiguration.current.locales[0]
|
||||
val expires = DateFormat.getDateInstance(DateFormat.MEDIUM, locale).format(Date(certificate.notAfterMillis))
|
||||
val rows = listOf(
|
||||
Triple(Icons.Rounded.Fingerprint, R.string.add_account_certificate_fingerprint, certificate.displayFingerprint),
|
||||
Triple(Icons.Rounded.Badge, R.string.add_account_certificate_subject, certificate.subject),
|
||||
Triple(Icons.Rounded.Verified, R.string.add_account_certificate_issuer, certificate.issuer),
|
||||
Triple(Icons.Rounded.Event, R.string.add_account_certificate_expires, expires),
|
||||
)
|
||||
SelectionContainer {
|
||||
Column {
|
||||
rows.forEachIndexed { index, (icon, title, value) ->
|
||||
GroupedRow(
|
||||
title = AnnotatedString(stringResource(title)),
|
||||
summary = if (index == 0) {
|
||||
buildAnnotatedString { withStyle(SpanStyle(fontFamily = FontFamily.Monospace)) { append(value) } }
|
||||
} else {
|
||||
AnnotatedString(value)
|
||||
},
|
||||
position = positionOf(index, rows.size),
|
||||
leading = { Icon(icon, contentDescription = null) },
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
Spacer(Modifier.height(16.dp))
|
||||
}
|
||||
@@ -5,14 +5,11 @@
|
||||
default trust anchors. That breaks exactly the self-hosting audience this app
|
||||
is for, so they are added back here.
|
||||
|
||||
Cleartext is permitted here and gated in code instead, per account: every
|
||||
client CalDavHttp builds leaves ConnectionSpec.CLEARTEXT out unless the user
|
||||
opted that account into plain http behind an explicit warning, so OkHttp
|
||||
itself refuses an http:// URL for everyone else. This file cannot express a
|
||||
per-account choice, only a per-host one, and the hosts are the user's.
|
||||
|
||||
⚠️ That makes CalDavHttp the only gate. A client built any other way would
|
||||
speak http silently, so HttpClientConstructionTest fails the build on one.
|
||||
Cleartext stays off. It has been the default since API 28, and CalDavDiscovery
|
||||
refuses a typed http:// address for the same reason: credentials are never
|
||||
sent over an unencrypted connection. Any escape hatch has to be a narrow,
|
||||
warned, per-account opt-in — Play's User Data policy requires modern
|
||||
cryptography in transit — and this file is not the place for it.
|
||||
|
||||
⚠️ KNOWN TRADE-OFF, and it is the widest form of this. base-config applies to
|
||||
*all* traffic, so any CA in the user store — a corporate MDM profile, a "free
|
||||
@@ -28,7 +25,7 @@
|
||||
sit alongside it.
|
||||
-->
|
||||
<network-security-config>
|
||||
<base-config cleartextTrafficPermitted="true">
|
||||
<base-config cleartextTrafficPermitted="false">
|
||||
<trust-anchors>
|
||||
<certificates src="system" />
|
||||
<certificates src="user" />
|
||||
|
||||
@@ -65,8 +65,10 @@
|
||||
android:exported="true"
|
||||
android:launchMode="singleTop"
|
||||
android:windowSoftInputMode="adjustResize">
|
||||
<!-- MAIN/LAUNCHER lives on the two aliases below, so the launcher
|
||||
name can be switched at runtime (#104). -->
|
||||
<intent-filter>
|
||||
<action android:name="android.intent.action.MAIN" />
|
||||
<category android:name="android.intent.category.LAUNCHER" />
|
||||
</intent-filter>
|
||||
<!-- Shared text becomes a new task's title. -->
|
||||
<intent-filter>
|
||||
<action android:name="android.intent.action.SEND" />
|
||||
@@ -87,32 +89,6 @@
|
||||
<data android:mimeType="text/calendar" />
|
||||
</intent-filter>
|
||||
</activity>
|
||||
<activity-alias
|
||||
android:name=".DefaultNameAlias"
|
||||
android:enabled="true"
|
||||
android:exported="true"
|
||||
android:icon="@mipmap/ic_launcher"
|
||||
android:label="@string/app_name"
|
||||
android:roundIcon="@mipmap/ic_launcher_round"
|
||||
android:targetActivity=".MainActivity">
|
||||
<intent-filter>
|
||||
<action android:name="android.intent.action.MAIN" />
|
||||
<category android:name="android.intent.category.LAUNCHER" />
|
||||
</intent-filter>
|
||||
</activity-alias>
|
||||
<activity-alias
|
||||
android:name=".TasksNameAlias"
|
||||
android:enabled="false"
|
||||
android:exported="true"
|
||||
android:icon="@mipmap/ic_launcher"
|
||||
android:label="@string/app_name_tasks_alias"
|
||||
android:roundIcon="@mipmap/ic_launcher_round"
|
||||
android:targetActivity=".MainActivity">
|
||||
<intent-filter>
|
||||
<action android:name="android.intent.action.MAIN" />
|
||||
<category android:name="android.intent.category.LAUNCHER" />
|
||||
</intent-filter>
|
||||
</activity-alias>
|
||||
|
||||
<!-- Quick Settings "New task" tile. Only the system QS host can bind it. -->
|
||||
<service
|
||||
|
||||
@@ -12,7 +12,6 @@ import dagger.hilt.components.SingletonComponent
|
||||
import de.jeanlucmakiola.agendula.data.di.ApplicationScope
|
||||
import de.jeanlucmakiola.agendula.data.di.ChannelRefresher
|
||||
import de.jeanlucmakiola.agendula.data.reminders.ReminderMaintenanceWorker
|
||||
import de.jeanlucmakiola.agendula.data.reminders.ReminderRefresher
|
||||
import de.jeanlucmakiola.agendula.data.reminders.ReminderScheduler
|
||||
import de.jeanlucmakiola.agendula.data.reminders.TaskNotifier
|
||||
import de.jeanlucmakiola.agendula.data.tasks.ProviderResolver
|
||||
@@ -66,12 +65,15 @@ class AgendulaApp : Application(), Configuration.Provider {
|
||||
// v0.3.x install's tasks, both before anything reads a store.
|
||||
val startupGate = entryPoint.startupGate()
|
||||
val scope = entryPoint.applicationScope()
|
||||
// A switch rebuilds the alarms through ReminderRefresher, which hears it
|
||||
// as a store change. Channels only once startup's own null -> stored
|
||||
// transition is past, which the launch sync below covers.
|
||||
// An alarm is armed off whichever store was active when it was scheduled,
|
||||
// so a switch has to rebuild the set. Armed only once startup's own
|
||||
// null -> stored transition is past, which the launch sync below covers.
|
||||
val started = AtomicBoolean(false)
|
||||
entryPoint.providerResolver().onModeChanged {
|
||||
if (started.get()) runCatching { entryPoint.taskNotifier().refreshChannel() }
|
||||
if (started.get()) {
|
||||
scope.launch { runCatching { scheduler.sync() } }
|
||||
runCatching { entryPoint.taskNotifier().refreshChannel() }
|
||||
}
|
||||
}
|
||||
startupGate.start()
|
||||
refreshNotificationChannels()
|
||||
@@ -86,7 +88,6 @@ class AgendulaApp : Application(), Configuration.Provider {
|
||||
scheduler.sync()
|
||||
}
|
||||
runCatching { entryPoint.taskWidgetUpdater().start() }
|
||||
runCatching { entryPoint.reminderRefresher().start() }
|
||||
runCatching { entryPoint.providerSnapshotSource().start() }
|
||||
runCatching { ReminderMaintenanceWorker.schedule(this@AgendulaApp) }
|
||||
}
|
||||
@@ -123,7 +124,6 @@ class AgendulaApp : Application(), Configuration.Provider {
|
||||
fun taskNotifier(): TaskNotifier
|
||||
fun channelRefreshers(): Set<@JvmSuppressWildcards ChannelRefresher>
|
||||
fun taskWidgetUpdater(): TaskWidgetUpdater
|
||||
fun reminderRefresher(): ReminderRefresher
|
||||
fun providerSnapshotSource(): ProviderSnapshotSource
|
||||
}
|
||||
}
|
||||
@@ -16,7 +16,6 @@ import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.platform.LocalContext
|
||||
import androidx.core.net.toUri
|
||||
import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
|
||||
import de.jeanlucmakiola.agendula.data.prefs.is24Hour
|
||||
import de.jeanlucmakiola.agendula.ui.common.LocalFirstDayOfWeek
|
||||
import de.jeanlucmakiola.agendula.ui.common.LocalUse24HourFormat
|
||||
@@ -29,17 +28,15 @@ import de.jeanlucmakiola.agendula.data.di.LaunchHook
|
||||
import de.jeanlucmakiola.agendula.domain.SmartList
|
||||
import de.jeanlucmakiola.agendula.ui.imports.importIntentUri
|
||||
import de.jeanlucmakiola.agendula.ui.navigation.AppShortcuts
|
||||
import de.jeanlucmakiola.agendula.data.prefs.ThemeMode
|
||||
import de.jeanlucmakiola.agendula.ui.RootScreen
|
||||
import de.jeanlucmakiola.agendula.ui.crash.CrashReportActivity
|
||||
import de.jeanlucmakiola.agendula.ui.navigation.NavRequest
|
||||
import de.jeanlucmakiola.agendula.ui.settings.SettingsViewModel
|
||||
import de.jeanlucmakiola.agendula.ui.theme.AgendulaTheme
|
||||
import de.jeanlucmakiola.agendula.ui.theme.SystemTheme
|
||||
import de.jeanlucmakiola.floret.crash.CrashReportDialog
|
||||
import de.jeanlucmakiola.floret.crash.CrashReporter
|
||||
import de.jeanlucmakiola.floret.crash.submitCrashReport
|
||||
import kotlinx.coroutines.flow.distinctUntilChanged
|
||||
import kotlinx.coroutines.flow.map
|
||||
import kotlinx.coroutines.launch
|
||||
import javax.inject.Inject
|
||||
|
||||
@@ -53,8 +50,6 @@ class MainActivity : ComponentActivity() {
|
||||
|
||||
@Inject lateinit var launchHooks: Set<@JvmSuppressWildcards LaunchHook>
|
||||
|
||||
@Inject lateinit var settingsPrefs: SettingsPrefs
|
||||
|
||||
// A captured crash report awaiting the user's decision, surfaced as a dialog
|
||||
// over the app on the next launch (the single-crash path). A startup
|
||||
// crash-loop is handled out of band, before setContent — see below.
|
||||
@@ -78,13 +73,6 @@ class MainActivity : ComponentActivity() {
|
||||
enableEdgeToEdge()
|
||||
AppShortcuts.publish(this)
|
||||
|
||||
// The stored setting, never the view model's placeholder: a night mode
|
||||
// that flips back and forth would recreate the activity each time.
|
||||
lifecycleScope.launch {
|
||||
settingsPrefs.settings.map { it.themeMode to it.dynamicColor }.distinctUntilChanged()
|
||||
.collect { (mode, dynamicColor) -> SystemTheme.apply(this@MainActivity, mode, dynamicColor) }
|
||||
}
|
||||
|
||||
// Only on a fresh launch: after a rotation or process restore the intent
|
||||
// is the same old one and the back stack already holds its destination.
|
||||
val fromHistory = intent.flags and Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY != 0
|
||||
@@ -100,15 +88,15 @@ class MainActivity : ComponentActivity() {
|
||||
setContent {
|
||||
val settingsViewModel: SettingsViewModel = hiltViewModel()
|
||||
val ui by settingsViewModel.state.collectAsStateWithLifecycle()
|
||||
val darkTheme = ui.settings.themeMode.isDark(isSystemInDarkTheme())
|
||||
val darkTheme = when (ui.settings.themeMode) {
|
||||
ThemeMode.SYSTEM -> isSystemInDarkTheme()
|
||||
ThemeMode.LIGHT -> false
|
||||
ThemeMode.DARK -> true
|
||||
}
|
||||
val context = LocalContext.current
|
||||
val use24Hour = ui.settings.timeFormat.is24Hour(DateFormat.is24HourFormat(context))
|
||||
val firstDayOfWeek = ui.settings.weekStart ?: localeFirstDayOfWeek()
|
||||
AgendulaTheme(
|
||||
darkTheme = darkTheme,
|
||||
dynamicColor = ui.settings.dynamicColor,
|
||||
pureBlack = ui.settings.themeMode.isPureBlack,
|
||||
) {
|
||||
AgendulaTheme(darkTheme = darkTheme, dynamicColor = ui.settings.dynamicColor) {
|
||||
CompositionLocalProvider(
|
||||
LocalUse24HourFormat provides use24Hour,
|
||||
LocalFirstDayOfWeek provides firstDayOfWeek,
|
||||
@@ -117,7 +105,6 @@ class MainActivity : ComponentActivity() {
|
||||
modifier = Modifier.fillMaxSize(),
|
||||
navRequest = navRequest,
|
||||
onNavRequestConsumed = { navRequest = null },
|
||||
onReturnHome = ::finish,
|
||||
)
|
||||
pendingCrashReport?.let { report ->
|
||||
CrashReportDialog(
|
||||
@@ -166,9 +153,7 @@ class MainActivity : ComponentActivity() {
|
||||
private const val EXTRA_FILTER_ID = "de.jeanlucmakiola.agendula.extra.FILTER_ID"
|
||||
private const val EXTRA_SMART_LIST = "de.jeanlucmakiola.agendula.extra.SMART_LIST"
|
||||
private const val EXTRA_LIST_ID = "de.jeanlucmakiola.agendula.extra.LIST_ID"
|
||||
private const val EXTRA_RETURN_HOME = "de.jeanlucmakiola.agendula.extra.RETURN_HOME"
|
||||
private const val EXTRA_PRESET_LIST_ID = "de.jeanlucmakiola.agendula.extra.PRESET_LIST_ID"
|
||||
private const val EXTRA_DUE_TODAY = "de.jeanlucmakiola.agendula.extra.DUE_TODAY"
|
||||
private const val SHARED_TITLE_LIMIT = 500
|
||||
private const val NO_OCCURRENCE = -1L
|
||||
|
||||
@@ -176,16 +161,10 @@ class MainActivity : ComponentActivity() {
|
||||
* Opens a task's detail (reminder taps). [occurrenceStart] (epoch millis)
|
||||
* picks the occurrence of a recurring task.
|
||||
*/
|
||||
fun taskIntent(
|
||||
context: Context,
|
||||
taskId: Long,
|
||||
occurrenceStart: Long? = null,
|
||||
returnHome: Boolean = false,
|
||||
): Intent =
|
||||
fun taskIntent(context: Context, taskId: Long, occurrenceStart: Long? = null): Intent =
|
||||
Intent(context, MainActivity::class.java).apply {
|
||||
putExtra(EXTRA_TASK_ID, taskId)
|
||||
putExtra(EXTRA_OCCURRENCE_START, occurrenceStart ?: NO_OCCURRENCE)
|
||||
putExtra(EXTRA_RETURN_HOME, returnHome)
|
||||
addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
||||
}
|
||||
|
||||
@@ -197,17 +176,13 @@ class MainActivity : ComponentActivity() {
|
||||
|
||||
/**
|
||||
* The launcher shortcut's, Quick Settings tile's and a widget's "New
|
||||
* task". [listId] preset the list when it names exactly one, [dueToday]
|
||||
* the due date for a Today widget; the data URI keeps each widget's
|
||||
* PendingIntent apart from the others.
|
||||
* task". [listId] preset the list when it names exactly one; the data
|
||||
* URI keeps each widget's PendingIntent apart from the others.
|
||||
*/
|
||||
fun newTaskIntent(context: Context, listId: Long? = null, dueToday: Boolean = false): Intent {
|
||||
val path = listOfNotNull(listId?.toString(), "today".takeIf { dueToday }).joinToString("/")
|
||||
return Intent(ACTION_NEW_TASK, path.ifEmpty { null }?.let { "agendula://newtask/$it".toUri() }, context, MainActivity::class.java)
|
||||
fun newTaskIntent(context: Context, listId: Long? = null): Intent =
|
||||
Intent(ACTION_NEW_TASK, listId?.let { "agendula://newtask/$it".toUri() }, context, MainActivity::class.java)
|
||||
.putExtra(EXTRA_PRESET_LIST_ID, listId ?: -1L)
|
||||
.putExtra(EXTRA_DUE_TODAY, dueToday)
|
||||
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
||||
}
|
||||
|
||||
fun todayIntent(context: Context): Intent =
|
||||
Intent(ACTION_TODAY, null, context, MainActivity::class.java)
|
||||
@@ -241,8 +216,6 @@ class MainActivity : ComponentActivity() {
|
||||
when (intent.action) {
|
||||
ACTION_NEW_TASK -> return NavRequest.NewTask(
|
||||
listId = intent.getLongExtra(EXTRA_PRESET_LIST_ID, -1L).takeIf { it > 0L },
|
||||
dueToday = intent.getBooleanExtra(EXTRA_DUE_TODAY, false),
|
||||
returnHome = true,
|
||||
)
|
||||
ACTION_TODAY -> return NavRequest.OpenSmart(SmartList.TODAY)
|
||||
ACTION_OPEN_SMART -> intent.getStringExtra(EXTRA_SMART_LIST)
|
||||
@@ -257,12 +230,12 @@ class MainActivity : ComponentActivity() {
|
||||
if (intent.action == Intent.ACTION_SEND && intent.type?.startsWith("text/plain") == true) {
|
||||
val shared = intent.getStringExtra(Intent.EXTRA_SUBJECT)?.takeIf { it.isNotBlank() }
|
||||
?: intent.getStringExtra(Intent.EXTRA_TEXT)
|
||||
return NavRequest.NewTask(shared?.trim()?.take(SHARED_TITLE_LIMIT), returnHome = true)
|
||||
return NavRequest.NewTask(shared?.trim()?.take(SHARED_TITLE_LIMIT))
|
||||
}
|
||||
val taskId = intent.getLongExtra(EXTRA_TASK_ID, -1L).takeIf { it > 0L } ?: return null
|
||||
val occurrence = intent.getLongExtra(EXTRA_OCCURRENCE_START, NO_OCCURRENCE)
|
||||
.takeIf { it != NO_OCCURRENCE }
|
||||
return NavRequest.OpenTask(taskId, occurrence, intent.getBooleanExtra(EXTRA_RETURN_HOME, false))
|
||||
return NavRequest.OpenTask(taskId, occurrence)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,86 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.data.appname
|
||||
|
||||
import android.content.ComponentName
|
||||
import android.content.Context
|
||||
import android.content.pm.PackageManager
|
||||
import dagger.hilt.android.qualifiers.ApplicationContext
|
||||
import de.jeanlucmakiola.agendula.ui.navigation.AppShortcuts
|
||||
import javax.inject.Inject
|
||||
import javax.inject.Singleton
|
||||
|
||||
/** The label the launcher shows for the app (#104). */
|
||||
enum class LauncherName { AGENDULA, TASKS }
|
||||
|
||||
/** The two launcher aliases declared in the manifest. */
|
||||
enum class LauncherAlias { DEFAULT, TASKS }
|
||||
|
||||
/** One component-enable change in an [aliasWritePlan]. */
|
||||
data class AliasStateChange(val alias: LauncherAlias, val enabled: Boolean)
|
||||
|
||||
/**
|
||||
* Reads the `TasksNameAlias` enabled state as a [LauncherName]. Only an explicit
|
||||
* enable means "Tasks"; never toggled and disabled both mean the manifest default.
|
||||
*/
|
||||
fun launcherNameFor(tasksAliasState: Int): LauncherName =
|
||||
if (tasksAliasState == PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
|
||||
LauncherName.TASKS
|
||||
} else {
|
||||
LauncherName.AGENDULA
|
||||
}
|
||||
|
||||
/**
|
||||
* The steps to switch to [target]: enable the target alias first, then disable
|
||||
* the other, so the launcher can briefly see two entries but never none.
|
||||
*/
|
||||
fun aliasWritePlan(target: LauncherName): List<AliasStateChange> = when (target) {
|
||||
LauncherName.TASKS -> listOf(
|
||||
AliasStateChange(LauncherAlias.TASKS, enabled = true),
|
||||
AliasStateChange(LauncherAlias.DEFAULT, enabled = false),
|
||||
)
|
||||
LauncherName.AGENDULA -> listOf(
|
||||
AliasStateChange(LauncherAlias.DEFAULT, enabled = true),
|
||||
AliasStateChange(LauncherAlias.TASKS, enabled = false),
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Switches the launcher label by enabling one of the two `<activity-alias>`
|
||||
* components. The component state is the only source of truth; nothing is
|
||||
* stored in prefs.
|
||||
*/
|
||||
@Singleton
|
||||
class LauncherNameManager @Inject constructor(
|
||||
@ApplicationContext private val context: Context,
|
||||
) {
|
||||
private val packageManager: PackageManager get() = context.packageManager
|
||||
|
||||
// The package is the (suffixed) applicationId, the class is namespace-qualified.
|
||||
private fun component(alias: LauncherAlias): ComponentName {
|
||||
val simpleName = when (alias) {
|
||||
LauncherAlias.DEFAULT -> "DefaultNameAlias"
|
||||
LauncherAlias.TASKS -> "TasksNameAlias"
|
||||
}
|
||||
return ComponentName(context.packageName, "$NAMESPACE.$simpleName")
|
||||
}
|
||||
|
||||
fun current(): LauncherName =
|
||||
launcherNameFor(packageManager.getComponentEnabledSetting(component(LauncherAlias.TASKS)))
|
||||
|
||||
fun set(name: LauncherName) {
|
||||
for (change in aliasWritePlan(name)) {
|
||||
val state = if (change.enabled) {
|
||||
PackageManager.COMPONENT_ENABLED_STATE_ENABLED
|
||||
} else {
|
||||
PackageManager.COMPONENT_ENABLED_STATE_DISABLED
|
||||
}
|
||||
packageManager.setComponentEnabledSetting(component(change.alias), state, PackageManager.DONT_KILL_APP)
|
||||
}
|
||||
// Dynamic shortcuts hang off the launcher activity, which just changed.
|
||||
AppShortcuts.publish(context)
|
||||
}
|
||||
|
||||
private companion object {
|
||||
/** `namespace` in app/build.gradle.kts, not the suffixed applicationId. */
|
||||
const val NAMESPACE = "de.jeanlucmakiola.agendula"
|
||||
}
|
||||
}
|
||||
@@ -89,7 +89,7 @@ object DataProvideModule {
|
||||
// backed-up `.db` does not. The backup rules carry all three files and
|
||||
// the app checkpoints on ON_STOP.
|
||||
.setJournalMode(RoomDatabase.JournalMode.WRITE_AHEAD_LOGGING)
|
||||
.addMigrations(TasksDatabase.MIGRATION_1_2, TasksDatabase.MIGRATION_2_3, TasksDatabase.MIGRATION_3_4, TasksDatabase.MIGRATION_4_5)
|
||||
.addMigrations(TasksDatabase.MIGRATION_1_2, TasksDatabase.MIGRATION_2_3)
|
||||
.build()
|
||||
|
||||
/**
|
||||
|
||||
@@ -15,7 +15,6 @@ import de.jeanlucmakiola.agendula.domain.Task
|
||||
import de.jeanlucmakiola.agendula.domain.TaskFilter
|
||||
import de.jeanlucmakiola.agendula.domain.TaskFormField
|
||||
import de.jeanlucmakiola.agendula.domain.TaskReminder
|
||||
import de.jeanlucmakiola.agendula.domain.TaskSection
|
||||
import de.jeanlucmakiola.agendula.domain.asTaskReminder
|
||||
import de.jeanlucmakiola.agendula.domain.asReminderLead
|
||||
import de.jeanlucmakiola.agendula.domain.TaskSortOrder
|
||||
@@ -32,18 +31,7 @@ import kotlinx.coroutines.flow.map
|
||||
import javax.inject.Inject
|
||||
import javax.inject.Singleton
|
||||
|
||||
/** [BLACK] is dark with pure-black surfaces, for AMOLED screens. */
|
||||
enum class ThemeMode {
|
||||
SYSTEM, LIGHT, DARK, BLACK;
|
||||
|
||||
fun isDark(systemDark: Boolean): Boolean = when (this) {
|
||||
SYSTEM -> systemDark
|
||||
LIGHT -> false
|
||||
DARK, BLACK -> true
|
||||
}
|
||||
|
||||
val isPureBlack: Boolean get() = this == BLACK
|
||||
}
|
||||
enum class ThemeMode { SYSTEM, LIGHT, DARK }
|
||||
|
||||
/** Clock convention: AUTO follows the device's 24-hour switch. */
|
||||
enum class TimeFormatPref { AUTO, TWELVE_HOUR, TWENTY_FOUR_HOUR }
|
||||
@@ -55,7 +43,6 @@ fun TimeFormatPref.is24Hour(systemIs24Hour: Boolean): Boolean = when (this) {
|
||||
}
|
||||
|
||||
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)
|
||||
|
||||
/** The snooze lengths Settings offers. */
|
||||
val SNOOZE_PRESETS = listOf(5, 10, 15, 30, 60)
|
||||
@@ -116,8 +103,6 @@ data class Settings(
|
||||
val hiddenFromSmartLists: Set<Long> = emptySet(),
|
||||
/** Pre-fill a new task's start with today's date. */
|
||||
val defaultStartToday: Boolean = false,
|
||||
/** Task-list sections folded away; Done starts folded. */
|
||||
val collapsedSections: Set<TaskSection> = DEFAULT_COLLAPSED_SECTIONS,
|
||||
) {
|
||||
/** [tasks] as [filter] shows them: a smart list drops the lists kept out of it. */
|
||||
fun visibleIn(filter: TaskFilter, tasks: List<Task>): List<Task> =
|
||||
@@ -183,18 +168,9 @@ class SettingsPrefs @Inject constructor(
|
||||
.toSet()
|
||||
},
|
||||
defaultStartToday = p[DEFAULT_START_TODAY] ?: false,
|
||||
collapsedSections = p[COLLAPSED_SECTIONS]
|
||||
?.mapNotNull { name -> runCatching { TaskSection.valueOf(name) }.getOrNull() }
|
||||
?.toSet()
|
||||
?: DEFAULT_COLLAPSED_SECTIONS,
|
||||
)
|
||||
}
|
||||
|
||||
suspend fun setSectionCollapsed(section: TaskSection, collapsed: Boolean) = dataStore.edit { p ->
|
||||
val current = p[COLLAPSED_SECTIONS] ?: DEFAULT_COLLAPSED_SECTIONS.mapTo(HashSet()) { it.name }
|
||||
p[COLLAPSED_SECTIONS] = if (collapsed) current + section.name else current - section.name
|
||||
}
|
||||
|
||||
suspend fun setSortOrder(order: TaskSortOrder) = dataStore.edit { it[SORT_ORDER] = order.name }
|
||||
|
||||
suspend fun setSnoozeMinutes(minutes: Int) = dataStore.edit { it[SNOOZE_MINUTES] = minutes.coerceAtLeast(1) }
|
||||
@@ -352,7 +328,6 @@ class SettingsPrefs @Inject constructor(
|
||||
val PUSH_ENABLED = booleanPreferencesKey("push_enabled")
|
||||
val SMART_LIST_HIDDEN = stringSetPreferencesKey("smart_list_hidden")
|
||||
val DEFAULT_START_TODAY = booleanPreferencesKey("default_start_today")
|
||||
val COLLAPSED_SECTIONS = stringSetPreferencesKey("collapsed_sections")
|
||||
val SAVED_FILTERS = stringPreferencesKey("saved_filters")
|
||||
val SAVED_FILTER_NEXT_ID = longPreferencesKey("saved_filter_next_id")
|
||||
}
|
||||
|
||||
+12
-47
@@ -5,7 +5,6 @@ import android.content.Context
|
||||
import android.content.Intent
|
||||
import androidx.core.net.toUri
|
||||
import dagger.hilt.android.AndroidEntryPoint
|
||||
import de.jeanlucmakiola.agendula.data.prefs.Settings
|
||||
import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TaskQuery
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TasksDataSource
|
||||
@@ -16,7 +15,6 @@ import kotlinx.coroutines.SupervisorJob
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.launch
|
||||
import javax.inject.Inject
|
||||
import kotlin.time.Instant
|
||||
|
||||
/**
|
||||
* Fires when a task's reminder alarm goes off. Re-reads the task (it may have
|
||||
@@ -46,7 +44,8 @@ class DueReminderReceiver : BroadcastReceiver() {
|
||||
}
|
||||
val settings = settingsPrefs.settings.first()
|
||||
if (!settings.remindersEnabled) return@launch
|
||||
runCatching { notifier.postIfOpen(dataSource, taskId, occurrence, settings) }
|
||||
val task = runCatching { dataSource.occurrence(taskId, occurrence) }.getOrNull()
|
||||
if (task != null && !task.isClosed) notifier.postDue(task, settings)
|
||||
} finally {
|
||||
pending.finish()
|
||||
}
|
||||
@@ -75,51 +74,17 @@ class DueReminderReceiver : BroadcastReceiver() {
|
||||
/**
|
||||
* The occurrence of [taskId] anchored at [occurrenceStart] (epoch millis), or the
|
||||
* task's current one when there is no anchor or it can no longer be found.
|
||||
*
|
||||
* ⚠️ A ticked or edited occurrence is a row of its own with its own id, so
|
||||
* matching list rows on [taskId] misses it; [TasksDataSource.task] with the
|
||||
* anchor finds it by start. The list scan is for a provider whose exception
|
||||
* rows that lookup does not reach.
|
||||
* [TasksDataSource.task] alone resolves a series to whichever occurrence is
|
||||
* current, which is not necessarily the one a reminder was armed for.
|
||||
*/
|
||||
internal fun TasksDataSource.occurrence(taskId: Long, occurrenceStart: Long): Task? {
|
||||
val anchor = occurrenceStart.takeIf { it != ScheduledReminder.NO_OCCURRENCE }?.let(Instant::fromEpochMilliseconds)
|
||||
val found = task(taskId, anchor) ?: return null
|
||||
if (anchor == null || found.occurrenceStart == anchor) return found
|
||||
return tasks(TaskQuery(listId = found.listId, includeCompleted = true))
|
||||
.firstOrNull { (it.taskId == taskId || it.seriesId == taskId) && it.occurrenceStart == anchor }
|
||||
?: found
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether a reminder posted for [occurrenceStart] is done with, given [current]
|
||||
* as [occurrence] resolved it.
|
||||
*
|
||||
* - No task: gone, but only when [missingMeansGone] — a provider that fails a
|
||||
* read hands back nothing rather than throwing.
|
||||
* - [occurrenceStart] null: posted before reminders recorded their occurrence,
|
||||
* so only a task that does not recur can be judged.
|
||||
* - A lookup that fell back to another occurrence says nothing about the
|
||||
* reminded one, so it stays.
|
||||
*/
|
||||
internal fun reminderIsStale(occurrenceStart: Long?, current: Task?, missingMeansGone: Boolean): Boolean {
|
||||
if (current == null) return missingMeansGone
|
||||
val same = when (occurrenceStart) {
|
||||
null -> current.occurrenceStart == null
|
||||
ScheduledReminder.NO_OCCURRENCE -> true
|
||||
else -> current.occurrenceStart?.toEpochMilliseconds() == occurrenceStart
|
||||
val current = task(taskId) ?: return null
|
||||
if (occurrenceStart == ScheduledReminder.NO_OCCURRENCE ||
|
||||
current.occurrenceStart?.toEpochMilliseconds() == occurrenceStart
|
||||
) {
|
||||
return current
|
||||
}
|
||||
return same && current.isClosed
|
||||
}
|
||||
|
||||
/**
|
||||
* Posts the reminder for [taskId]'s occurrence if it is still open, then checks
|
||||
* once more: a completion landing between the read and the post may already
|
||||
* have had its withdrawal pass, which ran before there was anything to withdraw.
|
||||
*/
|
||||
internal fun TaskNotifier.postIfOpen(dataSource: TasksDataSource, taskId: Long, occurrenceStart: Long, settings: Settings) {
|
||||
val task = dataSource.occurrence(taskId, occurrenceStart) ?: return
|
||||
if (task.isClosed) return
|
||||
postDue(task, settings)
|
||||
val now = runCatching { dataSource.occurrence(taskId, occurrenceStart) }.getOrElse { return }
|
||||
if (now == null || now.isClosed) cancel(taskId)
|
||||
return tasks(TaskQuery(listId = current.listId, includeCompleted = true))
|
||||
.firstOrNull { it.taskId == taskId && it.occurrenceStart?.toEpochMilliseconds() == occurrenceStart }
|
||||
?: current
|
||||
}
|
||||
+4
-1
@@ -32,6 +32,7 @@ class ReminderActionReceiver : BroadcastReceiver() {
|
||||
|
||||
@Inject lateinit var notifier: TaskNotifier
|
||||
@Inject lateinit var snoozeScheduler: ReminderSnoozeScheduler
|
||||
@Inject lateinit var reminderScheduler: ReminderScheduler
|
||||
@Inject lateinit var repository: TasksRepository
|
||||
@Inject lateinit var dataSource: TasksDataSource
|
||||
@Inject lateinit var settingsPrefs: SettingsPrefs
|
||||
@@ -53,6 +54,7 @@ class ReminderActionReceiver : BroadcastReceiver() {
|
||||
val anchor = occurrence.takeIf { it != ScheduledReminder.NO_OCCURRENCE }
|
||||
?.let(Instant::fromEpochMilliseconds)
|
||||
repository.setCompleted(taskId, anchor, completed = true)
|
||||
reminderScheduler.sync()
|
||||
}
|
||||
|
||||
ACTION_SNOOZE -> runCatching {
|
||||
@@ -65,7 +67,8 @@ class ReminderActionReceiver : BroadcastReceiver() {
|
||||
val settings = settingsPrefs.settings.first()
|
||||
if (!settings.remindersEnabled) return@runCatching
|
||||
startupGate.awaitReady()
|
||||
notifier.postIfOpen(dataSource, taskId, occurrence, settings)
|
||||
val task = dataSource.occurrence(taskId, occurrence)
|
||||
if (task != null && !task.isClosed) notifier.postDue(task, settings)
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
|
||||
@@ -21,9 +21,7 @@ internal data class ReminderDiff(
|
||||
fired: Set<ScheduledReminder> = emptySet(),
|
||||
isArmed: (ScheduledReminder) -> Boolean,
|
||||
): ReminderDiff {
|
||||
// A fired entry counts even once the store dropped it, so a task
|
||||
// reopened within the grace does not ring again.
|
||||
val live = previous.filterTo(HashSet()) { it in fired || isArmed(it) } + fired
|
||||
val live = previous.filterTo(HashSet()) { it in fired || isArmed(it) }
|
||||
return ReminderDiff(
|
||||
cancel = live - desired,
|
||||
arm = desired - live,
|
||||
|
||||
@@ -1,35 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.data.reminders
|
||||
|
||||
import de.jeanlucmakiola.agendula.data.di.ApplicationScope
|
||||
import de.jeanlucmakiola.agendula.data.tasks.StoreChangeDebouncer
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TasksDataSource
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import javax.inject.Inject
|
||||
import javax.inject.Singleton
|
||||
|
||||
/**
|
||||
* Keeps reminders in step with the store: any change to tasks, lists or alarms —
|
||||
* a tick in the list or on a widget, a sync pulling in a completion from another
|
||||
* device, an edit, a store switch — runs one debounced [ReminderScheduler.sync].
|
||||
* Started once from `AgendulaApp`, after the startup gate, so it observes the
|
||||
* right store.
|
||||
*/
|
||||
@Singleton
|
||||
class ReminderRefresher @Inject constructor(
|
||||
dataSource: TasksDataSource,
|
||||
scheduler: ReminderScheduler,
|
||||
@ApplicationScope scope: CoroutineScope,
|
||||
) {
|
||||
private val changes = StoreChangeDebouncer(scope, DEBOUNCE_MILLIS, dataSource::registerTaskObserver) { scheduler.sync() }
|
||||
|
||||
fun start() {
|
||||
changes.start()
|
||||
}
|
||||
|
||||
/** Re-sync soon, folded into any pass a store change already asked for. */
|
||||
fun requestRefresh() = changes.request()
|
||||
|
||||
private companion object {
|
||||
const val DEBOUNCE_MILLIS = 1_000L
|
||||
}
|
||||
}
|
||||
@@ -8,7 +8,6 @@ import dagger.hilt.android.qualifiers.ApplicationContext
|
||||
import de.jeanlucmakiola.agendula.data.di.IoDispatcher
|
||||
import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
|
||||
import de.jeanlucmakiola.agendula.data.tasks.ProviderResolver
|
||||
import de.jeanlucmakiola.agendula.data.tasks.StorageMode
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TaskQuery
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TasksDataSource
|
||||
import kotlinx.coroutines.CoroutineDispatcher
|
||||
@@ -24,9 +23,8 @@ import javax.inject.Singleton
|
||||
* The self-scheduled due-reminder engine. Nothing else delivers task reminders —
|
||||
* not the platform, not a tasks provider — so Agendula reads upcoming due tasks
|
||||
* and arms one exact [AlarmManager] alarm per reminder, within a rolling window. Re-run
|
||||
* on app start, on boot, on a store switch and on every change to the store (see
|
||||
* [ReminderRefresher]); it diffs against [ScheduledReminderStore] so only changed
|
||||
* alarms move, and takes down posted reminders whose task is done with.
|
||||
* on app start, on boot, on a store switch, and on an external provider change;
|
||||
* it diffs against [ScheduledReminderStore] so only changed alarms move.
|
||||
*/
|
||||
@Singleton
|
||||
class ReminderScheduler @Inject constructor(
|
||||
@@ -36,7 +34,6 @@ class ReminderScheduler @Inject constructor(
|
||||
private val store: ScheduledReminderStore,
|
||||
private val providerResolver: ProviderResolver,
|
||||
private val snoozeScheduler: ReminderSnoozeScheduler,
|
||||
private val notifier: TaskNotifier,
|
||||
@IoDispatcher private val io: CoroutineDispatcher,
|
||||
) {
|
||||
private val syncLock = Mutex()
|
||||
@@ -68,23 +65,19 @@ class ReminderScheduler @Inject constructor(
|
||||
// Gate on whether the store is readable, not on whether a provider
|
||||
// resolves: our own store deliberately resolves to no provider, so the
|
||||
// latter clears every reminder in the default mode.
|
||||
val readable = providerResolver.canReadStore()
|
||||
if (!settings.remindersEnabled || !readable) {
|
||||
if (!settings.remindersEnabled || !providerResolver.canReadStore()) {
|
||||
clearAll()
|
||||
// Switched off, a reminder already up still goes when its task does.
|
||||
if (readable) withdrawStale()
|
||||
return
|
||||
}
|
||||
val tasks = runCatching { dataSource.tasks(TaskQuery(includeCompleted = false)) }
|
||||
.getOrElse { return }
|
||||
// Per-task leads. One query for all of them.
|
||||
val perTask = runCatching { dataSource.reminders() }.getOrElse { emptyMap() }
|
||||
val now = System.currentTimeMillis()
|
||||
val desired = ReminderPlanner.plan(
|
||||
tasks = tasks,
|
||||
perTask = perTask,
|
||||
settings = settings,
|
||||
now = now,
|
||||
now = System.currentTimeMillis(),
|
||||
zone = ZoneId.systemDefault(),
|
||||
)
|
||||
|
||||
@@ -99,10 +92,7 @@ class ReminderScheduler @Inject constructor(
|
||||
|
||||
// ⚠️ The store survives reboot, force-stop and restore; the alarms don't.
|
||||
// Trusting it alone left every reminder after a reboot unarmed for good.
|
||||
// ⚠️ Kept through the missed-reminder grace even once it drops out of
|
||||
// the plan: a tick undone a moment later would otherwise re-arm a
|
||||
// trigger in the past, and the reminder would ring a second time.
|
||||
val fired = store.fired().filterTo(HashSet()) { it in desired || it.triggerAt >= now - ReminderPlanner.MISSED_GRACE_MS }
|
||||
val fired = store.fired()
|
||||
val diff = ReminderDiff.of(store.all(), desired, fired) { !afterReboot && !rearm && isArmed(it) }
|
||||
diff.cancel.forEach { cancel(it) }
|
||||
// ⚠️ Only what was actually armed. A throw mid-loop used to skip the
|
||||
@@ -110,25 +100,7 @@ class ReminderScheduler @Inject constructor(
|
||||
// — uncancellable, and firing for tasks that no longer exist — and the
|
||||
// exception escaped into BootReceiver's goAsync().
|
||||
val armed = diff.arm.filter { schedule(it) }
|
||||
store.replace(diff.keep + armed, fired = fired, exact = canExact)
|
||||
withdrawStale()
|
||||
}
|
||||
|
||||
/**
|
||||
* A reminder already on screen outlives its alarm: completing the task in
|
||||
* the list, on a widget or on another device has to take it down too.
|
||||
*/
|
||||
private fun withdrawStale() {
|
||||
// Only our own store tells a deleted task from a failed read.
|
||||
val missingMeansGone = providerResolver.mode() == StorageMode.OWN
|
||||
runCatching {
|
||||
notifier.withdrawStale { taskId, occurrence ->
|
||||
runCatching {
|
||||
val current = dataSource.occurrence(taskId, occurrence ?: ScheduledReminder.NO_OCCURRENCE)
|
||||
reminderIsStale(occurrence, current, missingMeansGone)
|
||||
}.getOrDefault(false)
|
||||
}
|
||||
}
|
||||
store.replace(diff.keep + armed, fired = fired intersect desired, exact = canExact)
|
||||
}
|
||||
|
||||
/** Whether the system still holds this alarm's PendingIntent. */
|
||||
|
||||
@@ -10,7 +10,6 @@ import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.pm.PackageManager
|
||||
import android.os.Build
|
||||
import android.os.Bundle
|
||||
import android.text.format.DateFormat
|
||||
import androidx.core.app.NotificationCompat
|
||||
import androidx.core.app.NotificationManagerCompat
|
||||
@@ -104,11 +103,6 @@ class TaskNotifier @Inject constructor(
|
||||
.setPriority(NotificationCompat.PRIORITY_HIGH)
|
||||
.setAutoCancel(true)
|
||||
.setContentIntent(tapIntent)
|
||||
.addExtras(
|
||||
Bundle().apply {
|
||||
putLong(EXTRA_OCCURRENCE, task.occurrenceStart?.toEpochMilliseconds() ?: ScheduledReminder.NO_OCCURRENCE)
|
||||
},
|
||||
)
|
||||
.addAction(0, context.getString(R.string.reminder_action_done), actionIntent(task, ReminderActionReceiver.ACTION_DONE))
|
||||
.addAction(
|
||||
0,
|
||||
@@ -123,24 +117,6 @@ class TaskNotifier @Inject constructor(
|
||||
NotificationManagerCompat.from(context).cancel(taskId.toString(), NOTIFICATION_ID)
|
||||
}
|
||||
|
||||
/**
|
||||
* Takes down every posted reminder [isStale] says is done with — completed,
|
||||
* cancelled or deleted since it went off, here or on another device. The
|
||||
* occurrence is null for a reminder posted before it was recorded.
|
||||
*/
|
||||
fun withdrawStale(isStale: (taskId: Long, occurrenceStart: Long?) -> Boolean) {
|
||||
// Only the current store's: another store's task ids name other tasks.
|
||||
val prefix = "$LIST_CHANNEL_PREFIX${resolver.mode().name.lowercase()}_"
|
||||
manager.activeNotifications
|
||||
.filter { it.id == NOTIFICATION_ID && it.notification.channelId?.startsWith(prefix) == true }
|
||||
.forEach { posted ->
|
||||
val taskId = posted.tag?.toLongOrNull() ?: return@forEach
|
||||
val extras = posted.notification.extras
|
||||
val occurrence = if (extras.containsKey(EXTRA_OCCURRENCE)) extras.getLong(EXTRA_OCCURRENCE) else null
|
||||
if (isStale(taskId, occurrence)) cancel(taskId)
|
||||
}
|
||||
}
|
||||
|
||||
private fun actionIntent(task: Task, action: String): PendingIntent = PendingIntent.getBroadcast(
|
||||
context,
|
||||
task.taskId.toInt(),
|
||||
@@ -214,7 +190,6 @@ class TaskNotifier @Inject constructor(
|
||||
private const val LEGACY_CHANNEL_ID = "task_reminders"
|
||||
private const val LIST_CHANNEL_PREFIX = "reminders_"
|
||||
private const val NOTIFICATION_ID = 1
|
||||
private const val EXTRA_OCCURRENCE = "de.jeanlucmakiola.agendula.extra.OCCURRENCE_START"
|
||||
private const val CHANNEL_PREFS = "reminder_channels"
|
||||
private const val KEY_LEGACY_IMPORTANCE = "legacy_importance"
|
||||
|
||||
|
||||
@@ -1,23 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.data.sync
|
||||
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import kotlinx.coroutines.flow.StateFlow
|
||||
import kotlinx.coroutines.flow.flowOf
|
||||
|
||||
/** Pull to sync (#73): syncs every account at once. Inert in the `offline` flavor. */
|
||||
interface ManualSync {
|
||||
/** Whether there is anything to sync: our own store, with at least one account. */
|
||||
val available: Flow<Boolean>
|
||||
|
||||
/** True from [syncAll] until the syncs it started have finished. */
|
||||
val syncing: StateFlow<Boolean>
|
||||
|
||||
fun syncAll()
|
||||
|
||||
object None : ManualSync {
|
||||
override val available: Flow<Boolean> = flowOf(false)
|
||||
override val syncing: StateFlow<Boolean> = MutableStateFlow(false)
|
||||
override fun syncAll() = Unit
|
||||
}
|
||||
}
|
||||
@@ -2,5 +2,5 @@ package de.jeanlucmakiola.agendula.data.sync
|
||||
|
||||
/** Asks for an account to be synced now. A no-op in the `offline` flavor. */
|
||||
fun interface SyncRequests {
|
||||
suspend fun syncNow(accountId: Long)
|
||||
fun syncNow(accountName: String)
|
||||
}
|
||||
+80
-436
@@ -7,12 +7,9 @@ import android.content.ContentUris
|
||||
import android.content.ContentValues
|
||||
import android.content.Context
|
||||
import android.database.ContentObserver
|
||||
import android.database.Cursor
|
||||
import android.database.sqlite.SQLiteException
|
||||
import android.net.Uri
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import android.util.Log
|
||||
import dagger.hilt.android.qualifiers.ApplicationContext
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Instances
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Lists
|
||||
@@ -55,47 +52,14 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
// --- reads ----------------------------------------------------------------
|
||||
|
||||
override fun taskLists(): List<TaskList> {
|
||||
val authority = authority()
|
||||
val lists = resolver.query(TasksContract.listsUri(authority), TaskProjections.LISTS, null, null, null)?.use { c ->
|
||||
val uri = TasksContract.listsUri(authority())
|
||||
val sort = "${Lists.ACCOUNT_NAME}, ${Lists.NAME}"
|
||||
return resolver.query(uri, TaskProjections.LISTS, null, null, sort)?.use { c ->
|
||||
val reader = CursorColumnReader(c)
|
||||
buildList<TaskList> { while (c.moveToNext()) add(TaskMapper.taskList(reader)) }
|
||||
} ?: return emptyList()
|
||||
val order = synchronized(listOrderLock) {
|
||||
val stored = storedListOrder(authority)
|
||||
val known = lists.mapTo(HashSet()) { it.id }
|
||||
// A list gone from the provider takes its position along, as its id may be
|
||||
// reused — but not on an empty answer, which is as likely a provider mid-update.
|
||||
if (lists.isNotEmpty() && stored.keys.any { it !in known }) {
|
||||
stored.filterKeys { it in known }.also { storeListOrder(authority, it) }
|
||||
} else {
|
||||
stored
|
||||
}
|
||||
}
|
||||
return ListOrder.sorted(lists, order)
|
||||
buildList { while (c.moveToNext()) add(TaskMapper.taskList(reader)) }
|
||||
} ?: emptyList()
|
||||
}
|
||||
|
||||
/** The order Agendula keeps for [authority]'s lists. */
|
||||
internal fun storedListOrder(authority: String = authority()): Map<Long, Int> =
|
||||
ListOrder.decode(listOrder.getString(authority, null))
|
||||
|
||||
private val listOrder get() = context.getSharedPreferences(LIST_ORDER, Context.MODE_PRIVATE)
|
||||
|
||||
private fun storeListOrder(authority: String, order: Map<Long, Int>) {
|
||||
listOrder.edit().putString(authority, ListOrder.encode(order)).commit()
|
||||
}
|
||||
|
||||
/** Kept by Agendula, as the provider's lists table has no order of its own. */
|
||||
override fun reorderLists(listIds: List<Long>) {
|
||||
val authority = authority()
|
||||
synchronized(listOrderLock) {
|
||||
storeListOrder(authority, ListOrder.reordered(taskLists().map { it.id }, listIds))
|
||||
}
|
||||
// Wakes the observers on the lists without asking any sync adapter to upload: nothing changed in the provider.
|
||||
runCatching { resolver.notifyChange(TasksContract.listsUri(authority), null, 0) }
|
||||
}
|
||||
|
||||
private val listOrderLock = Any()
|
||||
|
||||
override fun tasks(query: TaskQuery): List<Task> {
|
||||
val clauses = mutableListOf<String>()
|
||||
val args = mutableListOf<String>()
|
||||
@@ -109,22 +73,14 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
}
|
||||
|
||||
override fun task(taskId: Long): Task? {
|
||||
roundLegacyAnchors()
|
||||
val rows = instanceRows(resolver.query(TasksContract.instancesUri(authority()), null, "${Instances.TASK_ID} = ?", arrayOf(taskId.toString()), null))
|
||||
return (rows.firstOrNull { it.task.distanceFromCurrent == 0 } ?: rows.firstOrNull())?.let { enrich(listOf(it)).single() }
|
||||
val rows = queryInstances("${Instances.TASK_ID} = ?", arrayOf(taskId.toString()))
|
||||
return rows.firstOrNull { it.distanceFromCurrent == 0 } ?: rows.firstOrNull()
|
||||
}
|
||||
|
||||
override fun task(taskId: Long, occurrenceStart: Instant?): Task? {
|
||||
if (occurrenceStart == null) return task(taskId)
|
||||
roundLegacyAnchors()
|
||||
val rows = instanceRows(queryOccurrences(taskId))
|
||||
val chosen = rows.firstOrNull { it.anchor == occurrenceStart }
|
||||
?: rows.firstOrNull { it.anchor?.let { a -> sameSecond(a, occurrenceStart) } == true }
|
||||
if (chosen != null) return enrich(listOf(chosen)).single()
|
||||
tickedCopy(taskId, occurrenceStart)?.let { copy -> return task(copy)?.copy(occurrenceStart = occurrenceStart) }
|
||||
// A plain task has one occurrence, whatever it was addressed by. A series
|
||||
// answers null rather than another occurrence a write would then land on.
|
||||
return if (seriesRules(listOf(taskId)).isEmpty()) task(taskId) else null
|
||||
val rows = queryInstances("${Instances.TASK_ID} = ?", arrayOf(taskId.toString()))
|
||||
return rows.firstOrNull { it.occurrenceStart == occurrenceStart } ?: task(taskId)
|
||||
}
|
||||
|
||||
override fun subtasks(parentTaskId: Long): List<Task> =
|
||||
@@ -151,74 +107,23 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
}
|
||||
} ?: emptyList()
|
||||
|
||||
/**
|
||||
* All columns and no sort: the instances view differs across provider
|
||||
* versions (tasks.org's has no `is_recurring`), the by-name mapper nulls what
|
||||
* is missing, and the repository re-sorts.
|
||||
*/
|
||||
private fun queryInstances(selection: String?, args: Array<String>?): List<Task> {
|
||||
roundLegacyAnchors()
|
||||
return instanceTasks(resolver.query(TasksContract.instancesUri(authority()), null, selection, args, null))
|
||||
}
|
||||
|
||||
/** Maps [cursor]'s instance rows, with the rule each series keeps on its `tasks` row, and their tags. */
|
||||
private fun instanceTasks(cursor: Cursor?): List<Task> = enrich(instanceRows(cursor))
|
||||
|
||||
/** [cursor]'s instance rows, before their rules and tags are looked up. */
|
||||
private fun instanceRows(cursor: Cursor?): List<InstanceRow> {
|
||||
var flagged = false
|
||||
val rows = cursor?.use { c ->
|
||||
flagged = c.getColumnIndex(Instances.IS_RECURRING) >= 0
|
||||
val reader = CursorColumnReader(c)
|
||||
buildList { while (c.moveToNext()) add(TaskMapper.instance(reader)) }
|
||||
}.orEmpty()
|
||||
// Where the provider flags recurrence, only flagged rows need their rule looked up.
|
||||
return if (flagged) rows.map { if (it.task.isRecurring) it else it.copy(ruleOwner = NO_RULE) } else rows
|
||||
}
|
||||
|
||||
/** [rows] completed with the rule each series keeps on its `tasks` row, and their tags. */
|
||||
private fun enrich(rows: List<InstanceRow>): List<Task> {
|
||||
if (rows.isEmpty()) return emptyList()
|
||||
val rules = seriesRules(rows.map { it.ruleOwner }.filter { it != NO_RULE })
|
||||
val tasks = rows.map { TaskMapper.withRule(it, rules[it.ruleOwner]) }
|
||||
val uri = TasksContract.instancesUri(authority())
|
||||
// projection = null (all columns): the instances view differs across
|
||||
// provider versions (e.g. tasks.org's bundled OpenTasks has no
|
||||
// `is_recurring` / `distance_from_current`). The by-name mapper reads
|
||||
// whatever is present and nulls the rest; the repository re-sorts, so we
|
||||
// don't depend on a provider sort column either.
|
||||
val tasks = resolver.query(uri, null, selection, args, null)
|
||||
?.use { c ->
|
||||
val reader = CursorColumnReader(c)
|
||||
buildList { while (c.moveToNext()) add(TaskMapper.task(reader)) }
|
||||
} ?: emptyList()
|
||||
if (tasks.isEmpty()) return tasks
|
||||
val tags = categories(tasks.map { it.taskId })
|
||||
return tasks.map { task -> tags[task.taskId]?.let { task.copy(tags = it) } ?: task }
|
||||
}
|
||||
|
||||
/** The recurrence of each of [taskIds] that is a series, keyed by task id. */
|
||||
private fun seriesRules(taskIds: Collection<Long>): Map<Long, SeriesRule> = queryByIds(
|
||||
TasksContract.tasksUri(authority()),
|
||||
arrayOf(Tasks.ID, Tasks.RRULE, Tasks.RDATE),
|
||||
Tasks.ID,
|
||||
taskIds,
|
||||
filter = "${Tasks.RRULE} IS NOT NULL OR ${Tasks.RDATE} IS NOT NULL",
|
||||
) { r -> r.getLong(Tasks.ID)?.let { id -> TaskMapper.seriesRule(r)?.let { id to it } } }.toMap()
|
||||
|
||||
/**
|
||||
* 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).
|
||||
*/
|
||||
private fun <T : Any> queryByIds(
|
||||
uri: Uri,
|
||||
projection: Array<String>,
|
||||
idColumn: String,
|
||||
ids: Collection<Long>,
|
||||
filter: String? = null,
|
||||
filterArgs: List<String> = emptyList(),
|
||||
sortOrder: String? = null,
|
||||
read: (ColumnReader) -> T?,
|
||||
): List<T> = ids.distinct().chunked(MAX_SQL_ARGS - filterArgs.size).flatMap { chunk ->
|
||||
val selection = buildString {
|
||||
append("$idColumn IN (${chunk.joinToString(",") { "?" }})")
|
||||
if (filter != null) append(" AND ($filter)")
|
||||
}
|
||||
val args = (chunk.map(Long::toString) + filterArgs).toTypedArray()
|
||||
resolver.query(uri, projection, selection, args, sortOrder)?.use { c ->
|
||||
val reader = CursorColumnReader(c)
|
||||
buildList { while (c.moveToNext()) read(reader)?.let(::add) }
|
||||
} ?: emptyList()
|
||||
}
|
||||
|
||||
override fun exportTasks(listId: Long): List<ExportTask> {
|
||||
// projection = null for the same reason queryInstances uses it: the tasks
|
||||
// table's shape varies across provider versions, and the by-name mapper
|
||||
@@ -289,7 +194,7 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
}
|
||||
|
||||
override fun updateSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>?) {
|
||||
val occurrence = occurrence(seriesId, occurrenceStart) { TaskMapper.instance(it).task } ?: task(seriesId)
|
||||
val occurrence = task(seriesId, occurrenceStart)
|
||||
val anchors = resolver.query(
|
||||
taskUri(authority(), seriesId), arrayOf(Tasks.DTSTART, Tasks.DUE), null, null, null,
|
||||
)?.use { c ->
|
||||
@@ -297,14 +202,14 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
val r = CursorColumnReader(c)
|
||||
r.getLong(Tasks.DTSTART) to r.getLong(Tasks.DUE)
|
||||
}
|
||||
val base = TaskWriteMapper.seriesValues(form, ZoneId.systemDefault().id)
|
||||
// Without an anchor to shift, the form's own value stands — already pinned for an all-day series.
|
||||
fun shifted(column: String, anchor: Long?, was: Instant?, now: Instant?): Any? =
|
||||
if (now == null || anchor == null || was == null) base[column]
|
||||
else providerMillis(anchor + (now - was).inWholeMilliseconds)
|
||||
val values = base +
|
||||
(Tasks.DTSTART to shifted(Tasks.DTSTART, anchors?.first, occurrence?.start, form.start)) +
|
||||
(Tasks.DUE to shifted(Tasks.DUE, anchors?.second, occurrence?.due, form.due))
|
||||
fun shifted(anchor: Long?, was: Instant?, now: Instant?): Long? = when {
|
||||
now == null -> null
|
||||
anchor == null || was == null -> now.toEpochMilliseconds()
|
||||
else -> anchor + (now - was).inWholeMilliseconds
|
||||
}
|
||||
val values = TaskWriteMapper.seriesValues(form, ZoneId.systemDefault().id) +
|
||||
(Tasks.DTSTART to shifted(anchors?.first, occurrence?.start, form.start)) +
|
||||
(Tasks.DUE to shifted(anchors?.second, occurrence?.due, form.due))
|
||||
val rows = resolver.update(taskUri(authority(), seriesId), values.toContentValues(), null, null)
|
||||
if (rows == 0) throw TaskWriteFailedException("update series $seriesId")
|
||||
setCategories(seriesId, form.tags)
|
||||
@@ -348,10 +253,9 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
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,
|
||||
rrule = r.getString(Tasks.RRULE)?.ifBlank { null },
|
||||
rdate = r.getString(Tasks.RDATE),
|
||||
exdate = r.getString(Tasks.EXDATE),
|
||||
anchor = Instant.fromEpochMilliseconds(anchor),
|
||||
isAllDay = r.getBoolean(Tasks.IS_ALLDAY),
|
||||
@@ -386,7 +290,7 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
buildList {
|
||||
while (c.moveToNext()) {
|
||||
val original = r.getLong(Tasks.ORIGINAL_INSTANCE_TIME) ?: continue
|
||||
if (providerMillis(original) >= providerMillis(from.toEpochMilliseconds())) r.getLong(Tasks.ID)?.let(::add)
|
||||
if (original >= from.toEpochMilliseconds()) r.getLong(Tasks.ID)?.let(::add)
|
||||
}
|
||||
}
|
||||
} ?: emptyList()
|
||||
@@ -398,10 +302,7 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
}
|
||||
|
||||
override fun updateInstance(taskId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>?) {
|
||||
val hit = instanceFor(taskId, occurrenceStart)
|
||||
?: throw TaskWriteFailedException("update instance $taskId@$occurrenceStart: no such occurrence")
|
||||
hit.overrideId?.let { return updateOverride(it, form, reminders) }
|
||||
if (reminders == null) return writeInstance(taskId, hit.instanceId, form)
|
||||
if (reminders == null) return writeInstance(taskId, occurrenceStart, form)
|
||||
// ⚠️ Written to the series, and then put back. Forking an occurrence
|
||||
// copies the task's *current* properties onto the new override row, so
|
||||
// setting the alarm beforehand is the only way to carry it across — and
|
||||
@@ -410,26 +311,15 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
val seriesReminders = alarmRows(taskId).map { it.second }
|
||||
writeReminders(taskId, reminders)
|
||||
try {
|
||||
writeInstance(taskId, hit.instanceId, form)
|
||||
writeInstance(taskId, occurrenceStart, form)
|
||||
} finally {
|
||||
setReminders(taskId, seriesReminders)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* An occurrence that already has its own row is written there directly. The
|
||||
* fork-and-restore dance in [updateInstance] would put its old tags and
|
||||
* reminders back over the new ones.
|
||||
*/
|
||||
private fun updateOverride(overrideId: Long, form: TaskForm, reminders: List<TaskReminder>?) {
|
||||
val values = TaskWriteMapper.instanceValues(form, ZoneId.systemDefault().id)
|
||||
val rows = resolver.update(taskUri(authority(), overrideId), values.toContentValues(), null, null)
|
||||
if (rows == 0) throw TaskWriteFailedException("update override $overrideId")
|
||||
setCategories(overrideId, form.tags)
|
||||
writeReminders(overrideId, reminders)
|
||||
}
|
||||
|
||||
private fun writeInstance(taskId: Long, instanceId: Long, form: TaskForm) {
|
||||
private fun writeInstance(taskId: Long, occurrenceStart: Instant, form: TaskForm) {
|
||||
val instanceId = instanceIdFor(taskId, occurrenceStart)
|
||||
?: throw TaskWriteFailedException("update instance $taskId@$occurrenceStart: no such occurrence")
|
||||
val values = TaskWriteMapper.instanceValues(form, ZoneId.systemDefault().id)
|
||||
val uri = TasksContract.instanceUri(authority(), instanceId)
|
||||
// The fork copies the series' properties onto the override, so the tags
|
||||
@@ -456,147 +346,28 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
}
|
||||
}
|
||||
|
||||
/** An occurrence's instance row, and the override row behind it if it has one. */
|
||||
private class InstanceHit(val instanceId: Long, val overrideId: Long?)
|
||||
|
||||
/**
|
||||
* The provider's instance row for one occurrence.
|
||||
* The provider's instance row id for one occurrence.
|
||||
*
|
||||
* The seam addresses occurrences by `(taskId, occurrenceStart)`; writing
|
||||
* through the instances URI still needs the row id, so it is looked up here
|
||||
* rather than carried around above the data layer.
|
||||
* rather than carried around above the data layer. Selection is on `task_id`
|
||||
* only — the anchor is matched in Kotlin because the column that holds it
|
||||
* (`instance_original_time`) is missing on older provider schemas, where a
|
||||
* WHERE clause naming it would throw instead of falling back.
|
||||
*/
|
||||
private fun instanceFor(taskId: Long, occurrenceStart: Instant): InstanceHit? {
|
||||
roundLegacyAnchors()
|
||||
return occurrence(taskId, occurrenceStart) { r ->
|
||||
r.getLong(Tasks.ID)?.let { id ->
|
||||
InstanceHit(id, r.getLong(Instances.TASK_ID)?.takeIf { r.getLong(Tasks.ORIGINAL_INSTANCE_ID) != null })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun instanceIdFor(taskId: Long, occurrenceStart: Instant): Long? = instanceFor(taskId, occurrenceStart)?.instanceId
|
||||
|
||||
/**
|
||||
* [read] applied to the instance row of [taskId]'s occurrence at
|
||||
* [occurrenceStart] — its own, or an override's that replaced it — matched in
|
||||
* whole seconds, as the provider expands them. The anchor is matched in
|
||||
* Kotlin because `instance_original_time` is missing on older schemas.
|
||||
*/
|
||||
private fun <T> occurrence(taskId: Long, occurrenceStart: Instant, read: (ColumnReader) -> T): T? =
|
||||
queryOccurrences(taskId)?.use { c ->
|
||||
private fun instanceIdFor(taskId: Long, occurrenceStart: Instant): Long? {
|
||||
val uri = TasksContract.instancesUri(authority())
|
||||
val selection = "${Instances.TASK_ID} = ?"
|
||||
return resolver.query(uri, null, selection, arrayOf(taskId.toString()), null)?.use { c ->
|
||||
val reader = CursorColumnReader(c)
|
||||
// An exact match first: a row of the same second is a fallback, not a peer.
|
||||
var near: Int? = null
|
||||
while (c.moveToNext()) {
|
||||
val anchor = TaskMapper.occurrenceAnchor(reader) ?: continue
|
||||
if (anchor == occurrenceStart) return@use read(reader)
|
||||
if (near == null && sameSecond(anchor, occurrenceStart)) near = c.position
|
||||
}
|
||||
near?.let { c.moveToPosition(it); read(reader) }
|
||||
}
|
||||
|
||||
/**
|
||||
* Instance rows of [taskId] and of the overrides standing in for its
|
||||
* occurrences. A provider whose view lacks `original_instance_id` gets the
|
||||
* task's own rows only, rather than a failed query.
|
||||
*/
|
||||
private fun queryOccurrences(taskId: Long): Cursor? {
|
||||
val authority = authority()
|
||||
val uri = TasksContract.instancesUri(authority)
|
||||
val id = taskId.toString()
|
||||
if (ownRowsOnlyFor != authority) {
|
||||
try {
|
||||
return resolver.query(uri, null, OCCURRENCE_OF, arrayOf(id, id), null)
|
||||
} catch (e: SQLiteException) {
|
||||
rememberIfMissingColumn(authority, e)
|
||||
} catch (e: IllegalArgumentException) {
|
||||
rememberIfMissingColumn(authority, e)
|
||||
}
|
||||
}
|
||||
return resolver.query(uri, null, "${Instances.TASK_ID} = ?", arrayOf(id), null)
|
||||
}
|
||||
|
||||
/** Only a view without the column is remembered; any other failure falls back for this query alone. */
|
||||
private fun rememberIfMissingColumn(authority: String, e: Exception) {
|
||||
val message = e.message.orEmpty()
|
||||
if (Tasks.ORIGINAL_INSTANCE_ID in message || "no such column" in message || "Invalid column" in message) {
|
||||
ownRowsOnlyFor = authority
|
||||
} else {
|
||||
Log.w(TAG, "Occurrence query failed, reading the task's own rows", e)
|
||||
}
|
||||
}
|
||||
|
||||
/** The provider whose instances view turned out to lack `original_instance_id`. */
|
||||
@Volatile
|
||||
private var ownRowsOnlyFor: String? = null
|
||||
|
||||
@Volatile
|
||||
private var anchorsRoundedFor: String? = null
|
||||
|
||||
private val roundingLock = Any()
|
||||
|
||||
/**
|
||||
* Rounds the DTSTART/DUE a build before [providerMillis] stored with
|
||||
* milliseconds, which the provider cannot move past a completed occurrence.
|
||||
* Once per provider, before the first read: concurrent readers wait for it.
|
||||
* Written as the rows' sync adapter, since the server only ever had whole
|
||||
* seconds, so nothing is dirtied or re-uploaded. Overrides need nothing: the
|
||||
* provider forks them at its own whole-second instance times.
|
||||
*
|
||||
* Never fails a read. A row the provider refuses is left as it was and tried
|
||||
* again on the next start; only a pass that rounded everything is remembered.
|
||||
*/
|
||||
private fun roundLegacyAnchors() {
|
||||
val authority = authority()
|
||||
if (anchorsRoundedFor == authority) return
|
||||
synchronized(roundingLock) {
|
||||
if (anchorsRoundedFor == authority) return
|
||||
val prefs = context.getSharedPreferences(MIGRATIONS, Context.MODE_PRIVATE)
|
||||
val key = "anchors_rounded:$authority"
|
||||
val done = prefs.getBoolean(key, false) || runCatching { roundAll(authority) }
|
||||
.onFailure { Log.w(TAG, "Rounding legacy anchors failed", it) }
|
||||
.getOrDefault(false)
|
||||
if (done) prefs.edit().putBoolean(key, true).apply()
|
||||
anchorsRoundedFor = authority
|
||||
}
|
||||
}
|
||||
|
||||
/** True when every stale row was rounded. */
|
||||
private fun roundAll(authority: String): Boolean {
|
||||
val columns = listOf(Tasks.DTSTART, Tasks.DUE)
|
||||
val ops = resolver.query(
|
||||
TasksContract.tasksUri(authority),
|
||||
arrayOf(Tasks.ID, Tasks.ACCOUNT_NAME, Tasks.ACCOUNT_TYPE) + columns,
|
||||
// Only series: the provider moves nothing else, so nothing else needs rounding.
|
||||
"(${columns.joinToString(" OR ") { "$it % 1000 != 0" }}) AND (${Tasks.RRULE} IS NOT NULL OR ${Tasks.RDATE} IS NOT NULL)",
|
||||
null,
|
||||
null,
|
||||
)?.use { c ->
|
||||
val r = CursorColumnReader(c)
|
||||
buildList<ContentProviderOperation> {
|
||||
while (c.moveToNext()) {
|
||||
val id = r.getLong(Tasks.ID) ?: continue
|
||||
val values = buildMap<String, Any?> {
|
||||
for (column in columns) {
|
||||
val millis = r.getLong(column) ?: continue
|
||||
if (providerMillis(millis) != millis) put(column, providerMillis(millis))
|
||||
}
|
||||
}
|
||||
val name = r.getString(Tasks.ACCOUNT_NAME)
|
||||
val type = r.getString(Tasks.ACCOUNT_TYPE)
|
||||
val uri = if (name.isNullOrEmpty() || type.isNullOrEmpty()) taskUri(authority, id)
|
||||
else TasksContract.asSyncAdapter(taskUri(authority, id), name, type)
|
||||
add(ContentProviderOperation.newUpdate(uri).withValues(values.toContentValues()).build())
|
||||
if (TaskMapper.occurrenceAnchor(reader) == occurrenceStart) {
|
||||
return@use reader.getLong(Tasks.ID)
|
||||
}
|
||||
}
|
||||
} ?: return false
|
||||
if (ops.isEmpty()) return true
|
||||
val batch = runCatching { resolver.applyBatch(authority, ArrayList(ops)) }.getOrNull()
|
||||
if (batch != null) return batch.all { (it.count ?: 0) > 0 }
|
||||
// One refused row fails the whole batch; row by row, the rest still go.
|
||||
return ops.map { op -> runCatching { resolver.applyBatch(authority, arrayListOf(op)).single().count ?: 0 }.getOrDefault(0) > 0 }
|
||||
.all { it }
|
||||
null
|
||||
}
|
||||
}
|
||||
|
||||
override fun setReminders(taskId: Long, reminders: List<TaskReminder>) {
|
||||
@@ -659,19 +430,29 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
}
|
||||
|
||||
/** Tags by task id for [taskIds], in stored order. */
|
||||
private fun categories(taskIds: Collection<Long>): Map<Long, List<String>> = queryByIds(
|
||||
TasksContract.propertiesUri(authority()),
|
||||
arrayOf(Properties.TASK_ID, TasksContract.Category.NAME),
|
||||
Properties.TASK_ID,
|
||||
taskIds,
|
||||
filter = "${Properties.MIMETYPE} = ?",
|
||||
filterArgs = listOf(TasksContract.Category.MIMETYPE),
|
||||
sortOrder = Properties.PROPERTY_ID,
|
||||
) { r ->
|
||||
val id = r.getLong(Properties.TASK_ID)
|
||||
val name = r.getString(TasksContract.Category.NAME)
|
||||
if (id == null || name == null) null else id to name
|
||||
}.groupBy({ it.first }, { it.second }).mapValues { normalizeTags(it.value) }
|
||||
private fun categories(taskIds: Collection<Long>): Map<Long, List<String>> {
|
||||
val rows = taskIds.distinct().chunked(MAX_SQL_ARGS - 1).flatMap { chunk ->
|
||||
val selection = "${Properties.MIMETYPE} = ? AND ${Properties.TASK_ID} IN (${chunk.joinToString(",") { "?" }})"
|
||||
val args = (listOf(TasksContract.Category.MIMETYPE) + chunk.map(Long::toString)).toTypedArray()
|
||||
resolver.query(
|
||||
TasksContract.propertiesUri(authority()),
|
||||
arrayOf(Properties.TASK_ID, TasksContract.Category.NAME),
|
||||
selection,
|
||||
args,
|
||||
Properties.PROPERTY_ID,
|
||||
)?.use { c ->
|
||||
val reader = CursorColumnReader(c)
|
||||
buildList {
|
||||
while (c.moveToNext()) {
|
||||
val id = reader.getLong(Properties.TASK_ID) ?: continue
|
||||
val name = reader.getString(TasksContract.Category.NAME) ?: continue
|
||||
add(id to name)
|
||||
}
|
||||
}
|
||||
} ?: emptyList()
|
||||
}
|
||||
return rows.groupBy({ it.first }, { it.second }).mapValues { normalizeTags(it.value) }
|
||||
}
|
||||
|
||||
/**
|
||||
* Replaces [taskId]'s category rows in one batch, so a refused insert cannot
|
||||
@@ -701,21 +482,16 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
}
|
||||
|
||||
override fun setCancelled(taskId: Long, cancelled: Boolean) {
|
||||
if (!cancelled && movedBack(taskId, null)) return
|
||||
val rows = resolver.update(taskUri(authority(), taskId), cancelValues(cancelled).toContentValues(), null, null)
|
||||
if (rows == 0) throw TaskWriteFailedException("cancel task $taskId")
|
||||
}
|
||||
|
||||
/** Through the instances URI, like [setCompletedInstance]. */
|
||||
override fun setCancelledInstance(taskId: Long, occurrenceStart: Instant, cancelled: Boolean) {
|
||||
if (!cancelled && movedBack(taskId, occurrenceStart)) return
|
||||
val instanceId = instanceIdFor(taskId, occurrenceStart)
|
||||
?: return tickedCopy(taskId, occurrenceStart)?.let { setCancelled(it, cancelled) }
|
||||
?: plainUnlessSeries(taskId, occurrenceStart) { setCancelled(taskId, cancelled) }
|
||||
?: return setCancelled(taskId, cancelled)
|
||||
val uri = TasksContract.instanceUri(authority(), instanceId)
|
||||
val rows = rememberingCopy(taskId, occurrenceStart, closing = cancelled) {
|
||||
resolver.update(uri, cancelValues(cancelled).toContentValues(), null, null)
|
||||
}
|
||||
val rows = resolver.update(uri, cancelValues(cancelled).toContentValues(), null, null)
|
||||
if (rows == 0) throw TaskWriteFailedException("cancel instance $instanceId")
|
||||
}
|
||||
|
||||
@@ -725,7 +501,6 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
)
|
||||
|
||||
override fun setCompleted(taskId: Long, completed: Boolean) {
|
||||
if (!completed && movedBack(taskId, null)) return
|
||||
val values = TaskWriteMapper.completionValues(completed, System.currentTimeMillis())
|
||||
val rows = resolver.update(taskUri(authority(), taskId), values.toContentValues(), null, null)
|
||||
if (rows == 0) throw TaskWriteFailedException("complete task $taskId")
|
||||
@@ -733,133 +508,22 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
|
||||
/**
|
||||
* Through the instances URI, which is what makes the provider fork an override
|
||||
* rather than close the series. No instance row for the anchor on a task that
|
||||
* is not a series means the plain write is the right one.
|
||||
* rather than close the series. No instance row for the anchor means the task
|
||||
* is not a series after all — the plain write is then the right one.
|
||||
*/
|
||||
override fun setCompletedInstance(taskId: Long, occurrenceStart: Instant, completed: Boolean) {
|
||||
if (!completed && movedBack(taskId, occurrenceStart)) return
|
||||
val instanceId = instanceIdFor(taskId, occurrenceStart)
|
||||
?: return tickedCopy(taskId, occurrenceStart)?.let { setCompleted(it, completed) }
|
||||
?: plainUnlessSeries(taskId, occurrenceStart) { setCompleted(taskId, completed) }
|
||||
?: return setCompleted(taskId, completed)
|
||||
val values = TaskWriteMapper.completionValues(completed, System.currentTimeMillis())
|
||||
val uri = TasksContract.instanceUri(authority(), instanceId)
|
||||
val rows = rememberingCopy(taskId, occurrenceStart, closing = completed) {
|
||||
resolver.update(uri, values.toContentValues(), null, null)
|
||||
}
|
||||
val rows = resolver.update(uri, values.toContentValues(), null, null)
|
||||
if (rows == 0) throw TaskWriteFailedException("complete instance $instanceId")
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
private fun rememberingCopy(taskId: Long, occurrenceStart: Instant, closing: Boolean, write: () -> Int): Int {
|
||||
if (!closing) return write()
|
||||
val authority = authority()
|
||||
val lastId = runCatching { lastTaskId(authority) }.getOrNull() ?: return write()
|
||||
val before = runCatching { seriesState(authority, taskId) }.getOrNull()
|
||||
return write().also { rows ->
|
||||
if (rows > 0) {
|
||||
runCatching {
|
||||
detachedSince(authority, lastId)?.let { copy ->
|
||||
val after = before?.let { seriesState(authority, taskId) }?.takeIf { it != before }
|
||||
val tick = Tick(copy, taskId.takeIf { after != null }, before.takeIf { after != null }, after, System.currentTimeMillis())
|
||||
ticks.put(ticks.key(authority, taskId, occurrenceStart), tick)
|
||||
}
|
||||
}.onFailure { Log.w(TAG, "Looking up the detached copy failed", it) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Undoes the tick that left [taskId]'s occurrence at [occurrenceStart] — or,
|
||||
* with no occurrence, the tick that left the copy [taskId]: the series goes
|
||||
* back where it was and the copy goes, as long as the series is still where
|
||||
* the tick moved it and the copy has nothing filed under it. False when it
|
||||
* cannot, so the caller reopens the copy as a task of its own.
|
||||
*/
|
||||
private fun movedBack(taskId: Long, occurrenceStart: Instant?): Boolean = runCatching {
|
||||
val authority = authority()
|
||||
val (key, tick) = occurrenceStart?.let { at -> ticks.key(authority, taskId, at).let { k -> ticks.get(k)?.let { k to it } } }
|
||||
?: ticks.forCopy(authority, taskId)
|
||||
?: return false
|
||||
val series = tick.seriesId ?: return false
|
||||
val before = tick.before ?: return false
|
||||
if (seriesState(authority, series) != tick.after || subtaskIds(tick.copyId).isNotEmpty()) return false
|
||||
val restore = before.filter { (column, value) -> tick.after?.get(column) != value }
|
||||
val ops = arrayListOf(
|
||||
ContentProviderOperation.newUpdate(taskUri(authority, series)).withValues(restore.toContentValues()).build(),
|
||||
ContentProviderOperation.newDelete(taskUri(authority, tick.copyId)).build(),
|
||||
)
|
||||
resolver.applyBatch(authority, ops)
|
||||
ticks.remove(key)
|
||||
true
|
||||
}.onFailure { Log.w(TAG, "Moving the series back failed", it) }.getOrDefault(false)
|
||||
|
||||
/** The columns a tick moves a series by, or null when [taskId] is no series. */
|
||||
private fun seriesState(authority: String, taskId: Long): Map<String, Any?>? {
|
||||
if (seriesRules(listOf(taskId)).isEmpty()) return null
|
||||
return resolver.query(taskUri(authority, taskId), SERIES_STATE, null, null, null)?.use { c ->
|
||||
if (!c.moveToFirst()) return@use null
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun lastTaskId(authority: String): Long =
|
||||
resolver.query(TasksContract.tasksUri(authority), arrayOf(Tasks.ID), null, null, "${Tasks.ID} DESC")
|
||||
?.use { c -> if (c.moveToFirst()) c.getLong(0) else 0L } ?: 0L
|
||||
|
||||
/** The one plain task the provider created after [afterId], or null when it was not exactly one. */
|
||||
private fun detachedSince(authority: String, afterId: Long): Long? =
|
||||
resolver.query(TasksContract.tasksUri(authority), null, "${Tasks.ID} > ?", arrayOf(afterId.toString()), null)
|
||||
?.use { c ->
|
||||
val r = CursorColumnReader(c)
|
||||
buildList {
|
||||
while (c.moveToNext()) {
|
||||
val plain = r.getString(Tasks.RRULE) == null && r.getString(Tasks.RDATE) == null &&
|
||||
r.getLong(Tasks.ORIGINAL_INSTANCE_ID) == null
|
||||
if (plain) r.getLong(Tasks.ID)?.let(::add)
|
||||
}
|
||||
}
|
||||
}?.singleOrNull()
|
||||
|
||||
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? =
|
||||
ticks.get(ticks.key(authority(), taskId, occurrenceStart))?.copyId
|
||||
|
||||
/**
|
||||
* [write] for a task that turned out not to be a series. A series whose
|
||||
* occurrence was not found fails instead: the plain write would close all of it.
|
||||
*/
|
||||
private fun plainUnlessSeries(taskId: Long, occurrenceStart: Instant, write: () -> Unit) {
|
||||
if (seriesRules(listOf(taskId)).isNotEmpty()) {
|
||||
throw TaskWriteFailedException("instance $taskId@$occurrenceStart: no such occurrence")
|
||||
}
|
||||
write()
|
||||
}
|
||||
|
||||
override fun deleteTask(taskId: Long) {
|
||||
resolver.delete(taskUri(authority(), taskId), null, null)
|
||||
}
|
||||
|
||||
/**
|
||||
* Through its instance, which the provider turns into an EXDATE on the master,
|
||||
* as the Room store does. Deleting the row alone leaves the master without one.
|
||||
*/
|
||||
override fun deleteOverride(taskId: Long, occurrenceStart: Instant) {
|
||||
val instanceId = instanceIdFor(taskId, occurrenceStart) ?: return deleteTask(taskId)
|
||||
resolver.delete(TasksContract.instanceUri(authority(), instanceId), null, null)
|
||||
}
|
||||
|
||||
override fun createLocalList(name: String, color: Int): Long {
|
||||
val uri = TasksContract.asSyncAdapter(
|
||||
TasksContract.listsUri(authority()),
|
||||
@@ -930,25 +594,5 @@ class AndroidTasksDataSource @Inject constructor(
|
||||
}
|
||||
}
|
||||
|
||||
private const val LIST_ORDER = "provider_list_order"
|
||||
|
||||
/** An instance row of the task, or of an override standing in for one of its occurrences. */
|
||||
private const val OCCURRENCE_OF = "${Instances.TASK_ID} = ? OR ${Tasks.ORIGINAL_INSTANCE_ID} = ?"
|
||||
|
||||
private const val MIGRATIONS = "provider_migrations"
|
||||
|
||||
private const val TICKED_COPIES = "provider_ticked_copies"
|
||||
|
||||
/** What a tick changes on a series, and an undo changes back. */
|
||||
private val SERIES_STATE = arrayOf(
|
||||
Tasks.DTSTART, Tasks.DUE, Tasks.DURATION, Tasks.RRULE, Tasks.RDATE, Tasks.EXDATE,
|
||||
Tasks.STATUS, Tasks.COMPLETED, Tasks.PERCENT_COMPLETE,
|
||||
)
|
||||
|
||||
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
|
||||
@@ -1,36 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.data.tasks
|
||||
|
||||
import de.jeanlucmakiola.agendula.domain.TaskList
|
||||
|
||||
/**
|
||||
* Agendula's own order for an external provider's lists, which the provider has
|
||||
* no column for. Stored as `id=position` pairs. A list without one counts as
|
||||
* position 0, as a new list does in Agendula's own store.
|
||||
*/
|
||||
object ListOrder {
|
||||
|
||||
fun decode(raw: String?): Map<Long, Int> = raw.orEmpty().split(',').mapNotNull { pair ->
|
||||
val (id, position) = pair.split('=').takeIf { it.size == 2 } ?: return@mapNotNull null
|
||||
id.toLongOrNull()?.let { key -> position.toIntOrNull()?.let { key to it } }
|
||||
}.toMap()
|
||||
|
||||
fun encode(order: Map<Long, Int>): String = order.entries.joinToString(",") { "${it.key}=${it.value}" }
|
||||
|
||||
/**
|
||||
* Positions for every list in [shown] — the lists in their current order —
|
||||
* after one account's [listIds] were rearranged: those take each other's
|
||||
* slots in their new order, and every other list keeps its own.
|
||||
*/
|
||||
fun reordered(shown: List<Long>, listIds: List<Long>): Map<Long, Int> {
|
||||
val moved = listIds.iterator()
|
||||
val moving = listIds.toSet()
|
||||
val result = shown.map { if (it in moving && moved.hasNext()) moved.next() else it }.toMutableList()
|
||||
moved.forEachRemaining { if (it !in result) result += it }
|
||||
return result.withIndex().associate { it.value to it.index }
|
||||
}
|
||||
|
||||
fun sorted(lists: List<TaskList>, order: Map<Long, Int>): List<TaskList> = lists.sortedWith(
|
||||
compareBy<TaskList>({ it.accountName.lowercase() }, { order[it.id] ?: 0 }, { it.name.lowercase() })
|
||||
.thenBy { it.name },
|
||||
)
|
||||
}
|
||||
+3
-10
@@ -67,7 +67,6 @@ class ModeRoutingTasksDataSource(
|
||||
active().setCancelledInstance(taskId, occurrenceStart, cancelled)
|
||||
|
||||
override fun deleteTask(taskId: Long) = active().deleteTask(taskId)
|
||||
override fun deleteOverride(taskId: Long, occurrenceStart: Instant) = active().deleteOverride(taskId, occurrenceStart)
|
||||
override fun createLocalList(name: String, color: Int): Long = active().createLocalList(name, color)
|
||||
override fun updateList(listId: Long, name: String, color: Int) = active().updateList(listId, name, color)
|
||||
override fun deleteList(listId: Long) = active().deleteList(listId)
|
||||
@@ -82,22 +81,16 @@ class ModeRoutingTasksDataSource(
|
||||
* So the registration moves with the mode, and the switch itself counts as a
|
||||
* change: the data underneath every live flow has just been replaced.
|
||||
*/
|
||||
override fun registerObserver(onChange: () -> Unit): AutoCloseable =
|
||||
follow(onChange) { it.registerObserver(onChange) }
|
||||
|
||||
override fun registerTaskObserver(onChange: () -> Unit): AutoCloseable =
|
||||
follow(onChange) { it.registerTaskObserver(onChange) }
|
||||
|
||||
private fun follow(onChange: () -> Unit, register: (TasksDataSource) -> AutoCloseable): AutoCloseable {
|
||||
override fun registerObserver(onChange: () -> Unit): AutoCloseable {
|
||||
val lock = Any()
|
||||
var closed = false
|
||||
var handle: AutoCloseable? = runCatching { register(active()) }.getOrNull()
|
||||
var handle: AutoCloseable? = runCatching { active().registerObserver(onChange) }.getOrNull()
|
||||
|
||||
val modeHandle = resolver.onModeChanged {
|
||||
synchronized(lock) {
|
||||
if (!closed) {
|
||||
handle?.let { runCatching { it.close() } }
|
||||
handle = runCatching { register(active()) }.getOrNull()
|
||||
handle = runCatching { active().registerObserver(onChange) }.getOrNull()
|
||||
}
|
||||
}
|
||||
onChange()
|
||||
|
||||
@@ -1,39 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.data.tasks
|
||||
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.FlowPreview
|
||||
import kotlinx.coroutines.channels.Channel
|
||||
import kotlinx.coroutines.flow.debounce
|
||||
import kotlinx.coroutines.flow.receiveAsFlow
|
||||
import kotlinx.coroutines.launch
|
||||
import java.util.concurrent.atomic.AtomicBoolean
|
||||
|
||||
/**
|
||||
* Runs [action] once per burst of store changes: [register] hooks the store's
|
||||
* observer, and [request] asks for a pass without one. Started at most once.
|
||||
*/
|
||||
class StoreChangeDebouncer(
|
||||
private val scope: CoroutineScope,
|
||||
private val delayMillis: Long,
|
||||
private val register: (onChange: () -> Unit) -> AutoCloseable,
|
||||
private val action: suspend () -> Unit,
|
||||
) {
|
||||
private val requests = Channel<Unit>(Channel.CONFLATED)
|
||||
private val started = AtomicBoolean(false)
|
||||
|
||||
/** @return whether this call started it; false when it already was. */
|
||||
@OptIn(FlowPreview::class)
|
||||
fun start(): Boolean {
|
||||
if (!started.compareAndSet(false, true)) return false
|
||||
runCatching { register { requests.trySend(Unit) } }
|
||||
scope.launch(Dispatchers.IO) {
|
||||
requests.receiveAsFlow().debounce(delayMillis).collect { runCatching { action() } }
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
fun request() {
|
||||
requests.trySend(Unit)
|
||||
}
|
||||
}
|
||||
@@ -5,7 +5,6 @@ import de.jeanlucmakiola.agendula.data.reminders.ReminderPlanner
|
||||
import de.jeanlucmakiola.agendula.domain.Task
|
||||
import de.jeanlucmakiola.agendula.domain.TaskForm
|
||||
import de.jeanlucmakiola.agendula.domain.TaskReminder
|
||||
import de.jeanlucmakiola.agendula.domain.calendarDate
|
||||
import java.time.ZoneId
|
||||
import kotlin.time.Instant
|
||||
|
||||
@@ -23,8 +22,7 @@ internal object StoredReminders {
|
||||
*
|
||||
* A task getting its first date takes the defaults only when the form
|
||||
* names no reminder; one that already had a date takes those of the new
|
||||
* date that no reminder of the form counts from, and those of a date
|
||||
* whose defaults had all rung when it moved — see [revived]. Otherwise the form is
|
||||
* date that no reminder of the form counts from. Otherwise the form is
|
||||
* kept, so an edit that clears every reminder means "use the default
|
||||
* here" as before.
|
||||
*
|
||||
@@ -35,7 +33,7 @@ internal object StoredReminders {
|
||||
fun of(form: TaskForm, current: Task?, settings: Settings, now: Long, zone: ZoneId): List<TaskReminder> {
|
||||
val wanted = form.reminders.map { it.lead }.distinct()
|
||||
if (form.remindersChosen) return wanted
|
||||
return withDefaults(form, current?.start, current?.due, current?.isAllDay ?: form.isAllDay, settings, now, zone)
|
||||
return withDefaults(form, current?.start, current?.due, settings, now, zone)
|
||||
}
|
||||
|
||||
/** [of] for a task whose dates were [start] and [due], whatever the form chose. */
|
||||
@@ -43,7 +41,6 @@ internal object StoredReminders {
|
||||
form: TaskForm,
|
||||
start: Instant?,
|
||||
due: Instant?,
|
||||
wasAllDay: Boolean,
|
||||
settings: Settings,
|
||||
now: Long,
|
||||
zone: ZoneId,
|
||||
@@ -51,12 +48,10 @@ internal object StoredReminders {
|
||||
val wanted = form.reminders.map { it.lead }.distinct()
|
||||
val had = anchorsOf(start, due)
|
||||
val gained = anchorsOf(form.start, form.due) - had
|
||||
val revived = revived(form, start, due, wasAllDay, wanted, settings, now, zone)
|
||||
if (gained.isEmpty() && revived.isEmpty()) return wanted
|
||||
if (gained.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 }
|
||||
return wanted + defaultsFor(form, settings, now, zone).filter { it.fromStart in gained && it.fromStart !in named }
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -84,41 +79,6 @@ internal object StoredReminders {
|
||||
return kept.distinct().ifEmpty { defaultsFor(form, settings, now, zone) }
|
||||
}
|
||||
|
||||
/**
|
||||
* The dates of a one-off task that moved after every default of theirs
|
||||
* had rung: a task saved then was left without them as past (#121), so
|
||||
* the new date brings them like a date the task gains. Only on a task
|
||||
* with reminders of its own and none from that date — no reminders at
|
||||
* all is the planner's default or turned off, and either holds.
|
||||
*/
|
||||
private fun revived(
|
||||
form: TaskForm,
|
||||
start: Instant?,
|
||||
due: Instant?,
|
||||
wasAllDay: Boolean,
|
||||
wanted: List<TaskReminder>,
|
||||
settings: Settings,
|
||||
now: Long,
|
||||
zone: ZoneId,
|
||||
): Set<Boolean> {
|
||||
if (form.rrule != null || wanted.isEmpty()) return emptySet()
|
||||
val named = wanted.map { it.fromStart }.toSet()
|
||||
val defaults = settings.defaultRemindersFor(form.listId, wasAllDay)
|
||||
fun revived(fromStart: Boolean, was: Instant?, isNow: Instant?): Boolean {
|
||||
if (was == null || isNow == null || fromStart in named) return false
|
||||
val moved = if (wasAllDay == form.isAllDay) {
|
||||
isNow != was
|
||||
} else {
|
||||
isNow.calendarDate(form.isAllDay, zone) != was.calendarDate(wasAllDay, zone)
|
||||
}
|
||||
val leads = defaults.filter { it.fromStart == fromStart }
|
||||
return moved && leads.isNotEmpty() && leads.all {
|
||||
ReminderPlanner.triggerAt(was, wasAllDay, it.minutesBefore, settings.allDayReminderMinuteOfDay, zone) < now
|
||||
}
|
||||
}
|
||||
return setOfNotNull(true.takeIf { revived(true, start, form.start) }, false.takeIf { revived(false, due, form.due) })
|
||||
}
|
||||
|
||||
/** The dates a reminder can count from, as [TaskReminder.fromStart]. */
|
||||
private fun anchorsOf(start: Any?, due: Any?): Set<Boolean> =
|
||||
setOfNotNull(true.takeIf { start != null }, false.takeIf { due != null })
|
||||
|
||||
@@ -13,23 +13,20 @@ import kotlin.time.Instant
|
||||
/** Maps a provider row (via [ColumnReader]) to a domain model. Pure + testable. */
|
||||
object TaskMapper {
|
||||
|
||||
/**
|
||||
* Maps an `instances` row, without its series' rule: the dmfs instances view
|
||||
* (DB 22 and 23) masks `rrule`/`rdate` with `NULL`, so the row alone cannot
|
||||
* tell a series from a one-off on tasks.org's bundled provider (DB 22), which
|
||||
* also lacks `is_recurring`. [withRule] completes it with the rule read from
|
||||
* the master's `tasks` row. An override names its master in
|
||||
* `original_instance_id`.
|
||||
*/
|
||||
fun instance(r: ColumnReader): InstanceRow {
|
||||
fun task(r: ColumnReader): Task {
|
||||
fun instant(name: String): Instant? =
|
||||
r.getLong(name)?.let { Instant.fromEpochMilliseconds(it) }
|
||||
|
||||
val rowId = r.getLong(Tasks.ID) ?: 0L
|
||||
val masterId = r.getLong(Tasks.ORIGINAL_INSTANCE_ID)
|
||||
val recurring = masterId != null || r.getBoolean(Instances.IS_RECURRING)
|
||||
val anchor = occurrenceAnchor(r)
|
||||
val task = Task(
|
||||
// Derived from the rule columns rather than the `is_recurring` column
|
||||
// alone: that column only exists from OpenTasks 1.4.0 (DB 23) and is
|
||||
// absent on tasks.org's bundled provider (DB 22), where reading it
|
||||
// would silently report every recurring task as one-off — and route
|
||||
// its edits onto the series anchor.
|
||||
val recurring = r.getString(Tasks.RRULE) != null ||
|
||||
r.getString(Tasks.RDATE) != null ||
|
||||
r.getBoolean(Instances.IS_RECURRING)
|
||||
return Task(
|
||||
taskId = r.getLong(Instances.TASK_ID) ?: rowId,
|
||||
listId = r.getLong(Tasks.LIST_ID) ?: 0L,
|
||||
title = r.getString(Tasks.TITLE).orEmpty(),
|
||||
@@ -50,31 +47,13 @@ object TaskMapper {
|
||||
accountName = r.getString(Tasks.ACCOUNT_NAME),
|
||||
parentId = r.getLong(Tasks.PARENT_ID),
|
||||
isRecurring = recurring,
|
||||
occurrenceStart = if (recurring) anchor else null,
|
||||
occurrenceStart = if (recurring) occurrenceAnchor(r) else null,
|
||||
distanceFromCurrent = r.getInt(Instances.DISTANCE_FROM_CURRENT),
|
||||
created = instant(Tasks.CREATED),
|
||||
lastModified = instant(Tasks.LAST_MODIFIED),
|
||||
seriesId = if (recurring) masterId ?: r.getLong(Instances.TASK_ID) ?: rowId else null,
|
||||
seriesId = if (recurring) r.getLong(Instances.TASK_ID) ?: rowId else null,
|
||||
recurrenceRule = r.getString(Tasks.RRULE),
|
||||
)
|
||||
return InstanceRow(task, ruleOwner = masterId ?: task.taskId, anchor = anchor)
|
||||
}
|
||||
|
||||
/** [row]'s task as an occurrence of the series [rule] belongs to, or as it is without one. */
|
||||
fun withRule(row: InstanceRow, rule: SeriesRule?): Task {
|
||||
if (rule == null) return row.task
|
||||
return row.task.copy(
|
||||
isRecurring = true,
|
||||
occurrenceStart = row.task.occurrenceStart ?: row.anchor,
|
||||
seriesId = row.task.seriesId ?: row.ruleOwner,
|
||||
recurrenceRule = rule.rrule,
|
||||
)
|
||||
}
|
||||
|
||||
/** The rule columns of a `tasks` row, or null when it does not recur. */
|
||||
fun seriesRule(r: ColumnReader): SeriesRule? {
|
||||
val rrule = r.getString(Tasks.RRULE)?.ifBlank { null }
|
||||
val rdate = r.getString(Tasks.RDATE)?.ifBlank { null }
|
||||
return if (rrule == null && rdate == null) null else SeriesRule(rrule, rdate)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -140,12 +119,3 @@ object TaskMapper {
|
||||
owner = r.getString(Lists.OWNER),
|
||||
)
|
||||
}
|
||||
|
||||
/** A series' recurrence as stored on its master row. */
|
||||
data class SeriesRule(val rrule: String?, val rdate: String?)
|
||||
|
||||
/**
|
||||
* An instance row's task before its series' rule is applied. [ruleOwner] is the
|
||||
* task whose `tasks` row carries that rule: the master, for an override.
|
||||
*/
|
||||
data class InstanceRow(val task: Task, val ruleOwner: Long, val anchor: Instant?)
|
||||
@@ -17,20 +17,6 @@ private fun Instant.forAllDay(allDay: Boolean): Instant =
|
||||
Math.floorDiv(toEpochMilliseconds(), MILLIS_PER_DAY) * MILLIS_PER_DAY,
|
||||
)
|
||||
|
||||
/**
|
||||
* Whole seconds, as iCalendar stores times. The provider expands a series from
|
||||
* second-precision instants, so a DTSTART carrying milliseconds never matches its
|
||||
* own first occurrence: completing it detaches a copy but leaves the series where
|
||||
* it was, and the same occurrence comes straight back.
|
||||
*/
|
||||
fun providerMillis(epochMillis: Long): Long = Math.floorDiv(epochMillis, 1000L) * 1000L
|
||||
|
||||
/** [at] cut to its whole second, as [providerMillis] does. */
|
||||
fun wholeSecond(at: Instant): Instant = Instant.fromEpochMilliseconds(providerMillis(at.toEpochMilliseconds()))
|
||||
|
||||
/** True when [a] and [b] fall in the same whole second. */
|
||||
fun sameSecond(a: Instant, b: Instant): Boolean = wholeSecond(a) == wholeSecond(b)
|
||||
|
||||
/**
|
||||
* Turns a [TaskForm] / mutation into a name→value map. Pure (no ContentValues),
|
||||
* so it unit-tests on the JVM; [AndroidTasksDataSource] converts the map to
|
||||
@@ -71,8 +57,8 @@ object TaskWriteMapper {
|
||||
// through DateTime.toAllDay(), which drops the time-of-day and resolves the
|
||||
// remaining date against UTC — so a local-midnight instant lands on the
|
||||
// previous day for anyone west of UTC. Pin all-day values to UTC midnight.
|
||||
put(Tasks.DTSTART, form.start?.forAllDay(form.isAllDay)?.toEpochMilliseconds()?.let(::providerMillis))
|
||||
put(Tasks.DUE, form.due?.forAllDay(form.isAllDay)?.toEpochMilliseconds()?.let(::providerMillis))
|
||||
put(Tasks.DTSTART, form.start?.forAllDay(form.isAllDay)?.toEpochMilliseconds())
|
||||
put(Tasks.DUE, form.due?.forAllDay(form.isAllDay)?.toEpochMilliseconds())
|
||||
// DUE and DURATION are mutually exclusive. The provider's Validating
|
||||
// processor evaluates the *merged* row (supplied values over the stored
|
||||
// ones), so writing DUE onto a task that already carries a DURATION throws
|
||||
|
||||
@@ -124,17 +124,13 @@ interface TasksDataSource {
|
||||
*
|
||||
* Implementations fall back to [setCompleted] when the row turns out not to
|
||||
* be a series master — an override, or a plain task the caller happened to
|
||||
* hand an anchor for. A series whose occurrence cannot be found fails with
|
||||
* [TaskWriteFailedException] instead: the plain write would close all of it.
|
||||
* hand an anchor for — so the routing above cannot get this wrong.
|
||||
*/
|
||||
fun setCompletedInstance(taskId: Long, occurrenceStart: Instant, completed: Boolean)
|
||||
|
||||
/** Cancel (or restore) one occurrence of a series; the counterpart of [setCompletedInstance]. */
|
||||
fun setCancelledInstance(taskId: Long, occurrenceStart: Instant, cancelled: Boolean)
|
||||
fun deleteTask(taskId: Long)
|
||||
|
||||
/** Delete the override [taskId] standing for one occurrence, excluding that occurrence from its series. */
|
||||
fun deleteOverride(taskId: Long, occurrenceStart: Instant) = deleteTask(taskId)
|
||||
fun createLocalList(name: String, color: Int): Long
|
||||
|
||||
/** Rename and recolour [listId]. */
|
||||
@@ -156,7 +152,4 @@ interface TasksDataSource {
|
||||
|
||||
/** Observe any change to tasks/lists; [onChange] fires on a background thread. */
|
||||
fun registerObserver(onChange: () -> Unit): AutoCloseable
|
||||
|
||||
/** Like [registerObserver], but only for changes to tasks, lists and alarms — not account bookkeeping. */
|
||||
fun registerTaskObserver(onChange: () -> Unit): AutoCloseable = registerObserver(onChange)
|
||||
}
|
||||
@@ -68,11 +68,9 @@ class TasksRepositoryImpl @Inject constructor(
|
||||
|
||||
override fun taskDetail(taskId: Long, occurrenceStart: Instant?): Flow<TaskDetail?> = observing {
|
||||
dataSource.task(taskId, occurrenceStart)?.let { task ->
|
||||
// A series' subtasks hang off its master, also when this occurrence is an override.
|
||||
val owner = task.seriesId ?: resolvedRow(task, taskId)
|
||||
TaskDetail(
|
||||
task = task,
|
||||
subtasks = SeriesCollapse.visible(dataSource.subtasks(owner)).filter { it.taskId != owner },
|
||||
subtasks = SeriesCollapse.visible(dataSource.subtasks(taskId)).filter { it.taskId != taskId },
|
||||
parent = task.parentId?.takeIf { it > 0 }?.let { dataSource.task(it) },
|
||||
)
|
||||
}
|
||||
@@ -174,9 +172,7 @@ class TasksRepositoryImpl @Inject constructor(
|
||||
) = withContext(io) {
|
||||
// Re-read just before writing: it settles the conflict check *and* tells
|
||||
// us which URI to write through.
|
||||
// An occurrence that is gone is not written through to its series.
|
||||
val current = dataSource.task(taskId, occurrenceStart)
|
||||
?: if (occurrenceStart != null) throw TaskWriteFailedException("update task $taskId@$occurrenceStart: gone") else null
|
||||
// Conflict-safe overwrite: bail if the provider's last_modified moved
|
||||
// since the form captured it (external sync / another app). A null
|
||||
// baseline means "force / overwrite anyway".
|
||||
@@ -205,7 +201,7 @@ class TasksRepositoryImpl @Inject constructor(
|
||||
// Going through the occurrence forks an override instead, which takes
|
||||
// the reminders on its own row and leaves the series' alone.
|
||||
val instance = current?.takeIf { it.isRecurring }?.occurrenceStart
|
||||
if (instance == null) dataSource.updateTask(resolvedRow(current, taskId), form, reminders)
|
||||
if (instance == null) dataSource.updateTask(taskId, form, reminders)
|
||||
else dataSource.updateInstance(taskId, instance, form, reminders)
|
||||
}
|
||||
|
||||
@@ -237,16 +233,14 @@ class TasksRepositoryImpl @Inject constructor(
|
||||
override suspend fun deleteTask(taskId: Long, occurrenceStart: Instant?, scope: RecurringScope) =
|
||||
withContext(io) {
|
||||
val current = dataSource.task(taskId, occurrenceStart)
|
||||
// An occurrence that is gone leaves nothing to delete; its series stays.
|
||||
if (current == null && occurrenceStart != null) return@withContext
|
||||
val seriesId = current?.seriesId
|
||||
val occurrence = current?.occurrenceStart
|
||||
if (seriesId == null || occurrence == null) return@withContext dataSource.deleteWithSubtasks(resolvedRow(current, taskId))
|
||||
if (seriesId == null || occurrence == null) return@withContext dataSource.deleteWithSubtasks(taskId)
|
||||
when (scope) {
|
||||
RecurringScope.ThisOccurrence ->
|
||||
// An override row deletes itself into an EXDATE; a generated
|
||||
// occurrence has no row to delete.
|
||||
if (current.taskId != seriesId) dataSource.deleteOverride(current.taskId, occurrence)
|
||||
if (current.taskId != seriesId) dataSource.deleteTask(current.taskId)
|
||||
else dataSource.deleteOccurrence(seriesId, occurrence)
|
||||
RecurringScope.ThisAndFollowing -> dataSource.deleteFollowing(seriesId, occurrence)
|
||||
RecurringScope.AllOccurrences -> dataSource.deleteWithSubtasks(seriesId)
|
||||
@@ -297,13 +291,6 @@ class TasksRepositoryImpl @Inject constructor(
|
||||
ticks.close()
|
||||
}
|
||||
}.flowOn(io)
|
||||
|
||||
/**
|
||||
* The row a read for [taskId] resolved to — a past occurrence the series moved
|
||||
* past is a task of its own — which is the one a write has to address.
|
||||
*/
|
||||
private fun resolvedRow(resolved: Task?, taskId: Long): Long = resolved?.taskId ?: taskId
|
||||
|
||||
}
|
||||
|
||||
/** Subtask levels a duplicate follows; deeper than any real list, short of a cycle. */
|
||||
|
||||
@@ -1,84 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.data.tasks
|
||||
|
||||
import android.content.SharedPreferences
|
||||
import org.json.JSONObject
|
||||
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.
|
||||
*/
|
||||
internal class Tick(
|
||||
val copyId: Long,
|
||||
val seriesId: Long?,
|
||||
val before: Map<String, Any?>?,
|
||||
val after: Map<String, Any?>?,
|
||||
val at: Long,
|
||||
)
|
||||
|
||||
/** 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}"
|
||||
|
||||
fun get(key: String): Tick? = prefs().getString(key, null)?.let(::decode)
|
||||
|
||||
/** The tick that left [copyId], with its key. */
|
||||
fun forCopy(authority: String, copyId: Long): Pair<String, Tick>? =
|
||||
prefs().all.entries.firstNotNullOfOrNull { (key, value) ->
|
||||
if (!key.startsWith("$authority|")) return@firstNotNullOfOrNull null
|
||||
(value as? String)?.let(::decode)?.takeIf { it.copyId == copyId }?.let { key to it }
|
||||
}
|
||||
|
||||
fun put(key: String, tick: Tick) {
|
||||
val stale = prefs().all.filter { (_, value) ->
|
||||
val at = (value as? String)?.let(::decode)?.at ?: 0L
|
||||
tick.at - at > HORIZON_MS
|
||||
}.keys
|
||||
prefs().edit().apply {
|
||||
stale.forEach(::remove)
|
||||
putString(key, encode(tick))
|
||||
}.apply()
|
||||
}
|
||||
|
||||
fun remove(key: String) {
|
||||
prefs().edit().remove(key).apply()
|
||||
}
|
||||
|
||||
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)) }
|
||||
}.toString()
|
||||
|
||||
private fun columns(values: Map<String, Any?>) = JSONObject().apply {
|
||||
values.forEach { (column, value) -> put(column, value ?: JSONObject.NULL) }
|
||||
}
|
||||
|
||||
private fun decode(raw: String): Tick? = runCatching {
|
||||
val json = JSONObject(raw)
|
||||
Tick(
|
||||
copyId = json.getLong("copy"),
|
||||
seriesId = if (json.has("series")) json.getLong("series") else null,
|
||||
before = json.optJSONObject("before")?.let(::values),
|
||||
after = json.optJSONObject("after")?.let(::values),
|
||||
at = json.getLong("at"),
|
||||
)
|
||||
}.getOrNull()
|
||||
|
||||
private fun values(json: JSONObject): Map<String, Any?> = json.keys().asSequence().associateWith { column ->
|
||||
when (val value = json.get(column)) {
|
||||
JSONObject.NULL -> null
|
||||
is Number -> value.toLong()
|
||||
else -> value.toString()
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
/** As long as the own store keeps a tick undoable. */
|
||||
const val HORIZON_MS = 30L * 24 * 60 * 60 * 1000
|
||||
}
|
||||
}
|
||||
+34
-28
@@ -1,7 +1,8 @@
|
||||
package de.jeanlucmakiola.agendula.data.tasks.provider
|
||||
|
||||
import android.database.sqlite.SQLiteConstraintException
|
||||
import de.jeanlucmakiola.agendula.data.reminders.ReminderRefresher
|
||||
import de.jeanlucmakiola.agendula.data.di.ApplicationScope
|
||||
import de.jeanlucmakiola.agendula.data.reminders.ReminderScheduler
|
||||
import de.jeanlucmakiola.agendula.data.tasks.ProviderResolver
|
||||
import de.jeanlucmakiola.agendula.data.tasks.StorageMode
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TaskWriteFailedException
|
||||
@@ -18,6 +19,8 @@ import de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase
|
||||
import de.jeanlucmakiola.agendula.data.tasks.room.seriesOccurrences
|
||||
import de.jeanlucmakiola.agendula.domain.TaskStatus
|
||||
import de.jeanlucmakiola.agendula.domain.normalizeTags
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.launch
|
||||
import java.time.ZoneId
|
||||
import java.util.UUID
|
||||
import javax.inject.Inject
|
||||
@@ -55,40 +58,47 @@ class ProviderWriter internal constructor(
|
||||
store: RoomTasksDataSource,
|
||||
source: ProviderSnapshotSource,
|
||||
resolver: ProviderResolver,
|
||||
reminders: ReminderRefresher,
|
||||
) : this(database, store, source, resolver, reminders::requestRefresh)
|
||||
scheduler: ReminderScheduler,
|
||||
@ApplicationScope scope: CoroutineScope,
|
||||
) : this(database, store, source, resolver, { scope.launch { runCatching { scheduler.sync() } } })
|
||||
|
||||
private var batchDepth = 0
|
||||
private var batchWrote = false
|
||||
|
||||
/** Inserts one row and returns its published id. */
|
||||
fun insert(table: ProviderTable, values: ProviderValues): Long = when (table) {
|
||||
ProviderTable.TASKS -> write { insertTask(values) }
|
||||
ProviderTable.PROPERTIES -> write { insertProperty(values) }
|
||||
ProviderTable.LISTS, ProviderTable.INSTANCES -> readOnly(table)
|
||||
fun insert(table: ProviderTable, values: ProviderValues): Long = write {
|
||||
when (table) {
|
||||
ProviderTable.TASKS -> insertTask(values)
|
||||
ProviderTable.PROPERTIES -> insertProperty(values)
|
||||
else -> throw UnsupportedOperationException("${table.path} is read-only")
|
||||
}
|
||||
}
|
||||
|
||||
/** Updates every row [selection] matches and returns how many changed. */
|
||||
fun update(table: ProviderTable, values: ProviderValues, selection: String?, args: Array<out String>?): Int = when (table) {
|
||||
ProviderTable.TASKS -> write {
|
||||
val writable = ProviderTaskWriter.writable(table, values, WRITABLE_TASK_COLUMNS)
|
||||
val matched = ids(table, selection, args)
|
||||
(if (Tasks.LIST_ID in writable) parentsFirst(matched) else matched).count { updateTask(it, writable) }
|
||||
fun update(table: ProviderTable, values: ProviderValues, selection: String?, args: Array<out String>?): Int = write {
|
||||
when (table) {
|
||||
ProviderTable.TASKS -> {
|
||||
val writable = ProviderTaskWriter.writable(table, values, WRITABLE_TASK_COLUMNS)
|
||||
val matched = ids(table, selection, args)
|
||||
(if (Tasks.LIST_ID in writable) parentsFirst(matched) else matched).count { updateTask(it, writable) }
|
||||
}
|
||||
ProviderTable.INSTANCES -> {
|
||||
val writable = ProviderTaskWriter.writable(table, values, WRITABLE_TASK_COLUMNS)
|
||||
instances(selection, args).count { updateInstance(it, writable) }
|
||||
}
|
||||
ProviderTable.PROPERTIES -> ids(table, selection, args).count { updateProperty(it, values) }
|
||||
else -> throw UnsupportedOperationException("${table.path} is read-only")
|
||||
}
|
||||
ProviderTable.INSTANCES -> write {
|
||||
val writable = ProviderTaskWriter.writable(table, values, WRITABLE_TASK_COLUMNS)
|
||||
instances(selection, args).count { updateInstance(it, writable) }
|
||||
}
|
||||
ProviderTable.PROPERTIES -> write { ids(table, selection, args).count { updateProperty(it, values) } }
|
||||
ProviderTable.LISTS -> readOnly(table)
|
||||
}
|
||||
|
||||
/** Deletes every row [selection] matches and returns how many went. */
|
||||
fun delete(table: ProviderTable, selection: String?, args: Array<out String>?): Int = when (table) {
|
||||
ProviderTable.TASKS -> write { ids(table, selection, args).count { deleteTask(it) } }
|
||||
ProviderTable.INSTANCES -> write { instances(selection, args).count { deleteInstance(it) } }
|
||||
ProviderTable.PROPERTIES -> write { ids(table, selection, args).count { deleteProperty(it) } }
|
||||
ProviderTable.LISTS -> readOnly(table)
|
||||
fun delete(table: ProviderTable, selection: String?, args: Array<out String>?): Int = write {
|
||||
when (table) {
|
||||
ProviderTable.TASKS -> ids(table, selection, args).count { deleteTask(it) }
|
||||
ProviderTable.INSTANCES -> instances(selection, args).count { deleteInstance(it) }
|
||||
ProviderTable.PROPERTIES -> ids(table, selection, args).count { deleteProperty(it) }
|
||||
else -> throw UnsupportedOperationException("${table.path} is read-only")
|
||||
}
|
||||
}
|
||||
|
||||
/** Runs a client's batch in one transaction, re-arming reminders once at the end. */
|
||||
@@ -107,9 +117,6 @@ class ProviderWriter internal constructor(
|
||||
}
|
||||
}
|
||||
|
||||
/** Refused as read-only whichever store is active, before the store is even looked at. */
|
||||
private fun readOnly(table: ProviderTable): Nothing = throw UnsupportedOperationException("${table.path} is read-only")
|
||||
|
||||
private fun <T> write(block: () -> T): T = source.locked {
|
||||
check(resolver.mode() == StorageMode.OWN) {
|
||||
"Agendula is working on top of an external tasks provider; write to that one instead"
|
||||
@@ -189,8 +196,7 @@ class ProviderWriter internal constructor(
|
||||
val current = database.tasks().entity(taskId)?.takeUnless { it.isDeleted } ?: return false
|
||||
requireWritableList(current.listId)
|
||||
// An override deletes itself into an EXDATE on its master.
|
||||
val occurrence = current.recurrenceId
|
||||
if (current.masterId != null && occurrence != null) store.deleteOverride(taskId, occurrence) else store.deleteWithSubtasks(taskId)
|
||||
if (current.masterId != null) store.deleteTask(taskId) else store.deleteWithSubtasks(taskId)
|
||||
return true
|
||||
}
|
||||
|
||||
|
||||
@@ -37,9 +37,6 @@ interface AccountDao {
|
||||
@Query("UPDATE accounts SET last_sync_at = :at, last_sync_error = :error WHERE id = :accountId")
|
||||
fun recordSync(accountId: Long, at: Instant?, error: String?)
|
||||
|
||||
@Query("UPDATE accounts SET label = :label WHERE id = :accountId")
|
||||
fun setLabel(accountId: Long, label: String?)
|
||||
|
||||
@Query("DELETE FROM accounts WHERE id = :accountId")
|
||||
fun delete(accountId: Long): Int
|
||||
}
|
||||
@@ -1,131 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.data.tasks.room
|
||||
|
||||
import androidx.room.ColumnInfo
|
||||
import androidx.room.Dao
|
||||
import androidx.room.Entity
|
||||
import androidx.room.ForeignKey
|
||||
import androidx.room.Index
|
||||
import androidx.room.Insert
|
||||
import androidx.room.OnConflictStrategy
|
||||
import androidx.room.PrimaryKey
|
||||
import androidx.room.Query
|
||||
import de.jeanlucmakiola.agendula.domain.TaskStatus
|
||||
import kotlin.time.Instant
|
||||
|
||||
/**
|
||||
* How a series was moved past one of its occurrences (#137). It maps the
|
||||
* occurrence to its completed copy for as long as the copy lives, and while
|
||||
* [undoable] it also holds what reopening the copy needs to move the series
|
||||
* back: the change, not the old series, so edits made since are kept. Local
|
||||
* only: never part of a `VTODO`.
|
||||
*/
|
||||
@Entity(
|
||||
tableName = "advanced_occurrences",
|
||||
foreignKeys = [
|
||||
ForeignKey(entity = TaskEntity::class, parentColumns = ["id"], childColumns = ["copy_id"], onDelete = ForeignKey.CASCADE),
|
||||
ForeignKey(entity = TaskEntity::class, parentColumns = ["id"], childColumns = ["master_id"], onDelete = ForeignKey.CASCADE),
|
||||
],
|
||||
indices = [Index(value = ["master_id", "anchor"])],
|
||||
)
|
||||
data class AdvancedOccurrenceEntity(
|
||||
/** The completed copy of the occurrence. */
|
||||
@PrimaryKey @ColumnInfo(name = "copy_id") val copyId: Long,
|
||||
@ColumnInfo(name = "master_id") val masterId: Long,
|
||||
@ColumnInfo(name = "anchor") val anchor: Instant,
|
||||
/** The anchor the series moved to; it is only moved back while it still has it. */
|
||||
@ColumnInfo(name = "advanced_to") val advancedTo: Instant,
|
||||
@ColumnInfo(name = "prior_dtstart") val priorDtstart: Instant?,
|
||||
@ColumnInfo(name = "prior_due") val priorDue: Instant?,
|
||||
@ColumnInfo(name = "prior_status") val priorStatus: TaskStatus,
|
||||
@ColumnInfo(name = "prior_percent_complete") val priorPercentComplete: Int?,
|
||||
@ColumnInfo(name = "prior_completed_at") val priorCompletedAt: Instant?,
|
||||
/** Occurrences `COUNT` lost to the move. */
|
||||
@ColumnInfo(name = "spent") val spent: Int,
|
||||
/** The `RRULE` the move left; once it differs, the series was reshaped and is not moved back. */
|
||||
@ColumnInfo(name = "rule_after") val ruleAfter: String?,
|
||||
/** The `EXDATE` occurrences the move dropped, as epoch millis, comma-separated. */
|
||||
@ColumnInfo(name = "dropped_exdates", defaultValue = "") val droppedExdates: String = "",
|
||||
/** The copy was an override before, and goes back to being one. */
|
||||
@ColumnInfo(name = "from_override") val fromOverride: Boolean,
|
||||
/** Cleared once the copy is edited, moved or reopened on its own: it is then a task of its own. */
|
||||
@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,
|
||||
) {
|
||||
val dropped: List<Instant>
|
||||
get() = droppedExdates.split(',').mapNotNull { it.toLongOrNull()?.let(Instant::fromEpochMilliseconds) }
|
||||
|
||||
companion object {
|
||||
fun encode(instants: List<Instant>) = instants.joinToString(",") { it.toEpochMilliseconds().toString() }
|
||||
}
|
||||
}
|
||||
|
||||
/** A closed override detached along with an advance; [taskId] is null once that row is gone. */
|
||||
@Entity(
|
||||
tableName = "advanced_detached",
|
||||
foreignKeys = [
|
||||
ForeignKey(
|
||||
entity = AdvancedOccurrenceEntity::class,
|
||||
parentColumns = ["copy_id"],
|
||||
childColumns = ["copy_id"],
|
||||
onDelete = ForeignKey.CASCADE,
|
||||
),
|
||||
ForeignKey(entity = TaskEntity::class, parentColumns = ["id"], childColumns = ["task_id"], onDelete = ForeignKey.SET_NULL),
|
||||
],
|
||||
indices = [Index(value = ["copy_id"]), Index(value = ["task_id"])],
|
||||
)
|
||||
data class AdvancedDetachedEntity(
|
||||
@PrimaryKey(autoGenerate = true) @ColumnInfo(name = "id") val id: Long = 0,
|
||||
@ColumnInfo(name = "copy_id") val copyId: Long,
|
||||
@ColumnInfo(name = "anchor") val anchor: Instant,
|
||||
@ColumnInfo(name = "task_id") val taskId: Long?,
|
||||
)
|
||||
|
||||
@Dao
|
||||
interface AdvancedOccurrenceDao {
|
||||
@Insert(onConflict = OnConflictStrategy.REPLACE)
|
||||
fun insert(row: AdvancedOccurrenceEntity)
|
||||
|
||||
@Insert
|
||||
fun insertDetached(rows: List<AdvancedDetachedEntity>)
|
||||
|
||||
@Query("SELECT * FROM advanced_occurrences WHERE copy_id = :copyId")
|
||||
fun forCopy(copyId: Long): AdvancedOccurrenceEntity?
|
||||
|
||||
@Query("SELECT * FROM advanced_detached WHERE copy_id = :copyId")
|
||||
fun detachedFor(copyId: Long): List<AdvancedDetachedEntity>
|
||||
|
||||
@Query("SELECT * FROM advanced_occurrences WHERE master_id = :masterId")
|
||||
fun forMaster(masterId: Long): List<AdvancedOccurrenceEntity>
|
||||
|
||||
/** The record for [masterId]'s occurrence within the second starting at [secondStart]. */
|
||||
@Query(
|
||||
"SELECT * FROM advanced_occurrences WHERE master_id = :masterId " +
|
||||
"AND anchor >= :secondStart AND anchor < :secondStart + 1000",
|
||||
)
|
||||
fun at(masterId: Long, secondStart: Instant): AdvancedOccurrenceEntity?
|
||||
|
||||
@Query("DELETE FROM advanced_occurrences WHERE copy_id = :copyId")
|
||||
fun delete(copyId: Long)
|
||||
|
||||
@Query("UPDATE advanced_occurrences SET undoable = 0 WHERE copy_id = :copyId")
|
||||
fun keepAsOwnTask(copyId: Long)
|
||||
|
||||
@Query("UPDATE advanced_occurrences SET settled = 1 WHERE master_id IN (:masterIds)")
|
||||
fun settle(masterIds: List<Long>)
|
||||
|
||||
/** Settles [masterId]'s moves to before [until], the anchor the server now holds. */
|
||||
@Query("UPDATE advanced_occurrences SET settled = 1 WHERE master_id = :masterId AND advanced_to < :until")
|
||||
fun settleUpTo(masterId: Long, until: Instant)
|
||||
|
||||
/** Records of ticks made before [before]: too old to undo. Counted from the tick, not the occurrence, which may be long overdue. */
|
||||
@Query(
|
||||
"DELETE FROM advanced_occurrences WHERE master_id = :masterId " +
|
||||
"AND copy_id IN (SELECT id FROM tasks WHERE created_at < :before)",
|
||||
)
|
||||
fun pruneTickedBefore(masterId: Long, before: Instant)
|
||||
|
||||
/** [taskId], once detached with a tick, has a life of its own and no longer returns to the series. */
|
||||
@Query("UPDATE advanced_detached SET task_id = NULL WHERE task_id = :taskId")
|
||||
fun unlinkDetached(taskId: Long)
|
||||
}
|
||||
@@ -26,8 +26,6 @@ data class AccountEntity(
|
||||
@ColumnInfo(name = "username") val username: String? = null,
|
||||
@ColumnInfo(name = "last_sync_at") val lastSyncAt: Instant? = null,
|
||||
@ColumnInfo(name = "last_sync_error") val lastSyncError: String? = null,
|
||||
/** A name the user gave the account (#105); [displayName] stays the stable key. */
|
||||
@ColumnInfo(name = "label") val label: String? = null,
|
||||
)
|
||||
|
||||
/**
|
||||
|
||||
@@ -11,7 +11,6 @@ import androidx.room.Embedded
|
||||
data class TaskListRow(
|
||||
@Embedded val list: TaskListEntity,
|
||||
@ColumnInfo(name = "account_display_name") val accountDisplayName: String?,
|
||||
@ColumnInfo(name = "account_label") val accountLabel: String? = null,
|
||||
)
|
||||
|
||||
/**
|
||||
@@ -24,6 +23,5 @@ data class TaskRow(
|
||||
@ColumnInfo(name = "list_name") val listName: String,
|
||||
@ColumnInfo(name = "list_color") val listColor: Int,
|
||||
@ColumnInfo(name = "account_display_name") val accountDisplayName: String?,
|
||||
@ColumnInfo(name = "account_label") val accountLabel: String? = null,
|
||||
@ColumnInfo(name = "list_read_only") val listReadOnly: Boolean = false,
|
||||
)
|
||||
@@ -4,7 +4,6 @@ import de.jeanlucmakiola.agendula.domain.LocalAccount
|
||||
import de.jeanlucmakiola.agendula.domain.Task
|
||||
import de.jeanlucmakiola.agendula.domain.TaskList
|
||||
import de.jeanlucmakiola.agendula.domain.export.ExportTask
|
||||
import de.jeanlucmakiola.agendula.domain.isClosed
|
||||
import de.jeanlucmakiola.agendula.domain.priorityFromICal
|
||||
import de.jeanlucmakiola.agendula.domain.recurrence.RecurrenceSpec
|
||||
import kotlin.time.Instant
|
||||
@@ -21,7 +20,7 @@ object RoomTaskMapper {
|
||||
color = row.list.color,
|
||||
// TaskList.accountName is non-null and the lists screen groups by it, so a
|
||||
// list with no account still has to report something to group under.
|
||||
accountName = row.accountLabel ?: row.accountDisplayName ?: LocalAccount.NAME,
|
||||
accountName = row.accountDisplayName ?: LocalAccount.NAME,
|
||||
accountType = if (row.list.accountId == null) LocalAccount.TYPE else CALDAV_ACCOUNT_TYPE,
|
||||
isSynced = row.list.isSynced,
|
||||
isVisible = row.list.isVisible,
|
||||
@@ -62,7 +61,7 @@ object RoomTaskMapper {
|
||||
listColor = row.listColor,
|
||||
taskColor = row.task.color,
|
||||
listName = row.listName,
|
||||
accountName = row.accountLabel ?: row.accountDisplayName ?: LocalAccount.NAME,
|
||||
accountName = row.accountDisplayName ?: LocalAccount.NAME,
|
||||
parentId = row.task.parentId,
|
||||
isRecurring = row.task.isRecurring,
|
||||
occurrenceStart = occurrenceStart,
|
||||
@@ -101,10 +100,6 @@ object RoomTaskMapper {
|
||||
val TaskEntity.isRecurring: Boolean
|
||||
get() = !rrule.isNullOrBlank() || !rdate.isNullOrBlank()
|
||||
|
||||
/** Completed or cancelled. */
|
||||
val TaskEntity.isClosed: Boolean
|
||||
get() = status.isClosed
|
||||
|
||||
/**
|
||||
* The series anchor: `DTSTART` when present, else `DUE`. A `VTODO` may carry only
|
||||
* a due date, and RFC 5545 then anchors the recurrence on it — matching how the
|
||||
|
||||
+56
-368
@@ -6,17 +6,13 @@ import de.jeanlucmakiola.agendula.domain.TaskReminder
|
||||
import de.jeanlucmakiola.agendula.domain.TaskReminderOrder
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TaskWriteFailedException
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TasksDataSource
|
||||
import de.jeanlucmakiola.agendula.data.tasks.sameSecond
|
||||
import de.jeanlucmakiola.agendula.data.tasks.wholeSecond
|
||||
import de.jeanlucmakiola.agendula.domain.Task
|
||||
import de.jeanlucmakiola.agendula.domain.TaskForm
|
||||
import de.jeanlucmakiola.agendula.domain.TaskList
|
||||
import de.jeanlucmakiola.agendula.domain.TaskStatus
|
||||
import de.jeanlucmakiola.agendula.domain.export.ExportTask
|
||||
import de.jeanlucmakiola.agendula.domain.normalizeTags
|
||||
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 java.util.UUID
|
||||
import javax.inject.Inject
|
||||
@@ -32,12 +28,6 @@ private val WINDOW_FORWARD = 730.days
|
||||
/** Residue lines that describe the old series and must not follow the new one. */
|
||||
private val SERIES_LINES = listOf("EXDATE", "RDATE", "RRULE", "RECURRENCE-ID", "UID")
|
||||
|
||||
/** How long a record keeps mapping a ticked occurrence to its copy. */
|
||||
private val RECORD_HORIZON = 30.days
|
||||
|
||||
/** Only bounds the search: the occurrence count is what stops expansion, so no real gap is cut off. */
|
||||
private val SERIES_LOOKAHEAD = (366 * 1000).days
|
||||
|
||||
/** Enough to count every occurrence before a split point without bounding a real series. */
|
||||
internal const val SPLIT_COUNT_CEILING = 100_000
|
||||
|
||||
@@ -86,7 +76,6 @@ internal fun seriesOccurrences(master: TaskEntity, overrides: List<TaskEntity>,
|
||||
}
|
||||
|
||||
internal val OBSERVED_TABLES = arrayOf("tasks", "task_lists", "task_alarms", "accounts")
|
||||
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
|
||||
@@ -113,7 +102,6 @@ class RoomTasksDataSource @Inject constructor(
|
||||
private val tasks get() = database.tasks()
|
||||
private val lists get() = database.taskLists()
|
||||
private val alarms get() = database.alarms()
|
||||
private val advanced get() = database.advancedOccurrences()
|
||||
|
||||
// --- reads ----------------------------------------------------------------
|
||||
|
||||
@@ -141,13 +129,9 @@ class RoomTasksDataSource @Inject constructor(
|
||||
if (occurrenceStart == null) return task(taskId)
|
||||
val row = tasks.task(taskId) ?: return null
|
||||
if (row.task.recurrenceId != null || !row.task.isRecurring) return task(taskId)
|
||||
val occurrences = occurrencesOf(row, tasks.overrides(taskId), clock.now())
|
||||
// Null rather than another occurrence: a write addressed to this one must not land on that.
|
||||
return occurrences.firstOrNull { it.occurrenceStart == occurrenceStart }
|
||||
?: occurrences.firstOrNull { it.occurrenceStart?.let { a -> sameSecond(a, occurrenceStart) } == true }
|
||||
?: copyAt(row.task, occurrenceStart)?.let { copy ->
|
||||
tasks.task(copy.id)?.let { RoomTaskMapper.task(it).copy(occurrenceStart = occurrenceStart) }
|
||||
}
|
||||
return occurrencesOf(row, tasks.overrides(taskId), clock.now())
|
||||
.firstOrNull { it.occurrenceStart == occurrenceStart }
|
||||
?: task(taskId)
|
||||
}
|
||||
|
||||
private fun overrideTask(row: TaskRow, anchor: Instant): Task =
|
||||
@@ -245,8 +229,10 @@ class RoomTasksDataSource @Inject constructor(
|
||||
* reminders sync, a sync landing between the two would upload the task
|
||||
* without them, or with the ones it is about to lose.
|
||||
*/
|
||||
private fun writeReminders(taskId: Long, reminders: List<TaskReminder>?): Boolean =
|
||||
reminders != null && alarms.syncForTask(taskId, reminders)
|
||||
private fun writeReminders(taskId: Long, reminders: List<TaskReminder>?) {
|
||||
if (reminders == null) return
|
||||
alarms.syncForTask(taskId, reminders)
|
||||
}
|
||||
|
||||
private fun storedReminders(taskId: Long): List<TaskReminder> =
|
||||
alarms.forTask(taskId).map { it.asReminder() }.sortedWith(TaskReminderOrder)
|
||||
@@ -254,7 +240,7 @@ class RoomTasksDataSource @Inject constructor(
|
||||
override fun updateTask(taskId: Long, form: TaskForm, reminders: List<TaskReminder>?) = tx {
|
||||
val current = tasks.entity(taskId) ?: throw TaskWriteFailedException("update task $taskId")
|
||||
val edited = TaskFormWriter.apply(current, form, clock.now(), zone())
|
||||
val remindersChanged = writeReminders(taskId, reminders)
|
||||
writeReminders(taskId, reminders)
|
||||
if (current.masterId == null && edited.listId != current.listId) {
|
||||
if (lists.exists(edited.listId) == 0) throw TaskWriteFailedException("move task: no list ${edited.listId}")
|
||||
move(current, TaskFormWriter.withRule(edited, form.rrule))
|
||||
@@ -269,23 +255,18 @@ class RoomTasksDataSource @Inject constructor(
|
||||
// in both (the task query skips non-null `master_id`, and the override
|
||||
// query finds no master in B) while still uploading as part of A's
|
||||
// resource.
|
||||
saveRow(
|
||||
current,
|
||||
tasks.update(
|
||||
if (current.masterId == null) {
|
||||
TaskFormWriter.withRule(edited, form.rrule)
|
||||
} else {
|
||||
edited.copy(listId = current.listId, parentId = current.parentId)
|
||||
},
|
||||
changedBesides = remindersChanged,
|
||||
)
|
||||
writes.onWritten(setOf(current.listId))
|
||||
}
|
||||
|
||||
/** See [TaskMove]: the rows move, and the old collection is left a tombstone. */
|
||||
private fun move(current: TaskEntity, edited: TaskEntity) {
|
||||
// A copy moved elsewhere is a task of its own now.
|
||||
advanced.keepAsOwnTask(current.id)
|
||||
advanced.unlinkDetached(current.id)
|
||||
val plan = TaskMove.plan(
|
||||
edited = edited,
|
||||
previous = current,
|
||||
@@ -341,7 +322,11 @@ class RoomTasksDataSource @Inject constructor(
|
||||
return@tx
|
||||
}
|
||||
val now = clock.now()
|
||||
val spent = spentBefore(spec, occurrenceStart)
|
||||
// COUNT counts before EXDATE is applied (RFC 5545 §3.8.5.3).
|
||||
val spent = RecurrenceExpander.expand(
|
||||
spec.copy(exdate = null),
|
||||
ExpansionWindow(from = anchor, until = occurrenceStart, maxOccurrences = SPLIT_COUNT_CEILING),
|
||||
).size
|
||||
val (start, due) = resolvedTimes(master, occurrenceStart)
|
||||
tasks.update(TaskFormWriter.endedBefore(master, occurrenceStart, now, zone()))
|
||||
|
||||
@@ -364,7 +349,9 @@ class RoomTasksDataSource @Inject constructor(
|
||||
percentComplete = null,
|
||||
completedAt = null,
|
||||
// Recurrence lines belong to the old series; everything else carries over.
|
||||
unknownProperties = seriesFreeText(master.unknownProperties),
|
||||
unknownProperties = master.unknownProperties?.lines()
|
||||
?.filterNot { line -> SERIES_LINES.any { line.startsWith(it, ignoreCase = true) } }
|
||||
?.joinToString("\r\n")?.ifBlank { null },
|
||||
)
|
||||
val applied = TaskFormWriter.apply(base, form.copy(percentComplete = null), now, zone())
|
||||
val delta = applied.dtstart?.let { newStart -> start?.let { newStart - it } }
|
||||
@@ -423,12 +410,9 @@ class RoomTasksDataSource @Inject constructor(
|
||||
|
||||
private inline fun tx(crossinline block: () -> Unit) = database.runInTransaction(Runnable { block() })
|
||||
|
||||
private fun seriesMaster(seriesId: Long): TaskEntity = rowAndMaster(seriesId).second
|
||||
|
||||
/** [taskId]'s row, and its series' master — the row itself unless it is an override. */
|
||||
private fun rowAndMaster(taskId: Long): Pair<TaskEntity, TaskEntity> {
|
||||
val row = tasks.entity(taskId) ?: throw TaskWriteFailedException("series $taskId")
|
||||
return row to (row.masterId?.let { tasks.entity(it) } ?: row)
|
||||
private fun seriesMaster(seriesId: Long): TaskEntity {
|
||||
val row = tasks.entity(seriesId) ?: throw TaskWriteFailedException("series $seriesId")
|
||||
return row.masterId?.let { tasks.entity(it) } ?: row
|
||||
}
|
||||
|
||||
/** The occurrence's own times: its override's if it has one, else generated. */
|
||||
@@ -475,354 +459,62 @@ class RoomTasksDataSource @Inject constructor(
|
||||
|
||||
override fun setReminders(taskId: Long, reminders: List<TaskReminder>) = tx {
|
||||
if (!alarms.syncForTask(taskId, reminders)) return@tx
|
||||
advanced.keepAsOwnTask(taskId)
|
||||
advanced.unlinkDetached(taskId)
|
||||
// The reminders are part of the VTODO now, so changing them is an edit.
|
||||
val current = tasks.entity(taskId) ?: return@tx
|
||||
tasks.update(current.copy(isDirty = true, lastModified = clock.now()))
|
||||
writes.onWritten(setOf(current.listId))
|
||||
}
|
||||
|
||||
/** Reopening the copy a ticked occurrence left behind moves its series back, as in [setCompletedInstance]. */
|
||||
override fun setCancelled(taskId: Long, cancelled: Boolean) = tx {
|
||||
override fun setCancelled(taskId: Long, cancelled: Boolean) {
|
||||
val current = tasks.entity(taskId) ?: throw TaskWriteFailedException("cancel task $taskId")
|
||||
saveRow(current, TaskFormWriter.cancelled(current, cancelled, clock.now()))
|
||||
tasks.update(TaskFormWriter.cancelled(current, cancelled, clock.now()))
|
||||
writes.onWritten(setOf(current.listId))
|
||||
}
|
||||
|
||||
/** Reopening the copy a ticked occurrence left behind moves its series back, as in [setCompletedInstance]. */
|
||||
override fun setCompleted(taskId: Long, completed: Boolean) = tx {
|
||||
override fun setCompleted(taskId: Long, completed: Boolean) {
|
||||
val current = tasks.entity(taskId) ?: throw TaskWriteFailedException("complete task $taskId")
|
||||
saveRow(current, TaskFormWriter.completed(current, completed, clock.now()))
|
||||
tasks.update(TaskFormWriter.completed(current, completed, clock.now()))
|
||||
writes.onWritten(setOf(current.listId))
|
||||
}
|
||||
|
||||
/**
|
||||
* Ticking a series' first open occurrence moves the series on to its next
|
||||
* open one and keeps a completed copy, as tasks.org and Apple Reminders do — a
|
||||
* completed `RECURRENCE-ID` override alone leaves the series showing as open
|
||||
* in most other clients (#137). Closed overrides between become copies too.
|
||||
* Reopening the copy while the series is still where that left it moves it
|
||||
* back. Any other occurrence forks an override carrying the completion, the
|
||||
* same model [updateInstance] writes. Writing the status onto the master
|
||||
* instead would close the series.
|
||||
* Ticking one occurrence forks a `RECURRENCE-ID` override carrying the
|
||||
* completion — the same model [updateInstance] writes. Writing the status onto
|
||||
* the master instead would close the series: the master is what
|
||||
* [TaskDao.tasks] filters on, so every occurrence, past and future, would
|
||||
* leave every list at once.
|
||||
*/
|
||||
override fun setCompletedInstance(taskId: Long, occurrenceStart: Instant, completed: Boolean) = tx {
|
||||
closeOccurrence(taskId, occurrenceStart, completed) { TaskFormWriter.completed(it, completed, clock.now()) }
|
||||
}
|
||||
override fun setCompletedInstance(taskId: Long, occurrenceStart: Instant, completed: Boolean) =
|
||||
writeInstance(taskId, occurrenceStart, "complete") { TaskFormWriter.completed(it, completed, clock.now()) }
|
||||
|
||||
/** Same model as [setCompletedInstance]. */
|
||||
override fun setCancelledInstance(taskId: Long, occurrenceStart: Instant, cancelled: Boolean) = tx {
|
||||
closeOccurrence(taskId, occurrenceStart, cancelled) { TaskFormWriter.cancelled(it, cancelled, clock.now()) }
|
||||
}
|
||||
/** Same override model as [setCompletedInstance]. */
|
||||
override fun setCancelledInstance(taskId: Long, occurrenceStart: Instant, cancelled: Boolean) =
|
||||
writeInstance(taskId, occurrenceStart, "cancel") { TaskFormWriter.cancelled(it, cancelled, clock.now()) }
|
||||
|
||||
private fun closeOccurrence(taskId: Long, occurrenceStart: Instant, closing: Boolean, close: (TaskEntity) -> TaskEntity) {
|
||||
val (row, master) = rowAndMaster(taskId)
|
||||
/** Applies [write] to the override for [occurrenceStart], forking one if there is none yet. */
|
||||
private fun writeInstance(
|
||||
taskId: Long,
|
||||
occurrenceStart: Instant,
|
||||
what: String,
|
||||
write: (TaskEntity) -> TaskEntity,
|
||||
) {
|
||||
val master = tasks.entity(taskId) ?: throw TaskWriteFailedException("$what instance $taskId")
|
||||
// Not a series master — an override, or a plain task the caller handed an
|
||||
// anchor for. Either way this row *is* the occurrence.
|
||||
if (master.recurrenceSpec() == null) {
|
||||
// A plain task, or the copy a ticked occurrence left: this row is the occurrence.
|
||||
saveRow(row, close(row))
|
||||
writes.onWritten(setOf(row.listId))
|
||||
tasks.update(write(master))
|
||||
writes.onWritten(setOf(master.listId))
|
||||
return
|
||||
}
|
||||
val override = if (row.masterId != null) row else tasks.override(master.id, occurrenceStart)
|
||||
val anchor = override?.recurrenceId ?: occurrenceStart
|
||||
val seriesStart = master.recurrenceAnchor ?: return
|
||||
if (anchor < seriesStart && !sameSecond(anchor, seriesStart)) {
|
||||
// The series has moved past it, so a tick has nothing left to close;
|
||||
// a reopen goes to the copy that occurrence left.
|
||||
when {
|
||||
override != null -> writeInstance(master, override, anchor, close)
|
||||
!closing -> copyAt(master, anchor)?.let { copy ->
|
||||
saveRow(copy, close(copy))
|
||||
writes.onWritten(setOf(copy.listId))
|
||||
}
|
||||
}
|
||||
|
||||
tasks.override(taskId, occurrenceStart)?.let {
|
||||
tasks.update(write(it))
|
||||
writes.onWritten(setOf(master.listId))
|
||||
return
|
||||
}
|
||||
if (master.isClosed) {
|
||||
// A series ends with its last occurrence; reopening that one reopens the
|
||||
// series. An override reopens alone while other occurrences are closed
|
||||
// only through the master, which reopening it would reopen too.
|
||||
val reopensSeries = !closing && (override == null || !closedThroughMaster(master, anchor))
|
||||
if (reopensSeries) closeSeries(master, override, close) else writeInstance(master, override, anchor, close)
|
||||
return
|
||||
}
|
||||
if (!closing || !advance(master, anchor, override, close)) writeInstance(master, override, anchor, close)
|
||||
}
|
||||
|
||||
/**
|
||||
* Writes [edited] over [current]. A copy whose only change is that it
|
||||
* reopens moves its series back instead; any other edit, [changedBesides]
|
||||
* included, makes it a task of its own, and it no longer stands for the
|
||||
* series' occurrence. So does any edit to an occurrence detached with it.
|
||||
*/
|
||||
private fun saveRow(current: TaskEntity, edited: TaskEntity, changedBesides: Boolean = false) {
|
||||
advanced.unlinkDetached(current.id)
|
||||
val record = advanced.forCopy(current.id)?.takeIf { it.undoable }
|
||||
if (record != null) {
|
||||
val unchanged = !changedBesides && sameApartFromState(current, edited)
|
||||
if (unchanged && current.isClosed && !edited.isClosed && reopenCopy(current, edited, record)) return
|
||||
if (!unchanged || !edited.isClosed) advanced.keepAsOwnTask(current.id)
|
||||
}
|
||||
tasks.update(edited)
|
||||
}
|
||||
|
||||
/**
|
||||
* Nothing a user sees changed but its state — what saving a reopened copy
|
||||
* from the editor amounts to. Compared as the editor writes them back:
|
||||
* trimmed, blank as none, tags normalised.
|
||||
*/
|
||||
private fun sameApartFromState(a: TaskEntity, b: TaskEntity): Boolean {
|
||||
fun text(value: String?) = value?.trim()?.ifEmpty { null }
|
||||
return text(a.title) == text(b.title) && text(a.description) == text(b.description) &&
|
||||
text(a.location) == text(b.location) && text(a.url) == text(b.url) &&
|
||||
a.priority == b.priority && a.dtstart == b.dtstart && a.due == b.due && a.isAllDay == b.isAllDay &&
|
||||
a.listId == b.listId && a.parentId == b.parentId && a.rrule == b.rrule && a.rdate == b.rdate &&
|
||||
normalizeTags(a.categories) == normalizeTags(b.categories) && a.color == b.color
|
||||
}
|
||||
|
||||
/** Whether an occurrence of [master] other than [except] has no override, so its state is the master's. */
|
||||
private fun closedThroughMaster(master: TaskEntity, except: Instant): Boolean {
|
||||
val spec = master.recurrenceSpec() ?: return false
|
||||
val overridden = tasks.overrides(master.id).mapNotNull { it.recurrenceId?.let(::wholeSecond) }.toSet()
|
||||
return expandFrom(spec, maxOccurrences = overridden.size + 2)
|
||||
.any { !sameSecond(it, except) && wholeSecond(it) !in overridden }
|
||||
}
|
||||
|
||||
/** [close] applied to the master — and to [override], its last occurrence — which ends the series. */
|
||||
private fun closeSeries(master: TaskEntity, override: TaskEntity?, close: (TaskEntity) -> TaskEntity) {
|
||||
tasks.update(close(master))
|
||||
override?.let { tasks.update(close(it)) }
|
||||
writes.onWritten(setOf(master.listId))
|
||||
}
|
||||
|
||||
/**
|
||||
* Moves [master] past [anchor] when that is its first open occurrence; false
|
||||
* when it is not, so the caller writes an override. Series with `RDATE`s keep
|
||||
* the override model (anchoring on one would re-align the `RRULE`), and so do
|
||||
* recurring subtasks, whose copies would pile up under the parent.
|
||||
*/
|
||||
private fun advance(master: TaskEntity, anchor: Instant, override: TaskEntity?, close: (TaskEntity) -> TaskEntity): Boolean {
|
||||
val rule = master.rrule?.takeIf { it.isNotBlank() } ?: return false
|
||||
if (!master.rdate.isNullOrBlank() || master.parentId != null) return false
|
||||
val spec = master.recurrenceSpec() ?: return false
|
||||
val overrides = tasks.overrides(master.id).associateBy { it.recurrenceId?.epochSeconds }
|
||||
fun closedAt(at: Instant) = overrides[at.epochSeconds]?.isClosed == true
|
||||
val leading = expandFrom(spec, maxOccurrences = overrides.values.count { it.isClosed } + 2)
|
||||
val index = leading.indexOfFirst { sameSecond(it, anchor) }
|
||||
if (index < 0 || leading.take(index).any { !closedAt(it) }) return false
|
||||
var nextIndex = index + 1
|
||||
while (nextIndex < leading.size && closedAt(leading[nextIndex])) nextIndex++
|
||||
val next = leading.getOrNull(nextIndex) ?: return true.also { closeSeries(master, override, close) }
|
||||
|
||||
val now = clock.now()
|
||||
val zone = master.timezone ?: zone()
|
||||
val detached = (leading.take(index) + leading.subList(index + 1, nextIndex)).map { at ->
|
||||
at to detach(overrides.getValue(at.epochSeconds), now)
|
||||
}
|
||||
// Expansion drops the anchor's sub-second part; the series keeps it.
|
||||
val newAnchor = next + (spec.anchor - wholeSecond(spec.anchor))
|
||||
val spent = spentBefore(spec, next)
|
||||
val (start, due) = occurrenceTimes(master, newAnchor)
|
||||
val ruleAfter = TaskFormWriter.remainingCount(rule, spent)
|
||||
tasks.update(
|
||||
master.copy(
|
||||
dtstart = start,
|
||||
due = due,
|
||||
rrule = ruleAfter,
|
||||
exdate = TaskFormWriter.valuesFrom(master.exdate, newAnchor, zone),
|
||||
status = TaskStatus.NEEDS_ACTION,
|
||||
percentComplete = null,
|
||||
completedAt = null,
|
||||
lastModified = now,
|
||||
isDirty = true,
|
||||
),
|
||||
)
|
||||
val copyId = if (override != null) {
|
||||
detach(override, now, close)
|
||||
} else {
|
||||
val (copyStart, copyDue) = occurrenceTimes(master, anchor)
|
||||
val id = tasks.insert(close(asCopy(master, now).copy(dtstart = copyStart, due = copyDue)))
|
||||
alarms.copyToTask(master.id, id, sameResource = false)
|
||||
id
|
||||
}
|
||||
advanced.at(master.id, wholeSecond(anchor))?.let { advanced.delete(it.copyId) }
|
||||
advanced.pruneTickedBefore(master.id, now - RECORD_HORIZON)
|
||||
advanced.insert(
|
||||
AdvancedOccurrenceEntity(
|
||||
copyId = copyId,
|
||||
masterId = master.id,
|
||||
anchor = anchor,
|
||||
advancedTo = newAnchor,
|
||||
priorDtstart = master.dtstart,
|
||||
priorDue = master.due,
|
||||
priorStatus = master.status,
|
||||
priorPercentComplete = master.percentComplete,
|
||||
priorCompletedAt = master.completedAt,
|
||||
spent = spent,
|
||||
ruleAfter = ruleAfter,
|
||||
droppedExdates = AdvancedOccurrenceEntity.encode(TaskFormWriter.instantsBefore(master.exdate, newAnchor, zone)),
|
||||
fromOverride = override != null,
|
||||
),
|
||||
)
|
||||
advanced.insertDetached(detached.map { (at, id) -> AdvancedDetachedEntity(copyId = copyId, anchor = at, taskId = id) })
|
||||
writes.onWritten(setOf(master.listId))
|
||||
return 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),
|
||||
ExpansionWindow(from = wholeSecond(spec.anchor), until = cut, maxOccurrences = SPLIT_COUNT_CEILING),
|
||||
).size
|
||||
|
||||
/**
|
||||
* Turns the override [row] into a task of its own, in place so its id keeps
|
||||
* working: a new UID, unlinked from the series, a resource of its own — and
|
||||
* so its alarms are fresh copies, not the series' ones.
|
||||
*/
|
||||
private fun detach(row: TaskEntity, now: Instant, close: (TaskEntity) -> TaskEntity = { it }): Long {
|
||||
tasks.update(close(asCopy(row, now).copy(id = row.id)))
|
||||
refreshAlarms(row.id)
|
||||
return row.id
|
||||
}
|
||||
|
||||
private fun refreshAlarms(taskId: Long) {
|
||||
val current = alarms.forTask(taskId)
|
||||
alarms.deleteForTask(taskId)
|
||||
current.forEach { alarms.insert(it.freshCopy(taskId)) }
|
||||
}
|
||||
|
||||
/** [source] as a standalone task: no series fields, never uploaded. */
|
||||
private fun asCopy(source: TaskEntity, now: Instant): TaskEntity = source.copy(
|
||||
id = 0,
|
||||
uid = UUID.randomUUID().toString(),
|
||||
masterId = null,
|
||||
recurrenceId = null,
|
||||
href = null,
|
||||
etag = null,
|
||||
rrule = null,
|
||||
rdate = null,
|
||||
exdate = null,
|
||||
createdAt = now,
|
||||
sequence = 0,
|
||||
isDeleted = false,
|
||||
isDirty = true,
|
||||
unknownProperties = seriesFreeText(source.unknownProperties),
|
||||
)
|
||||
|
||||
/**
|
||||
* Undoes [advance] for the copy [row] while the series still sits where it
|
||||
* moved it under the same rule, and the copy is still just that — same list,
|
||||
* nothing filed under it. The anchor goes back, `COUNT` gets back what it
|
||||
* spent, and the dropped `EXDATE`s return in the list's own shape; any other
|
||||
* edit made since stays. The occurrence takes [reopened]'s state: as a plain
|
||||
* occurrence again, or as an override where that state is its own. The
|
||||
* occurrences detached with it become overrides again, or are excluded where
|
||||
* their row is gone or has a life of its own. False when it cannot, so the
|
||||
* caller reopens the copy as a task of its own.
|
||||
*/
|
||||
private fun reopenCopy(row: TaskEntity, reopened: TaskEntity, record: AdvancedOccurrenceEntity): Boolean {
|
||||
val master = tasks.entity(record.masterId)?.takeIf {
|
||||
!it.isDeleted && !it.isClosed && row.listId == it.listId && sameRule(it.rrule, record.ruleAfter) &&
|
||||
it.recurrenceAnchor?.let { a -> sameSecond(a, record.advancedTo) } == true
|
||||
}
|
||||
if (master == null || tasks.subtasks(row.id).isNotEmpty()) return false
|
||||
val now = clock.now()
|
||||
val zone = master.timezone ?: zone()
|
||||
val synced = lists.entity(master.listId)?.accountId != null
|
||||
val (start, due) = occurrenceTimes(master, record.priorDtstart ?: record.priorDue ?: record.anchor)
|
||||
var back = master.copy(
|
||||
dtstart = start,
|
||||
due = due,
|
||||
rrule = master.rrule?.let { TaskFormWriter.remainingCount(it, -record.spent) },
|
||||
status = if (master.status == TaskStatus.NEEDS_ACTION) record.priorStatus else master.status,
|
||||
percentComplete = master.percentComplete ?: record.priorPercentComplete,
|
||||
completedAt = master.completedAt ?: record.priorCompletedAt,
|
||||
lastModified = now,
|
||||
isDirty = true,
|
||||
)
|
||||
record.dropped.forEach { back = TaskFormWriter.excepting(back, it, now, zone, dirty = synced) }
|
||||
// A detached row given a parent or subtasks since has a life of its own, and stays out.
|
||||
fun returns(task: TaskEntity?) = task != null && !task.isDeleted && task.listId == master.listId &&
|
||||
task.parentId == master.parentId && tasks.subtasks(task.id).isEmpty()
|
||||
val detached = advanced.detachedFor(row.id).map { it.anchor to it.taskId?.let(tasks::entity) }
|
||||
detached.forEach { (at, task) -> if (!returns(task)) back = TaskFormWriter.excepting(back, at, now, zone, dirty = synced) }
|
||||
tasks.update(back)
|
||||
detached.forEach { (at, task) -> if (returns(task)) toOverride(task!!, back, at, now) }
|
||||
advanced.delete(row.id)
|
||||
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))
|
||||
return true
|
||||
}
|
||||
|
||||
/** The same `RRULE` however a server re-serialised it: parts in any order and case. */
|
||||
private fun sameRule(a: String?, b: String?): Boolean {
|
||||
fun parts(rule: String?) = rule?.trim()?.removePrefix("RRULE:")?.split(';')
|
||||
?.map { it.trim().uppercase() }?.filter { it.isNotEmpty() }?.toSet()
|
||||
return parts(a) == parts(b)
|
||||
}
|
||||
|
||||
/** [row], a detached occurrence, back as [master]'s override for [anchor]. */
|
||||
private fun toOverride(row: TaskEntity, master: TaskEntity, anchor: Instant, now: Instant) {
|
||||
val back = row.copy(
|
||||
uid = master.uid,
|
||||
masterId = master.id,
|
||||
recurrenceId = anchor,
|
||||
href = null,
|
||||
etag = null,
|
||||
isDirty = true,
|
||||
lastModified = now,
|
||||
unknownProperties = seriesFreeText(row.unknownProperties),
|
||||
)
|
||||
if (row.href == null) {
|
||||
tasks.update(back)
|
||||
refreshAlarms(row.id)
|
||||
} else {
|
||||
// Already uploaded as a resource of its own: that one goes, a fresh override comes.
|
||||
val id = tasks.insert(back.copy(id = 0))
|
||||
alarms.copyToTask(row.id, id, sameResource = false)
|
||||
deleteTask(row.id)
|
||||
}
|
||||
}
|
||||
|
||||
/** The copy [advance] left for [master]'s occurrence at [anchor], if it is still there. */
|
||||
private fun copyAt(master: TaskEntity, anchor: Instant): TaskEntity? =
|
||||
advanced.at(master.id, wholeSecond(anchor))?.let { tasks.entity(it.copyId) }?.takeUnless { it.isDeleted }
|
||||
|
||||
/** The series' occurrences from its anchor on, at most [maxOccurrences]. */
|
||||
private fun expandFrom(spec: RecurrenceSpec, maxOccurrences: Int): List<Instant> {
|
||||
val from = wholeSecond(spec.anchor)
|
||||
return RecurrenceExpander.expand(spec, ExpansionWindow(from = from, until = from + SERIES_LOOKAHEAD, maxOccurrences = maxOccurrences))
|
||||
}
|
||||
|
||||
/**
|
||||
* The residue without the series' own lines, as a new resource must not
|
||||
* carry them. Lines inside a nested component (a `VALARM`'s `UID`) are its
|
||||
* own and stay.
|
||||
*/
|
||||
private fun seriesFreeText(unknown: String?): String? {
|
||||
var depth = 0
|
||||
return unknown?.lines()?.filter { line ->
|
||||
when {
|
||||
line.startsWith("BEGIN:", ignoreCase = true) -> { depth++; true }
|
||||
line.startsWith("END:", ignoreCase = true) -> { depth--; true }
|
||||
else -> depth > 0 || (line.isNotBlank() && SERIES_LINES.none { line.startsWith(it, ignoreCase = true) })
|
||||
}
|
||||
}?.joinToString("\r\n")?.ifBlank { null }
|
||||
}
|
||||
|
||||
/** Applies [write] to [override], or to a new one forked from [master] for [occurrenceStart]. */
|
||||
private fun writeInstance(master: TaskEntity, override: TaskEntity?, occurrenceStart: Instant, write: (TaskEntity) -> TaskEntity) {
|
||||
if (override != null) {
|
||||
tasks.update(write(override))
|
||||
} else {
|
||||
val (start, due) = occurrenceTimes(master, occurrenceStart)
|
||||
val id = tasks.insert(write(newOverride(master, master.id, occurrenceStart, start, due)))
|
||||
alarms.copyToTask(master.id, id, sameResource = true)
|
||||
}
|
||||
val (start, due) = occurrenceTimes(master, occurrenceStart)
|
||||
val id = tasks.insert(write(newOverride(master, taskId, occurrenceStart, start, due)))
|
||||
alarms.copyToTask(taskId, id, sameResource = true)
|
||||
writes.onWritten(setOf(master.listId))
|
||||
}
|
||||
|
||||
@@ -915,7 +607,7 @@ class RoomTasksDataSource @Inject constructor(
|
||||
if (lists.exists(edited.listId) == 0) throw TaskWriteFailedException("move task: no list ${edited.listId}")
|
||||
move(current, edited)
|
||||
}
|
||||
else -> saveRow(current, edited)
|
||||
else -> tasks.update(edited)
|
||||
}
|
||||
}
|
||||
writes.onWritten(setOf(current.listId, edited.listId))
|
||||
@@ -958,12 +650,8 @@ class RoomTasksDataSource @Inject constructor(
|
||||
|
||||
// --- observation ----------------------------------------------------------
|
||||
|
||||
override fun registerObserver(onChange: () -> Unit): AutoCloseable = observe(OBSERVED_TABLES, onChange)
|
||||
|
||||
override fun registerTaskObserver(onChange: () -> Unit): AutoCloseable = observe(TASK_TABLES, onChange)
|
||||
|
||||
private fun observe(tables: Array<String>, onChange: () -> Unit): AutoCloseable {
|
||||
val observer = object : InvalidationTracker.Observer(tables) {
|
||||
override fun registerObserver(onChange: () -> Unit): AutoCloseable {
|
||||
val observer = object : InvalidationTracker.Observer(OBSERVED_TABLES) {
|
||||
override fun onInvalidated(tables: Set<String>) = onChange()
|
||||
}
|
||||
database.invalidationTracker.addObserver(observer)
|
||||
|
||||
@@ -29,7 +29,7 @@ interface TaskDao {
|
||||
@Query(
|
||||
"""
|
||||
SELECT t.*, l.name AS list_name, l.color AS list_color, l.is_read_only AS list_read_only,
|
||||
a.display_name AS account_display_name, a.label AS account_label
|
||||
a.display_name AS account_display_name
|
||||
FROM tasks t
|
||||
JOIN task_lists l ON l.id = t.list_id
|
||||
LEFT JOIN accounts a ON a.id = l.account_id
|
||||
@@ -44,7 +44,7 @@ interface TaskDao {
|
||||
@Query(
|
||||
"""
|
||||
SELECT t.*, l.name AS list_name, l.color AS list_color, l.is_read_only AS list_read_only,
|
||||
a.display_name AS account_display_name, a.label AS account_label
|
||||
a.display_name AS account_display_name
|
||||
FROM tasks t
|
||||
JOIN task_lists l ON l.id = t.list_id
|
||||
LEFT JOIN accounts a ON a.id = l.account_id
|
||||
@@ -56,7 +56,7 @@ interface TaskDao {
|
||||
@Query(
|
||||
"""
|
||||
SELECT t.*, l.name AS list_name, l.color AS list_color, l.is_read_only AS list_read_only,
|
||||
a.display_name AS account_display_name, a.label AS account_label
|
||||
a.display_name AS account_display_name
|
||||
FROM tasks t
|
||||
JOIN task_lists l ON l.id = t.list_id
|
||||
LEFT JOIN accounts a ON a.id = l.account_id
|
||||
@@ -199,8 +199,4 @@ 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
|
||||
|
||||
/** 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?)
|
||||
}
|
||||
@@ -120,25 +120,18 @@ object TaskFormWriter {
|
||||
fun valuesBefore(values: String?, cut: Instant, zone: String): String? =
|
||||
mapValues(values, zone) { it.takeIf { at -> at < cut } }
|
||||
|
||||
/** The instants of an `EXDATE`/`RDATE` list before [cut]; values it cannot read are left out. */
|
||||
fun instantsBefore(values: String?, cut: Instant, zone: String): List<Instant> =
|
||||
parsed(values, zone).mapNotNull { it.second }.filter { it < cut }
|
||||
|
||||
/** The values of an `EXDATE`/`RDATE` list at or after [cut]. */
|
||||
fun valuesFrom(values: String?, cut: Instant, zone: String): String? =
|
||||
mapValues(values, zone) { it.takeIf { at -> at >= cut } }
|
||||
|
||||
private fun mapValues(values: String?, zone: String, map: (Instant) -> Instant?): String? {
|
||||
if (values == null) return null
|
||||
return parsed(values, zone).mapNotNull { (raw, at) ->
|
||||
if (at == null) raw else map(at)?.let { writeValueLike(raw, it, zone) }
|
||||
val list = values?.split(',')?.map(String::trim)?.filter(String::isNotEmpty) ?: return values
|
||||
return list.mapNotNull { raw ->
|
||||
val at = readValue(raw, zone) ?: return@mapNotNull raw
|
||||
map(at)?.let { writeValueLike(raw, it, zone) }
|
||||
}.joinToString(",").ifEmpty { null }
|
||||
}
|
||||
|
||||
/** Each value of an `EXDATE`/`RDATE` list with its instant, or null where it cannot be read. */
|
||||
private fun parsed(values: String?, zone: String): List<Pair<String, Instant?>> =
|
||||
values?.split(',')?.map(String::trim)?.filter(String::isNotEmpty)?.map { it to readValue(it, zone) }.orEmpty()
|
||||
|
||||
private fun readValue(raw: String, zone: String): Instant? = runCatching {
|
||||
val z = java.time.ZoneId.of(zone)
|
||||
val instant = when {
|
||||
|
||||
@@ -16,26 +16,22 @@ interface TaskListDao {
|
||||
|
||||
@Query(
|
||||
"""
|
||||
SELECT l.*, a.display_name AS account_display_name, a.label AS account_label
|
||||
SELECT l.*, a.display_name AS account_display_name
|
||||
FROM task_lists l LEFT JOIN accounts a ON a.id = l.account_id
|
||||
ORDER BY a.display_name COLLATE NOCASE, l.sort_order, l.name COLLATE NOCASE, l.name
|
||||
ORDER BY a.display_name, l.sort_order, l.name
|
||||
"""
|
||||
)
|
||||
fun lists(): List<TaskListRow>
|
||||
|
||||
@Query(
|
||||
"""
|
||||
SELECT l.*, a.display_name AS account_display_name, a.label AS account_label
|
||||
SELECT l.*, a.display_name AS account_display_name
|
||||
FROM task_lists l LEFT JOIN accounts a ON a.id = l.account_id
|
||||
WHERE l.id = :listId
|
||||
"""
|
||||
)
|
||||
fun list(listId: Long): TaskListRow?
|
||||
|
||||
/** The highest position among device-only lists, -1 when there are none. */
|
||||
@Query("SELECT COALESCE(MAX(sort_order), -1) FROM task_lists WHERE account_id IS NULL")
|
||||
fun lastLocalSortOrder(): Int
|
||||
|
||||
@Query("SELECT * FROM task_lists WHERE id = :listId")
|
||||
fun entity(listId: Long): TaskListEntity?
|
||||
|
||||
|
||||
@@ -9,7 +9,7 @@ import java.util.UUID
|
||||
import kotlin.time.Instant
|
||||
|
||||
/**
|
||||
* Agendula's own task store. Six tables, designed from
|
||||
* Agendula's own task store. Four tables, designed from
|
||||
* what the app actually reads and writes plus RFC 5545's `VTODO`.
|
||||
*
|
||||
* Schemas are exported to `app/schemas/` and committed, so a future version can
|
||||
@@ -21,10 +21,8 @@ import kotlin.time.Instant
|
||||
TaskListEntity::class,
|
||||
TaskEntity::class,
|
||||
TaskAlarmEntity::class,
|
||||
AdvancedOccurrenceEntity::class,
|
||||
AdvancedDetachedEntity::class,
|
||||
],
|
||||
version = 5,
|
||||
version = 3,
|
||||
exportSchema = true,
|
||||
)
|
||||
@TypeConverters(Converters::class)
|
||||
@@ -33,7 +31,6 @@ abstract class TasksDatabase : RoomDatabase() {
|
||||
abstract fun tasks(): TaskDao
|
||||
abstract fun alarms(): TaskAlarmDao
|
||||
abstract fun accounts(): AccountDao
|
||||
abstract fun advancedOccurrences(): AdvancedOccurrenceDao
|
||||
|
||||
companion object {
|
||||
const val NAME = "agendula-tasks.db"
|
||||
@@ -176,33 +173,5 @@ abstract class TasksDatabase : RoomDatabase() {
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/** v4 lets the user name an account (#105). */
|
||||
val MIGRATION_3_4 = object : Migration(3, 4) {
|
||||
override fun migrate(db: SupportSQLiteDatabase) {
|
||||
db.execSQL("ALTER TABLE accounts ADD COLUMN label TEXT")
|
||||
}
|
||||
}
|
||||
|
||||
/** v5 remembers how ticking an occurrence moved its series, so reopening it can move it back. */
|
||||
val MIGRATION_4_5 = object : Migration(4, 5) {
|
||||
override fun migrate(db: SupportSQLiteDatabase) {
|
||||
db.execSQL(
|
||||
"CREATE TABLE IF NOT EXISTS `advanced_occurrences` (`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, 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 )",
|
||||
)
|
||||
db.execSQL(
|
||||
"CREATE INDEX IF NOT EXISTS `index_advanced_occurrences_master_id_anchor` ON `advanced_occurrences` (`master_id`, `anchor`)",
|
||||
)
|
||||
db.execSQL(
|
||||
"CREATE TABLE IF NOT EXISTS `advanced_detached` (`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 )",
|
||||
)
|
||||
db.execSQL(
|
||||
"CREATE INDEX IF NOT EXISTS `index_advanced_detached_copy_id` ON `advanced_detached` (`copy_id`)",
|
||||
)
|
||||
db.execSQL(
|
||||
"CREATE INDEX IF NOT EXISTS `index_advanced_detached_task_id` ON `advanced_detached` (`task_id`)",
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -159,9 +159,7 @@ class ExternalImport @Inject constructor(
|
||||
val taskDao = database.tasks()
|
||||
val alarmDao = database.alarms()
|
||||
|
||||
// After the device-only lists already there, which the copies join.
|
||||
val after = listDao.lastLocalSortOrder() + 1
|
||||
val listIds = snapshot.lists.withIndex().associate { (position, list) ->
|
||||
val listIds = snapshot.lists.associate { list ->
|
||||
list.id to listDao.insert(
|
||||
TaskListEntity(
|
||||
name = list.name,
|
||||
@@ -170,7 +168,6 @@ class ExternalImport @Inject constructor(
|
||||
isVisible = list.isVisible,
|
||||
isSynced = false,
|
||||
owner = list.owner,
|
||||
sortOrder = after + position,
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
@@ -37,9 +37,6 @@ data class TaskList(
|
||||
|
||||
enum class TaskStatus { NEEDS_ACTION, IN_PROCESS, COMPLETED, CANCELLED }
|
||||
|
||||
/** Completed or cancelled. */
|
||||
val TaskStatus.isClosed: Boolean get() = this == TaskStatus.COMPLETED || this == TaskStatus.CANCELLED
|
||||
|
||||
/** iCalendar priority, bucketed for the UI. */
|
||||
enum class Priority { NONE, LOW, MEDIUM, HIGH }
|
||||
|
||||
@@ -114,7 +111,7 @@ data class Task(
|
||||
val isOccurrence: Boolean get() = seriesId != null && occurrenceStart != null
|
||||
|
||||
val isCompleted: Boolean get() = status == TaskStatus.COMPLETED
|
||||
val isClosed: Boolean get() = status.isClosed
|
||||
val isClosed: Boolean get() = status == TaskStatus.COMPLETED || status == TaskStatus.CANCELLED
|
||||
val isSubtask: Boolean get() = parentId != null && parentId > 0
|
||||
/** The task's own colour if set, else the list colour. */
|
||||
val effectiveColor: Int get() = taskColor ?: listColor
|
||||
|
||||
@@ -59,7 +59,7 @@ fun dueWindowOf(
|
||||
todayEnd: Instant,
|
||||
zone: ZoneId = ZoneId.systemDefault(),
|
||||
): DueWindow {
|
||||
val due = task.wallClock(task.due, zone)
|
||||
val due = task.due?.let { if (task.isAllDay) it.rebasedForAllDay(allDay = false, zone = zone) else it }
|
||||
return when {
|
||||
due == null -> DueWindow.NO_DATE
|
||||
due < todayStart -> DueWindow.OVERDUE
|
||||
@@ -68,10 +68,6 @@ fun dueWindowOf(
|
||||
}
|
||||
}
|
||||
|
||||
/** [at], one of this task's dates, as a local instant: an all-day date is read as its calendar date. */
|
||||
fun Task.wallClock(at: Instant?, zone: ZoneId = ZoneId.systemDefault()): Instant? =
|
||||
at?.let { if (isAllDay) it.rebasedForAllDay(allDay = false, zone = zone) else it }
|
||||
|
||||
/** What a task created from a [SavedFilter] starts with, so it lands in that filter. */
|
||||
data class NewTaskPreset(
|
||||
val listIds: Set<Long> = emptySet(),
|
||||
|
||||
@@ -1,13 +1,8 @@
|
||||
package de.jeanlucmakiola.agendula.domain
|
||||
|
||||
import java.time.ZoneId
|
||||
import kotlin.time.Instant
|
||||
|
||||
/**
|
||||
* The built-in "smart" lists, computed from dates rather than membership. All
|
||||
* but [COMPLETED] hold open tasks, except [TODAY], which also keeps the ones
|
||||
* completed today (see [TaskFiltering.isToday]).
|
||||
*/
|
||||
/** The built-in "smart" lists, computed from due dates rather than membership. */
|
||||
enum class SmartList { ALL, TODAY, UPCOMING, OVERDUE, NO_DATE, COMPLETED }
|
||||
|
||||
/** What a task screen is showing: one real list, a smart list, or a tag. */
|
||||
@@ -45,20 +40,6 @@ object TaskFiltering {
|
||||
is TaskFilter.Saved -> saved?.takeIf { it.id == filter.id }?.matches(task, todayStart, todayEnd) ?: false
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether [task] belongs in Today. An open task does when it is due today, or
|
||||
* starts today without being overdue; a completed one when it was completed today.
|
||||
*/
|
||||
fun isToday(task: Task, todayStart: Instant, todayEnd: Instant, zone: ZoneId = ZoneId.systemDefault()): Boolean {
|
||||
fun inToday(at: Instant?) = at != null && at >= todayStart && at < todayEnd
|
||||
if (task.isClosed) return task.isCompleted && inToday(task.completedAt)
|
||||
return when (dueWindowOf(task, todayStart, todayEnd, zone)) {
|
||||
DueWindow.TODAY -> true
|
||||
DueWindow.OVERDUE -> false
|
||||
DueWindow.UPCOMING, DueWindow.NO_DATE -> inToday(task.wallClock(task.start, zone))
|
||||
}
|
||||
}
|
||||
|
||||
/** Whether [task] carries every one of [tags]; an empty set matches everything. */
|
||||
fun hasAllTags(task: Task, tags: Set<String>): Boolean = task.tags.containsAll(tags)
|
||||
|
||||
@@ -68,7 +49,7 @@ object TaskFiltering {
|
||||
SmartList.ALL -> !task.isClosed
|
||||
SmartList.NO_DATE -> !task.isClosed && dueWindowOf(task, todayStart, todayEnd) == DueWindow.NO_DATE
|
||||
SmartList.OVERDUE -> !task.isClosed && dueWindowOf(task, todayStart, todayEnd) == DueWindow.OVERDUE
|
||||
SmartList.TODAY -> isToday(task, todayStart, todayEnd)
|
||||
SmartList.TODAY -> !task.isClosed && dueWindowOf(task, todayStart, todayEnd) == DueWindow.TODAY
|
||||
SmartList.UPCOMING -> !task.isClosed && dueWindowOf(task, todayStart, todayEnd) == DueWindow.UPCOMING
|
||||
}
|
||||
}
|
||||
@@ -16,22 +16,19 @@ data class SectionedTasks(val section: TaskSection, val tasks: List<Task>)
|
||||
*
|
||||
* [todayStart] is local midnight today and [todayEnd] local midnight tomorrow
|
||||
* (compute with [DayWindow]). Only non-empty sections are returned, in the
|
||||
* fixed order Overdue → Today → Upcoming → No date → Completed. In the Today
|
||||
* list ([todayList]) every open task sits under Today, as it may be there by its
|
||||
* start date alone.
|
||||
* fixed order Overdue → Today → Upcoming → No date → Completed.
|
||||
*/
|
||||
object TaskSections {
|
||||
|
||||
fun of(tasks: List<Task>, todayStart: Instant, todayEnd: Instant, todayList: Boolean = false): List<SectionedTasks> {
|
||||
val bySection = tasks.groupBy { sectionOf(it, todayStart, todayEnd, todayList) }
|
||||
fun of(tasks: List<Task>, todayStart: Instant, todayEnd: Instant): List<SectionedTasks> {
|
||||
val bySection = tasks.groupBy { sectionOf(it, todayStart, todayEnd) }
|
||||
return TaskSection.entries.mapNotNull { section ->
|
||||
bySection[section]?.takeIf { it.isNotEmpty() }?.let { SectionedTasks(section, it) }
|
||||
}
|
||||
}
|
||||
|
||||
fun sectionOf(task: Task, todayStart: Instant, todayEnd: Instant, todayList: Boolean = false): TaskSection {
|
||||
fun sectionOf(task: Task, todayStart: Instant, todayEnd: Instant): TaskSection {
|
||||
if (task.isCompleted) return TaskSection.COMPLETED
|
||||
if (todayList) return TaskSection.TODAY
|
||||
return when (dueWindowOf(task, todayStart, todayEnd)) {
|
||||
DueWindow.OVERDUE -> TaskSection.OVERDUE
|
||||
DueWindow.TODAY -> TaskSection.TODAY
|
||||
|
||||
@@ -46,7 +46,6 @@ fun RootScreen(
|
||||
modifier: Modifier = Modifier,
|
||||
navRequest: NavRequest? = null,
|
||||
onNavRequestConsumed: () -> Unit = {},
|
||||
onReturnHome: () -> Unit = {},
|
||||
permissionViewModel: PermissionViewModel = hiltViewModel(),
|
||||
) {
|
||||
val permission by permissionViewModel.state.collectAsStateWithLifecycle()
|
||||
@@ -87,7 +86,6 @@ fun RootScreen(
|
||||
modifier = modifier,
|
||||
navRequest = navRequest,
|
||||
onNavRequestConsumed = onNavRequestConsumed,
|
||||
onReturnHome = onReturnHome,
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -103,7 +101,6 @@ private fun ReadyGate(
|
||||
modifier: Modifier = Modifier,
|
||||
navRequest: NavRequest? = null,
|
||||
onNavRequestConsumed: () -> Unit = {},
|
||||
onReturnHome: () -> Unit = {},
|
||||
onboardingViewModel: OnboardingViewModel = hiltViewModel(),
|
||||
) {
|
||||
val done by onboardingViewModel.done.collectAsStateWithLifecycle()
|
||||
@@ -116,7 +113,6 @@ private fun ReadyGate(
|
||||
modifier = modifier.fillMaxSize().background(MaterialTheme.colorScheme.surface),
|
||||
navRequest = navRequest,
|
||||
onNavRequestConsumed = onNavRequestConsumed,
|
||||
onReturnHome = onReturnHome,
|
||||
)
|
||||
false -> ReadableWidth(modifier) {
|
||||
OnboardingFlow(modifier = Modifier.fillMaxSize(), viewModel = onboardingViewModel)
|
||||
|
||||
@@ -1,66 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.ui.common
|
||||
|
||||
import androidx.compose.foundation.gestures.awaitEachGesture
|
||||
import androidx.compose.foundation.gestures.awaitFirstDown
|
||||
import androidx.compose.foundation.layout.WindowInsets
|
||||
import androidx.compose.foundation.layout.systemGestures
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableFloatStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.input.pointer.PointerEventPass
|
||||
import androidx.compose.ui.input.pointer.pointerInput
|
||||
import androidx.compose.ui.layout.onGloballyPositioned
|
||||
import androidx.compose.ui.layout.positionInWindow
|
||||
import androidx.compose.ui.platform.LocalDensity
|
||||
import androidx.compose.ui.platform.LocalLayoutDirection
|
||||
import androidx.compose.ui.platform.LocalWindowInfo
|
||||
import androidx.compose.ui.unit.dp
|
||||
import kotlin.math.abs
|
||||
|
||||
/** How far past the system back-gesture zone a horizontal swipe is still ignored. */
|
||||
private val EDGE_MARGIN = 24.dp
|
||||
|
||||
/**
|
||||
* Swallows horizontal swipes that start near the screen's left or right edge,
|
||||
* before a swipe box below it sees them (#90). A back gesture started just
|
||||
* inside the system's gesture zone otherwise reaches the app as a row swipe.
|
||||
* Taps and vertical scrolls are left alone.
|
||||
*/
|
||||
@Composable
|
||||
fun Modifier.ignoringEdgeSwipes(): Modifier {
|
||||
val density = LocalDensity.current
|
||||
val layoutDirection = LocalLayoutDirection.current
|
||||
val windowWidth = LocalWindowInfo.current.containerSize.width
|
||||
val insets = WindowInsets.systemGestures
|
||||
val margin = with(density) { EDGE_MARGIN.roundToPx() }
|
||||
val leftEdge = insets.getLeft(density, layoutDirection) + margin
|
||||
val rightEdge = windowWidth - insets.getRight(density, layoutDirection) - margin
|
||||
var offsetX by remember { mutableFloatStateOf(0f) }
|
||||
return this
|
||||
.onGloballyPositioned { offsetX = it.positionInWindow().x }
|
||||
.pointerInput(leftEdge, rightEdge) {
|
||||
val slop = viewConfiguration.touchSlop
|
||||
awaitEachGesture {
|
||||
val down = awaitFirstDown(requireUnconsumed = false, pass = PointerEventPass.Initial)
|
||||
val x = offsetX + down.position.x
|
||||
if (x > leftEdge && x < rightEdge) return@awaitEachGesture
|
||||
var horizontal = false
|
||||
while (true) {
|
||||
val change = awaitPointerEvent(PointerEventPass.Initial).changes
|
||||
.firstOrNull { it.id == down.id } ?: break
|
||||
if (!horizontal) {
|
||||
val delta = change.position - down.position
|
||||
when {
|
||||
abs(delta.x) > slop -> horizontal = true
|
||||
abs(delta.y) > slop -> break
|
||||
}
|
||||
}
|
||||
if (horizontal) change.consume()
|
||||
if (!change.pressed) break
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.ui.common
|
||||
|
||||
import androidx.compose.foundation.layout.Box
|
||||
import androidx.compose.foundation.layout.BoxScope
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.material3.ExperimentalMaterial3Api
|
||||
import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
|
||||
import androidx.compose.material3.pulltorefresh.PullToRefreshBox
|
||||
import androidx.compose.material3.pulltorefresh.PullToRefreshDefaults
|
||||
import androidx.compose.material3.pulltorefresh.rememberPullToRefreshState
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.unit.Dp
|
||||
import androidx.compose.ui.unit.dp
|
||||
|
||||
/**
|
||||
* Pull down to sync every account (#73). Without an account there is nothing
|
||||
* to sync, so the gesture is off. [topPadding] keeps the indicator below a top
|
||||
* bar the content scrolls under.
|
||||
*/
|
||||
@OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterial3ExpressiveApi::class)
|
||||
@Composable
|
||||
fun SyncPullBox(
|
||||
available: Boolean,
|
||||
syncing: Boolean,
|
||||
onSync: () -> Unit,
|
||||
modifier: Modifier = Modifier,
|
||||
topPadding: Dp = 0.dp,
|
||||
content: @Composable BoxScope.() -> Unit,
|
||||
) {
|
||||
if (!available) {
|
||||
Box(modifier, content = content)
|
||||
return
|
||||
}
|
||||
val state = rememberPullToRefreshState()
|
||||
PullToRefreshBox(
|
||||
isRefreshing = syncing,
|
||||
onRefresh = onSync,
|
||||
modifier = modifier,
|
||||
state = state,
|
||||
indicator = {
|
||||
PullToRefreshDefaults.LoadingIndicator(
|
||||
state = state,
|
||||
isRefreshing = syncing,
|
||||
modifier = Modifier.align(Alignment.TopCenter).padding(top = topPadding),
|
||||
)
|
||||
},
|
||||
content = content,
|
||||
)
|
||||
}
|
||||
@@ -6,6 +6,7 @@ import dagger.hilt.android.lifecycle.HiltViewModel
|
||||
import de.jeanlucmakiola.agendula.data.prefs.DEFAULT_ALL_DAY_REMINDER_MINUTE
|
||||
import de.jeanlucmakiola.agendula.data.prefs.Settings
|
||||
import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
|
||||
import de.jeanlucmakiola.agendula.data.reminders.ReminderScheduler
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TaskConflictException
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TasksRepository
|
||||
import de.jeanlucmakiola.agendula.domain.Priority
|
||||
@@ -108,6 +109,7 @@ data class TaskEditUiState(
|
||||
class TaskEditViewModel @Inject constructor(
|
||||
private val repository: TasksRepository,
|
||||
private val settingsPrefs: SettingsPrefs,
|
||||
private val reminderScheduler: ReminderScheduler,
|
||||
) : ViewModel() {
|
||||
|
||||
private val _state = MutableStateFlow(TaskEditUiState())
|
||||
@@ -147,7 +149,6 @@ class TaskEditViewModel @Inject constructor(
|
||||
private var loadedReminders: List<TaskReminder> = emptyList()
|
||||
private var loadedStart: Instant? = null
|
||||
private var loadedDue: Instant? = null
|
||||
private var loadedAllDay = false
|
||||
|
||||
/** Start a fresh task, optionally pre-selecting a list / parent. */
|
||||
fun bindNew(
|
||||
@@ -156,7 +157,6 @@ class TaskEditViewModel @Inject constructor(
|
||||
initialTitle: String? = null,
|
||||
presetTag: String? = null,
|
||||
presetFilterId: Long? = null,
|
||||
presetDueToday: Boolean = false,
|
||||
) {
|
||||
if (bound) return
|
||||
bound = true
|
||||
@@ -169,7 +169,6 @@ class TaskEditViewModel @Inject constructor(
|
||||
val lists = runCatching { repository.taskLists().first() }.getOrElse { emptyList() }
|
||||
val preset = presetFilterId?.let { settingsPrefs.savedFilter(it).first() }
|
||||
?.newTaskPreset(LocalDate.now())
|
||||
val presetDue = preset?.dueDate ?: LocalDate.now().takeIf { presetDueToday }
|
||||
// A read-only or vanished default — or a widget's preset list, if it was
|
||||
// since deleted or turned read-only — would give the task a list it
|
||||
// cannot be saved to.
|
||||
@@ -191,12 +190,12 @@ class TaskEditViewModel @Inject constructor(
|
||||
// today's start would land after a due of today.
|
||||
start = when {
|
||||
!settings.defaultStartToday -> null
|
||||
presetDue != null -> allDayInstantOf(LocalDate.now())
|
||||
preset?.dueDate != null -> allDayInstantOf(LocalDate.now())
|
||||
else -> Clock.System.now()
|
||||
},
|
||||
// The same all-day value picking the date in the date field gives.
|
||||
due = presetDue?.let(::allDayInstantOf),
|
||||
isAllDay = presetDue != null,
|
||||
due = preset?.dueDate?.let(::allDayInstantOf),
|
||||
isAllDay = preset?.dueDate != null,
|
||||
priority = preset?.priority ?: Priority.NONE,
|
||||
parentId = parentId,
|
||||
lists = lists,
|
||||
@@ -229,7 +228,6 @@ class TaskEditViewModel @Inject constructor(
|
||||
storedReminders = loadedReminders.toSet()
|
||||
loadedStart = task.start
|
||||
loadedDue = task.due
|
||||
loadedAllDay = task.isAllDay
|
||||
_state.value = withFields(
|
||||
TaskEditUiState(
|
||||
loading = false,
|
||||
@@ -364,7 +362,6 @@ class TaskEditViewModel @Inject constructor(
|
||||
toForm().copy(reminders = loadedReminders),
|
||||
loadedStart,
|
||||
loadedDue,
|
||||
loadedAllDay,
|
||||
settings,
|
||||
nowMillis(),
|
||||
ZoneId.systemDefault(),
|
||||
@@ -449,6 +446,13 @@ class TaskEditViewModel @Inject constructor(
|
||||
scope = scope,
|
||||
)
|
||||
}
|
||||
// ⚠️ Outside the write's own result. The task is saved by this
|
||||
// point, and reporting a scheduling failure as a *save* failure
|
||||
// sends the user back to tap Save again — on a screen whose
|
||||
// editingTaskId is still null, which creates a second task. The
|
||||
// reminder is re-synced on the next data change and on launch;
|
||||
// the duplicate is forever.
|
||||
runCatching { reminderScheduler.sync() }
|
||||
}.onSuccess {
|
||||
_state.value = _state.value.copy(saved = true, saveFailed = false, saveConflict = false)
|
||||
}.onFailure { error ->
|
||||
|
||||
@@ -161,7 +161,7 @@ class ImportViewModel @Inject constructor(
|
||||
val result = importer.import(ready.parsed, target)
|
||||
(chosen as? ImportChoice.Existing)?.list
|
||||
?.takeIf { it.accountId != null && result.imported > 0 }
|
||||
?.let { runCatching { syncRequests.syncNow(it.accountId!!) } }
|
||||
?.let { runCatching { syncRequests.syncNow(it.accountName) } }
|
||||
ImportStep.Done(
|
||||
listName = listName,
|
||||
imported = result.imported,
|
||||
|
||||
@@ -97,7 +97,6 @@ import kotlinx.coroutines.delay
|
||||
import de.jeanlucmakiola.agendula.ui.common.ListColorChip
|
||||
import de.jeanlucmakiola.agendula.ui.common.LocalUse24HourFormat
|
||||
import de.jeanlucmakiola.agendula.ui.common.ShapedActionButton
|
||||
import de.jeanlucmakiola.agendula.ui.common.SyncPullBox
|
||||
import de.jeanlucmakiola.agendula.ui.common.priorityAccent
|
||||
import de.jeanlucmakiola.agendula.ui.tasklist.priorityLabel
|
||||
import de.jeanlucmakiola.floret.components.positionOf
|
||||
@@ -123,8 +122,6 @@ fun ListsScreen(
|
||||
viewModel: ListsViewModel = hiltViewModel(),
|
||||
) {
|
||||
val state by viewModel.state.collectAsStateWithLifecycle()
|
||||
val syncAvailable by viewModel.syncAvailable.collectAsStateWithLifecycle()
|
||||
val syncing by viewModel.syncing.collectAsStateWithLifecycle()
|
||||
var query by rememberSaveable { mutableStateOf("") }
|
||||
var searchActive by rememberSaveable { mutableStateOf(false) }
|
||||
var newList by rememberSaveable { mutableStateOf(false) }
|
||||
@@ -176,12 +173,7 @@ fun ListsScreen(
|
||||
}
|
||||
},
|
||||
) { inner ->
|
||||
SyncPullBox(
|
||||
available = syncAvailable && !searchActive,
|
||||
syncing = syncing,
|
||||
onSync = viewModel::syncAll,
|
||||
modifier = Modifier.fillMaxSize().padding(top = inner.calculateTopPadding()),
|
||||
) {
|
||||
Box(Modifier.fillMaxSize().padding(top = inner.calculateTopPadding())) {
|
||||
when (val s = state) {
|
||||
ListsUiState.Loading -> Unit // brief; avoids a flash before first emission
|
||||
ListsUiState.Failure ->
|
||||
|
||||
@@ -4,7 +4,6 @@ import androidx.lifecycle.ViewModel
|
||||
import androidx.lifecycle.viewModelScope
|
||||
import dagger.hilt.android.lifecycle.HiltViewModel
|
||||
import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
|
||||
import de.jeanlucmakiola.agendula.data.sync.ManualSync
|
||||
import de.jeanlucmakiola.agendula.data.sync.RemoteLists
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TasksRepository
|
||||
import de.jeanlucmakiola.agendula.data.tasks.recoveringFromProviderFailure
|
||||
@@ -106,17 +105,9 @@ private const val UPCOMING_PREVIEW = 3
|
||||
class ListsViewModel @Inject constructor(
|
||||
private val repository: TasksRepository,
|
||||
private val remoteLists: RemoteLists,
|
||||
private val manualSync: ManualSync,
|
||||
settingsPrefs: SettingsPrefs,
|
||||
) : ViewModel() {
|
||||
|
||||
/** Pull to sync (#73); off without an account. */
|
||||
val syncAvailable: StateFlow<Boolean> =
|
||||
manualSync.available.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), false)
|
||||
val syncing: StateFlow<Boolean> = manualSync.syncing
|
||||
|
||||
fun syncAll() = manualSync.syncAll()
|
||||
|
||||
/**
|
||||
* Where a new list may go: the device, then every account whose server said
|
||||
* it would take one.
|
||||
@@ -172,12 +163,14 @@ class ListsViewModel @Inject constructor(
|
||||
SmartCount(SmartList.ALL, smartTopLevel.size),
|
||||
)
|
||||
|
||||
// Today ring: the completed rows of the Today list against all of its rows.
|
||||
// Today ring: completed vs. total tasks *due today*. The numerator is the
|
||||
// top-level completed tasks whose due date falls in today's window; the
|
||||
// denominator adds the still-open ones (the Today smart count above).
|
||||
val openToday = count(SmartList.TODAY)
|
||||
val completedToday = completedTasks.count {
|
||||
!it.isSubtask && it.listId !in hidden && TaskFiltering.isToday(it, todayStart, todayEnd)
|
||||
val completedDueToday = completedTasks.count {
|
||||
!it.isSubtask && it.listId !in hidden && it.due != null && it.due >= todayStart && it.due < todayEnd
|
||||
}
|
||||
val todayTotal = openToday + completedToday
|
||||
val todayTotal = openToday + completedDueToday
|
||||
|
||||
// Upcoming preview: the next handful of open tasks due tomorrow onward,
|
||||
// already sorted by the repository's default ordering.
|
||||
@@ -212,7 +205,7 @@ class ListsViewModel @Inject constructor(
|
||||
smartCounts = smartCounts,
|
||||
filters = filters,
|
||||
groups = groups,
|
||||
todayDone = completedToday,
|
||||
todayDone = completedDueToday,
|
||||
todayTotal = todayTotal,
|
||||
upcoming = upcoming,
|
||||
allTasks = allTasks,
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
package de.jeanlucmakiola.agendula.ui.navigation
|
||||
|
||||
import android.annotation.SuppressLint
|
||||
import androidx.compose.animation.EnterTransition
|
||||
import androidx.compose.animation.ExitTransition
|
||||
import androidx.compose.animation.fadeIn
|
||||
@@ -8,17 +7,11 @@ import androidx.compose.animation.slideInHorizontally
|
||||
import androidx.compose.foundation.layout.BoxWithConstraints
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.collectAsState
|
||||
import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.unit.IntOffset
|
||||
import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
|
||||
import de.jeanlucmakiola.agendula.domain.SmartList
|
||||
import de.jeanlucmakiola.agendula.domain.Task
|
||||
import kotlin.time.Instant
|
||||
import androidx.navigation.compose.NavHost
|
||||
@@ -53,21 +46,8 @@ fun AgendulaNavHost(
|
||||
modifier: Modifier = Modifier,
|
||||
navRequest: NavRequest? = null,
|
||||
onNavRequestConsumed: () -> Unit = {},
|
||||
onReturnHome: () -> Unit = {},
|
||||
) {
|
||||
val nav = rememberNavController()
|
||||
// The entry a widget, tile, shortcut or share opened; closing it leaves the app (#93).
|
||||
var returnHomeEntry by rememberSaveable { mutableStateOf<String?>(null) }
|
||||
// No public API exposes the whole back stack, and visibleEntries drops an entry covered by another.
|
||||
@SuppressLint("RestrictedApi")
|
||||
val backStack by nav.currentBackStack.collectAsState()
|
||||
LaunchedEffect(backStack, returnHomeEntry) {
|
||||
val id = returnHomeEntry ?: return@LaunchedEffect
|
||||
if (backStack.none { it.id == id }) {
|
||||
returnHomeEntry = null
|
||||
onReturnHome()
|
||||
}
|
||||
}
|
||||
|
||||
LaunchedEffect(navRequest) {
|
||||
when (navRequest) {
|
||||
@@ -79,9 +59,7 @@ fun AgendulaNavHost(
|
||||
is NavRequest.OpenAccount ->
|
||||
nav.navigate(Dest.Settings.buildAccount(navRequest.accountId)) { launchSingleTop = true }
|
||||
is NavRequest.NewTask ->
|
||||
nav.navigate(
|
||||
Dest.TaskEdit.buildNew(presetListId = navRequest.listId, title = navRequest.title, dueToday = navRequest.dueToday),
|
||||
)
|
||||
nav.navigate(Dest.TaskEdit.buildNew(presetListId = navRequest.listId, title = navRequest.title))
|
||||
is NavRequest.OpenSmart -> nav.navigate(Dest.TaskList.build(TaskFilter.Smart(navRequest.list))) {
|
||||
launchSingleTop = true
|
||||
}
|
||||
@@ -93,9 +71,6 @@ fun AgendulaNavHost(
|
||||
}
|
||||
is NavRequest.Import -> nav.navigate(Dest.Import.build(navRequest.uri))
|
||||
}
|
||||
val returnHome = (navRequest as? NavRequest.NewTask)?.returnHome == true ||
|
||||
(navRequest as? NavRequest.OpenTask)?.returnHome == true
|
||||
returnHomeEntry = if (returnHome) nav.currentBackStackEntry?.id else null
|
||||
onNavRequestConsumed()
|
||||
}
|
||||
|
||||
@@ -166,7 +141,6 @@ fun AgendulaNavHost(
|
||||
presetListId = (filter as? TaskFilter.OfList)?.listId,
|
||||
tag = (filter as? TaskFilter.Tagged)?.tag,
|
||||
filterId = (filter as? TaskFilter.Saved)?.id,
|
||||
dueToday = filter == TaskFilter.Smart(SmartList.TODAY),
|
||||
),
|
||||
)
|
||||
},
|
||||
@@ -238,7 +212,6 @@ fun AgendulaNavHost(
|
||||
val title = args?.getString(Dest.TaskEdit.ARG_TITLE)
|
||||
val tag = args?.getString(Dest.TaskEdit.ARG_TAG)
|
||||
val filterId = args?.getLong(Dest.TaskEdit.ARG_FILTER_ID)?.takeIf { it != Dest.NO_ID }
|
||||
val dueToday = args?.getBoolean(Dest.TaskEdit.ARG_DUE_TODAY) ?: false
|
||||
val vm: TaskEditViewModel = hiltViewModel()
|
||||
LaunchedEffect(taskId, presetListId, parentId) {
|
||||
if (taskId != Dest.NO_ID) {
|
||||
@@ -250,7 +223,6 @@ fun AgendulaNavHost(
|
||||
initialTitle = title,
|
||||
presetTag = tag,
|
||||
presetFilterId = filterId,
|
||||
presetDueToday = dueToday,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -119,7 +119,7 @@ object Dest {
|
||||
/**
|
||||
* The create / edit form. `taskId` set ([NO_ID] otherwise) ⇒ edit; for a new
|
||||
* task, `presetListId` / `parentId` optionally seed the form, and `filterId`
|
||||
* (or `dueToday`, for the Today list) fills it so the task lands in that view.
|
||||
* fills it so the task lands in that saved filter.
|
||||
*/
|
||||
object TaskEdit {
|
||||
const val ARG_TASK_ID = "taskId"
|
||||
@@ -129,7 +129,6 @@ object Dest {
|
||||
const val ARG_TITLE = "title"
|
||||
const val ARG_TAG = "tag"
|
||||
const val ARG_FILTER_ID = "filterId"
|
||||
const val ARG_DUE_TODAY = "dueToday"
|
||||
const val route =
|
||||
"taskEdit?$ARG_TASK_ID={$ARG_TASK_ID}" +
|
||||
"&$ARG_PRESET_LIST_ID={$ARG_PRESET_LIST_ID}" +
|
||||
@@ -137,8 +136,7 @@ object Dest {
|
||||
"&$ARG_OCCURRENCE={$ARG_OCCURRENCE}" +
|
||||
"&$ARG_TITLE={$ARG_TITLE}" +
|
||||
"&$ARG_TAG={$ARG_TAG}" +
|
||||
"&$ARG_FILTER_ID={$ARG_FILTER_ID}" +
|
||||
"&$ARG_DUE_TODAY={$ARG_DUE_TODAY}"
|
||||
"&$ARG_FILTER_ID={$ARG_FILTER_ID}"
|
||||
|
||||
val arguments = listOf(
|
||||
navArgument(ARG_TASK_ID) { type = NavType.LongType; defaultValue = NO_ID },
|
||||
@@ -148,7 +146,6 @@ object Dest {
|
||||
navArgument(ARG_TITLE) { type = NavType.StringType; nullable = true; defaultValue = null },
|
||||
navArgument(ARG_TAG) { type = NavType.StringType; nullable = true; defaultValue = null },
|
||||
navArgument(ARG_FILTER_ID) { type = NavType.LongType; defaultValue = NO_ID },
|
||||
navArgument(ARG_DUE_TODAY) { type = NavType.BoolType; defaultValue = false },
|
||||
)
|
||||
|
||||
fun buildEdit(taskId: Long, occurrenceStart: Long? = null): String =
|
||||
@@ -161,7 +158,6 @@ object Dest {
|
||||
title: String? = null,
|
||||
tag: String? = null,
|
||||
filterId: Long? = null,
|
||||
dueToday: Boolean = false,
|
||||
): String {
|
||||
val params = buildList {
|
||||
if (presetListId != null) add("$ARG_PRESET_LIST_ID=$presetListId")
|
||||
@@ -169,7 +165,6 @@ object Dest {
|
||||
if (!title.isNullOrBlank()) add("$ARG_TITLE=${android.net.Uri.encode(title)}")
|
||||
if (!tag.isNullOrBlank()) add("$ARG_TAG=${android.net.Uri.encode(tag)}")
|
||||
if (filterId != null) add("$ARG_FILTER_ID=$filterId")
|
||||
if (dueToday) add("$ARG_DUE_TODAY=true")
|
||||
}
|
||||
return if (params.isEmpty()) "taskEdit" else "taskEdit?${params.joinToString("&")}"
|
||||
}
|
||||
|
||||
@@ -9,15 +9,8 @@ import de.jeanlucmakiola.agendula.domain.SmartList
|
||||
* [AgendulaNavHost], which pushes it over whatever is showing.
|
||||
*/
|
||||
sealed interface NavRequest {
|
||||
/**
|
||||
* One task's detail; [occurrenceStart] (epoch millis) picks the occurrence of a series.
|
||||
* [returnHome] leaves the app once the detail is closed (a widget row, #93).
|
||||
*/
|
||||
data class OpenTask(
|
||||
val taskId: Long,
|
||||
val occurrenceStart: Long? = null,
|
||||
val returnHome: Boolean = false,
|
||||
) : NavRequest
|
||||
/** One task's detail; [occurrenceStart] (epoch millis) picks the occurrence of a series. */
|
||||
data class OpenTask(val taskId: Long, val occurrenceStart: Long? = null) : NavRequest
|
||||
|
||||
/** Settings → Accounts, where a sync report's detail lives. */
|
||||
data object OpenAccounts : NavRequest
|
||||
@@ -27,16 +20,9 @@ sealed interface NavRequest {
|
||||
|
||||
/**
|
||||
* A new task, optionally titled with text shared from another app, or
|
||||
* preset to a list — a widget's own add button, when it shows one list —
|
||||
* or due today, from a Today widget.
|
||||
* [returnHome] leaves the app once the form is closed (#93).
|
||||
* preset to a list — a widget's own add button, when it shows one list.
|
||||
*/
|
||||
data class NewTask(
|
||||
val title: String? = null,
|
||||
val listId: Long? = null,
|
||||
val dueToday: Boolean = false,
|
||||
val returnHome: Boolean = false,
|
||||
) : NavRequest
|
||||
data class NewTask(val title: String? = null, val listId: Long? = null) : NavRequest
|
||||
|
||||
/** One of the smart lists — the launcher's "Today" shortcut, a widget header. */
|
||||
data class OpenSmart(val list: SmartList) : NavRequest
|
||||
|
||||
@@ -12,23 +12,16 @@ import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.platform.LocalContext
|
||||
import androidx.compose.ui.res.colorResource
|
||||
import androidx.compose.ui.res.painterResource
|
||||
import androidx.compose.ui.res.stringResource
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
||||
import de.jeanlucmakiola.agendula.R
|
||||
import de.jeanlucmakiola.agendula.data.appname.LauncherName
|
||||
import de.jeanlucmakiola.agendula.data.prefs.ThemeMode
|
||||
import de.jeanlucmakiola.agendula.data.prefs.TimeFormatPref
|
||||
import de.jeanlucmakiola.agendula.data.prefs.is24Hour
|
||||
import de.jeanlucmakiola.agendula.ui.common.formatMinuteOfDay
|
||||
import de.jeanlucmakiola.agendula.ui.common.localeFirstDayOfWeek
|
||||
import de.jeanlucmakiola.floret.components.CollapsingScaffold
|
||||
import de.jeanlucmakiola.floret.components.FullScreenPicker
|
||||
import de.jeanlucmakiola.floret.components.GroupedRow
|
||||
import de.jeanlucmakiola.floret.components.LauncherMark
|
||||
import de.jeanlucmakiola.floret.components.LauncherNameChooser
|
||||
import de.jeanlucmakiola.floret.components.OptionPicker
|
||||
import de.jeanlucmakiola.floret.components.Position
|
||||
import de.jeanlucmakiola.floret.locale.currentLocale
|
||||
@@ -45,8 +38,6 @@ internal fun AppearanceScreen(
|
||||
) {
|
||||
val dynamicColorAvailable = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
|
||||
var showTheme by remember { mutableStateOf(false) }
|
||||
var showAppName by remember { mutableStateOf(false) }
|
||||
val launcherName by viewModel.launcherName.collectAsStateWithLifecycle()
|
||||
var showTimeFormat by remember { mutableStateOf(false) }
|
||||
var showWeekStart by remember { mutableStateOf(false) }
|
||||
val systemIs24Hour = DateFormat.is24HourFormat(LocalContext.current)
|
||||
@@ -99,36 +90,6 @@ internal fun AppearanceScreen(
|
||||
position = Position.Bottom,
|
||||
onClick = { showWeekStart = true },
|
||||
)
|
||||
|
||||
Spacer(Modifier.height(24.dp))
|
||||
GroupedRow(
|
||||
title = stringResource(R.string.settings_app_name),
|
||||
summary = launcherNameLabel(launcherName),
|
||||
position = Position.Alone,
|
||||
onClick = { showAppName = true },
|
||||
)
|
||||
}
|
||||
|
||||
if (showAppName) {
|
||||
FullScreenPicker(
|
||||
title = stringResource(R.string.settings_app_name),
|
||||
onDismiss = { showAppName = false },
|
||||
predictiveBack = true,
|
||||
) {
|
||||
LauncherNameChooser(
|
||||
summary = stringResource(R.string.settings_app_name_hint),
|
||||
options = LauncherName.entries,
|
||||
selected = launcherName,
|
||||
label = { launcherNameLabel(it) },
|
||||
onSelect = viewModel::setLauncherName,
|
||||
mark = {
|
||||
LauncherMark(
|
||||
background = colorResource(R.color.ic_launcher_background),
|
||||
foreground = painterResource(R.drawable.ic_launcher_foreground),
|
||||
)
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
if (showTimeFormat) {
|
||||
@@ -179,7 +140,6 @@ internal fun AppearanceScreen(
|
||||
options = ThemeMode.entries,
|
||||
selected = state.settings.themeMode,
|
||||
label = { stringResource(themeLabel(it)) },
|
||||
summary = { if (it == ThemeMode.BLACK) stringResource(R.string.settings_theme_black_summary) else null },
|
||||
onSelect = viewModel::setThemeMode,
|
||||
onDismiss = { showTheme = false },
|
||||
)
|
||||
@@ -203,17 +163,8 @@ private fun weekStartLabel(day: DayOfWeek?): String =
|
||||
/** 14:00, the sample time "Automatic" is shown with. */
|
||||
private const val SAMPLE_MINUTE_OF_DAY = 14 * 60
|
||||
|
||||
@Composable
|
||||
private fun launcherNameLabel(name: LauncherName): String = stringResource(
|
||||
when (name) {
|
||||
LauncherName.AGENDULA -> R.string.app_name
|
||||
LauncherName.TASKS -> R.string.app_name_tasks_alias
|
||||
},
|
||||
)
|
||||
|
||||
private fun themeLabel(mode: ThemeMode): Int = when (mode) {
|
||||
ThemeMode.SYSTEM -> R.string.settings_theme_system
|
||||
ThemeMode.LIGHT -> R.string.settings_theme_light
|
||||
ThemeMode.DARK -> R.string.settings_theme_dark
|
||||
ThemeMode.BLACK -> R.string.settings_theme_black
|
||||
}
|
||||
@@ -3,8 +3,6 @@ package de.jeanlucmakiola.agendula.ui.settings
|
||||
import androidx.lifecycle.ViewModel
|
||||
import androidx.lifecycle.viewModelScope
|
||||
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.Settings
|
||||
import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
|
||||
@@ -35,7 +33,6 @@ import kotlinx.coroutines.flow.flowOn
|
||||
import kotlinx.coroutines.flow.stateIn
|
||||
import kotlinx.coroutines.flow.update
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.withContext
|
||||
import java.time.DayOfWeek
|
||||
import javax.inject.Inject
|
||||
|
||||
@@ -105,8 +102,7 @@ class SettingsViewModel @Inject constructor(
|
||||
private val oneShotImport: OneShotImport,
|
||||
private val reminderScheduler: ReminderScheduler,
|
||||
private val taskNotifier: TaskNotifier,
|
||||
private val launcherNameManager: LauncherNameManager,
|
||||
@IoDispatcher private val io: CoroutineDispatcher,
|
||||
@IoDispatcher io: CoroutineDispatcher,
|
||||
repository: TasksRepository,
|
||||
) : ViewModel() {
|
||||
|
||||
@@ -188,6 +184,7 @@ class SettingsViewModel @Inject constructor(
|
||||
transferState.update { it.copy(confirming = false, running = true, outcome = null) }
|
||||
viewModelScope.launch {
|
||||
val result = externalImport.run()
|
||||
if (result is TransferResult.Copied) runCatching { reminderScheduler.sync() }
|
||||
transferState.update {
|
||||
it.copy(
|
||||
running = false,
|
||||
@@ -211,6 +208,7 @@ class SettingsViewModel @Inject constructor(
|
||||
retryingLegacyImport.value = true
|
||||
viewModelScope.launch {
|
||||
runCatching { oneShotImport.reimportFromArchive() }
|
||||
runCatching { reminderScheduler.sync() }
|
||||
retryingLegacyImport.value = false
|
||||
}
|
||||
}
|
||||
@@ -219,23 +217,6 @@ class SettingsViewModel @Inject constructor(
|
||||
|
||||
val legacyImportRetrying: StateFlow<Boolean> = retryingLegacyImport
|
||||
|
||||
private val _launcherName = MutableStateFlow(LauncherName.AGENDULA)
|
||||
val launcherName: StateFlow<LauncherName> = _launcherName
|
||||
|
||||
init {
|
||||
viewModelScope.launch { _launcherName.value = withContext(io) { launcherNameManager.current() } }
|
||||
}
|
||||
|
||||
fun setLauncherName(name: LauncherName) {
|
||||
_launcherName.value = name
|
||||
viewModelScope.launch {
|
||||
_launcherName.value = withContext(io) {
|
||||
launcherNameManager.set(name)
|
||||
launcherNameManager.current()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun setThemeMode(mode: ThemeMode) = viewModelScope.launch { prefs.setThemeMode(mode) }
|
||||
fun setDynamicColor(enabled: Boolean) = viewModelScope.launch { prefs.setDynamicColor(enabled) }
|
||||
fun setDefaultList(id: Long?) = viewModelScope.launch { prefs.setDefaultListId(id) }
|
||||
|
||||
@@ -112,8 +112,6 @@ import de.jeanlucmakiola.agendula.domain.TaskFilter
|
||||
import de.jeanlucmakiola.agendula.domain.TaskSection
|
||||
import de.jeanlucmakiola.agendula.domain.TaskSections
|
||||
import de.jeanlucmakiola.agendula.ui.common.LocalUse24HourFormat
|
||||
import de.jeanlucmakiola.agendula.ui.common.SyncPullBox
|
||||
import de.jeanlucmakiola.agendula.ui.common.ignoringEdgeSwipes
|
||||
import de.jeanlucmakiola.agendula.ui.common.priorityAccent
|
||||
import de.jeanlucmakiola.agendula.ui.lists.ListEditorSheet
|
||||
import de.jeanlucmakiola.agendula.ui.lists.listWriteFailureMessage
|
||||
@@ -146,8 +144,6 @@ fun TaskListScreen(
|
||||
viewModel: TaskListViewModel = hiltViewModel(),
|
||||
) {
|
||||
val state by viewModel.state.collectAsStateWithLifecycle()
|
||||
val syncAvailable by viewModel.syncAvailable.collectAsStateWithLifecycle()
|
||||
val syncing by viewModel.syncing.collectAsStateWithLifecycle()
|
||||
val scrollBehavior = TopAppBarDefaults.exitUntilCollapsedScrollBehavior()
|
||||
val content = state as? TaskListUiState.Content
|
||||
val list = content?.list
|
||||
@@ -251,21 +247,13 @@ fun TaskListScreen(
|
||||
},
|
||||
) { inner ->
|
||||
Box(modifier = Modifier.fillMaxSize()) {
|
||||
SyncPullBox(
|
||||
available = syncAvailable,
|
||||
syncing = syncing,
|
||||
onSync = viewModel::syncAll,
|
||||
modifier = Modifier.fillMaxSize(),
|
||||
topPadding = inner.calculateTopPadding(),
|
||||
) {
|
||||
when (val s = state) {
|
||||
TaskListUiState.Loading -> Unit // brief; avoids a flash before first emission
|
||||
TaskListUiState.Failure -> CenteredMessage(stringResource(R.string.task_list_failure), inner)
|
||||
is TaskListUiState.Content -> TaskListBody(
|
||||
s, filter, inner, onOpenTask, onRequestDelete, viewModel,
|
||||
onClearCompleted = if (listId != null && list?.isReadOnly != true) ({ confirmClear = true }) else null,
|
||||
)
|
||||
}
|
||||
when (val s = state) {
|
||||
TaskListUiState.Loading -> Unit // brief; avoids a flash before first emission
|
||||
TaskListUiState.Failure -> CenteredMessage(stringResource(R.string.task_list_failure), inner)
|
||||
is TaskListUiState.Content -> TaskListBody(
|
||||
s, filter, inner, onOpenTask, onRequestDelete, viewModel,
|
||||
onClearCompleted = if (listId != null && list?.isReadOnly != true) ({ confirmClear = true }) else null,
|
||||
)
|
||||
}
|
||||
// A FAB-height band anchored at the bottom-start with the FAB's own
|
||||
// margin; centring the chip in it lines the chip up beside the bottom-end
|
||||
@@ -367,7 +355,7 @@ private fun TaskListBody(
|
||||
viewModel: TaskListViewModel,
|
||||
onClearCompleted: (() -> Unit)? = null,
|
||||
) {
|
||||
val (todayStart, todayEnd) = remember(state.tasks) { DayWindow.today(Clock.System.now(), ZoneId.systemDefault()) }
|
||||
val (todayStart, todayEnd) = remember { DayWindow.today(Clock.System.now(), ZoneId.systemDefault()) }
|
||||
// A parent represents its children via a progress chip (counts come from the
|
||||
// repository, over the full set), so drop children from the flat list — unless
|
||||
// their parent isn't in this view (can happen in smart lists), where we keep
|
||||
@@ -376,15 +364,15 @@ private fun TaskListBody(
|
||||
val present = state.tasks.mapTo(HashSet()) { it.taskId }
|
||||
state.tasks.filter { (it.parentId ?: 0L) <= 0L || it.parentId !in present }
|
||||
}
|
||||
val sections = remember(displayTasks, todayStart) {
|
||||
TaskSections.of(displayTasks, todayStart, todayEnd, todayList = filter == TaskFilter.Smart(SmartList.TODAY))
|
||||
}
|
||||
val sections = remember(displayTasks) { TaskSections.of(displayTasks, todayStart, todayEnd) }
|
||||
val showHeaders = sections.size > 1
|
||||
val listId = (filter as? TaskFilter.OfList)?.listId
|
||||
// In a mixed view (a smart list) the list colour bar + name disambiguate
|
||||
// rows; inside a single real list both are redundant.
|
||||
val showListName = filter is TaskFilter.Smart || filter is TaskFilter.Tagged ||
|
||||
(filter is TaskFilter.Saved && state.savedFilter?.listIds?.size != 1)
|
||||
// Completed tasks collapse away by default to keep the active list in focus.
|
||||
var completedExpanded by rememberSaveable { mutableStateOf(false) }
|
||||
// Parents the user expanded to reveal their subtasks inline. Children are
|
||||
// grouped from the same flat task set the list already holds.
|
||||
var expandedParents by rememberSaveable { mutableStateOf(emptySet<Long>()) }
|
||||
@@ -432,20 +420,23 @@ private fun TaskListBody(
|
||||
}
|
||||
|
||||
sections.forEach { section ->
|
||||
// Every header folds its section away (#91); Done starts folded.
|
||||
val expanded = !showHeaders || section.section !in state.collapsedSections
|
||||
val collapsible = showHeaders && section.section == TaskSection.COMPLETED
|
||||
if (showHeaders) {
|
||||
stickyHeader(key = "hdr-${section.section}") {
|
||||
CollapsibleSectionHeader(
|
||||
label = sectionLabel(section.section),
|
||||
count = section.tasks.size,
|
||||
expanded = expanded,
|
||||
onToggle = { viewModel.setSectionCollapsed(section.section, expanded) },
|
||||
onClear = onClearCompleted.takeIf { section.section == TaskSection.COMPLETED },
|
||||
)
|
||||
if (collapsible) {
|
||||
CollapsibleSectionHeader(
|
||||
label = sectionLabel(section.section),
|
||||
count = section.tasks.size,
|
||||
expanded = completedExpanded,
|
||||
onToggle = { completedExpanded = !completedExpanded },
|
||||
onClear = onClearCompleted,
|
||||
)
|
||||
} else {
|
||||
SectionHeader(sectionLabel(section.section))
|
||||
}
|
||||
}
|
||||
}
|
||||
if (expanded) {
|
||||
if (!collapsible || completedExpanded) {
|
||||
// Flatten the section into one grouped run: each parent, followed
|
||||
// by its subtasks when expanded. Each row's corners then come from
|
||||
// its place in the whole run (positionOf below) — so the children
|
||||
@@ -664,7 +655,7 @@ private fun TaskRow(
|
||||
|
||||
SwipeToDismissBox(
|
||||
state = dismissState,
|
||||
modifier = modifier.ignoringEdgeSwipes().fillMaxWidth().padding(horizontal = 16.dp).then(gap),
|
||||
modifier = modifier.fillMaxWidth().padding(horizontal = 16.dp).then(gap),
|
||||
// dismissDirection (not targetValue) tracks the live drag, so the colour +
|
||||
// icon reveal as you swipe rather than only once the threshold is crossed.
|
||||
backgroundContent = { SwipeBackground(dismissState.dismissDirection, task.isCompleted) },
|
||||
@@ -1046,7 +1037,7 @@ private fun SubtaskRow(
|
||||
val gap = if (lastInRun) Modifier else Modifier.padding(bottom = 2.dp)
|
||||
SwipeToDismissBox(
|
||||
state = dismissState,
|
||||
modifier = modifier.ignoringEdgeSwipes().fillMaxWidth().padding(horizontal = 16.dp).then(gap),
|
||||
modifier = modifier.fillMaxWidth().padding(horizontal = 16.dp).then(gap),
|
||||
backgroundContent = { SwipeBackground(dismissState.dismissDirection, task.isCompleted) },
|
||||
) {
|
||||
Surface(
|
||||
@@ -1136,6 +1127,19 @@ private fun cardShape(position: Position, full: androidx.compose.ui.unit.Dp, sma
|
||||
Position.Bottom -> RoundedCornerShape(topStart = small, topEnd = small, bottomStart = full, bottomEnd = full)
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun SectionHeader(text: String) {
|
||||
// Opaque surface so rows scroll cleanly under the pinned header.
|
||||
Surface(color = MaterialTheme.colorScheme.surface, modifier = Modifier.fillMaxWidth()) {
|
||||
Text(
|
||||
text = text,
|
||||
style = MaterialTheme.typography.titleSmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
modifier = Modifier.padding(start = 28.dp, end = 28.dp, top = 16.dp, bottom = 8.dp),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/** A tappable section header with a count and a chevron that rotates on expand. */
|
||||
@Composable
|
||||
private fun CollapsibleSectionHeader(
|
||||
|
||||
@@ -3,7 +3,6 @@ package de.jeanlucmakiola.agendula.ui.tasklist
|
||||
import androidx.lifecycle.ViewModel
|
||||
import androidx.lifecycle.viewModelScope
|
||||
import dagger.hilt.android.lifecycle.HiltViewModel
|
||||
import de.jeanlucmakiola.agendula.data.prefs.DEFAULT_COLLAPSED_SECTIONS
|
||||
import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
|
||||
import de.jeanlucmakiola.agendula.data.sync.RemoteLists
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TasksRepository
|
||||
@@ -15,13 +14,11 @@ import de.jeanlucmakiola.agendula.domain.TaskFiltering
|
||||
import de.jeanlucmakiola.agendula.domain.tagsInUse
|
||||
import de.jeanlucmakiola.agendula.domain.TaskForm
|
||||
import de.jeanlucmakiola.agendula.domain.TaskList
|
||||
import de.jeanlucmakiola.agendula.domain.TaskSection
|
||||
import de.jeanlucmakiola.agendula.domain.TaskSortOrder
|
||||
import de.jeanlucmakiola.agendula.domain.comparator
|
||||
import de.jeanlucmakiola.agendula.ui.lists.ListWriteFailure
|
||||
import de.jeanlucmakiola.agendula.ui.lists.asFailure
|
||||
import de.jeanlucmakiola.agendula.data.di.ApplicationScope
|
||||
import de.jeanlucmakiola.agendula.data.sync.ManualSync
|
||||
import de.jeanlucmakiola.agendula.domain.recurrence.RecurringScope
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.ExperimentalCoroutinesApi
|
||||
@@ -59,8 +56,6 @@ sealed interface TaskListUiState {
|
||||
/** Whether a real list uses the bottom quick-add bar instead of the FAB. */
|
||||
val bottomAddBar: Boolean = false,
|
||||
val sortOrder: TaskSortOrder = TaskSortOrder.DUE,
|
||||
/** Sections whose rows are folded under their header. */
|
||||
val collapsedSections: Set<TaskSection> = DEFAULT_COLLAPSED_SECTIONS,
|
||||
/** This real list is kept out of the smart lists. */
|
||||
val hiddenFromSmartLists: Boolean = false,
|
||||
/** Tags the unnarrowed view carries, offered as filter chips. */
|
||||
@@ -94,17 +89,9 @@ class TaskListViewModel @Inject constructor(
|
||||
private val repository: TasksRepository,
|
||||
private val settingsPrefs: SettingsPrefs,
|
||||
private val remoteLists: RemoteLists,
|
||||
private val manualSync: ManualSync,
|
||||
@ApplicationScope private val appScope: CoroutineScope,
|
||||
) : ViewModel() {
|
||||
|
||||
/** Pull to sync (#73); off without an account. */
|
||||
val syncAvailable: StateFlow<Boolean> =
|
||||
manualSync.available.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), false)
|
||||
val syncing: StateFlow<Boolean> = manualSync.syncing
|
||||
|
||||
fun syncAll() = manualSync.syncAll()
|
||||
|
||||
private val filter = MutableStateFlow<TaskFilter?>(null)
|
||||
|
||||
private val tagFilter = MutableStateFlow<Set<String>>(emptySet())
|
||||
@@ -157,7 +144,6 @@ class TaskListViewModel @Inject constructor(
|
||||
showAddSubtaskRow = settings.showAddSubtaskRow,
|
||||
bottomAddBar = settings.bottomAddBar,
|
||||
sortOrder = settings.sortOrder,
|
||||
collapsedSections = settings.collapsedSections,
|
||||
hiddenFromSmartLists = st.list?.id?.let { it in settings.hiddenFromSmartLists } ?: false,
|
||||
)
|
||||
} else {
|
||||
@@ -291,9 +277,6 @@ class TaskListViewModel @Inject constructor(
|
||||
fun setHiddenFromSmartLists(listId: Long, hidden: Boolean) =
|
||||
viewModelScope.launch { settingsPrefs.setHiddenFromSmartLists(listId, hidden) }
|
||||
|
||||
fun setSectionCollapsed(section: TaskSection, collapsed: Boolean) =
|
||||
viewModelScope.launch { settingsPrefs.setSectionCollapsed(section, collapsed) }
|
||||
|
||||
fun setSortOrder(order: TaskSortOrder) = viewModelScope.launch { settingsPrefs.setSortOrder(order) }
|
||||
|
||||
/**
|
||||
|
||||
@@ -1,44 +0,0 @@
|
||||
package de.jeanlucmakiola.agendula.ui.theme
|
||||
|
||||
import android.app.Activity
|
||||
import android.app.UiModeManager
|
||||
import android.os.Build
|
||||
import androidx.annotation.StyleRes
|
||||
import de.jeanlucmakiola.agendula.R
|
||||
import de.jeanlucmakiola.agendula.data.prefs.ThemeMode
|
||||
|
||||
/**
|
||||
* Hands the app's theme setting to the system, which draws the launch window
|
||||
* and splash before any of the app runs (#119). The system keeps both across
|
||||
* launches, so the next start already matches.
|
||||
*/
|
||||
object SystemTheme {
|
||||
|
||||
/** The light or dark the app's resources follow, as [UiModeManager.setApplicationNightMode] takes it. */
|
||||
fun nightModeOf(mode: ThemeMode): Int = when (mode) {
|
||||
ThemeMode.SYSTEM -> UiModeManager.MODE_NIGHT_AUTO
|
||||
ThemeMode.LIGHT -> UiModeManager.MODE_NIGHT_NO
|
||||
ThemeMode.DARK, ThemeMode.BLACK -> UiModeManager.MODE_NIGHT_YES
|
||||
}
|
||||
|
||||
/** The splash theme whose background is the one the app opens on. */
|
||||
@StyleRes
|
||||
fun splashThemeOf(mode: ThemeMode, dynamicColor: Boolean): Int = when {
|
||||
mode.isPureBlack -> R.style.Theme_Agendula_Black
|
||||
dynamicColor -> R.style.Theme_Agendula
|
||||
else -> R.style.Theme_Agendula_Fallback
|
||||
}
|
||||
|
||||
/**
|
||||
* Applies [mode] and [dynamicColor]. A night mode the activity does not
|
||||
* have yet recreates it, once; the same one again changes nothing.
|
||||
*/
|
||||
fun apply(activity: Activity, mode: ThemeMode, dynamicColor: Boolean) {
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
|
||||
activity.getSystemService(UiModeManager::class.java)?.setApplicationNightMode(nightModeOf(mode))
|
||||
}
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
|
||||
activity.splashScreen.setSplashScreenTheme(splashThemeOf(mode, dynamicColor))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -15,7 +15,6 @@ import de.jeanlucmakiola.floret.identity.FloretExpressiveTheme
|
||||
fun AgendulaTheme(
|
||||
darkTheme: Boolean = isSystemInDarkTheme(),
|
||||
dynamicColor: Boolean = true,
|
||||
pureBlack: Boolean = false,
|
||||
content: @Composable () -> Unit,
|
||||
) {
|
||||
FloretExpressiveTheme(
|
||||
@@ -23,7 +22,6 @@ fun AgendulaTheme(
|
||||
darkScheme = AgendulaDarkFallback,
|
||||
darkTheme = darkTheme,
|
||||
dynamicColor = dynamicColor,
|
||||
pureBlack = pureBlack,
|
||||
typography = AgendulaTypography,
|
||||
content = content,
|
||||
)
|
||||
|
||||
@@ -194,12 +194,10 @@ private fun TaskWidgetBody(
|
||||
Spacer(GlanceModifier.height(R.dimen.widget_tasks_header_gap_tight))
|
||||
WidgetDoneState(context.getString(R.string.widget_empty), context.getString(R.string.widget_empty_hint))
|
||||
} else {
|
||||
val todayList = filter == TaskFilter.Smart(SmartList.TODAY)
|
||||
val allSections = widgetSections(
|
||||
data.rows,
|
||||
data.groupByList,
|
||||
data.listNames,
|
||||
todayList,
|
||||
) { kind -> context.getString(dueBucketLabel(kind)) }
|
||||
// A lone group whose bucket repeats the widget's own smart list
|
||||
// (the "Today" smart list showing one "Today" bucket) earns no
|
||||
@@ -250,8 +248,7 @@ private fun TaskWidgetBody(
|
||||
// (Today / Tomorrow) whenever one is shown — and when
|
||||
// it isn't, that's only because it would have repeated
|
||||
// the title, which names the same day just as well.
|
||||
suppressDayLabel = !data.groupByList &&
|
||||
(!todayList || section.row.dueKind == DueKind.TODAY),
|
||||
suppressDayLabel = !data.groupByList,
|
||||
)
|
||||
Spacer(GlanceModifier.height(8.dp))
|
||||
}
|
||||
@@ -307,9 +304,7 @@ private fun TaskWidgetHeader(title: String, filter: TaskFilter, singleListId: Lo
|
||||
WidgetHeaderAction(
|
||||
icon = ImageProvider(GlanceR.drawable.floret_ic_widget_add),
|
||||
contentDescription = context.getString(R.string.new_task),
|
||||
action = actionStartActivity(
|
||||
MainActivity.newTaskIntent(context, singleListId, dueToday = filter == TaskFilter.Smart(SmartList.TODAY)),
|
||||
),
|
||||
action = actionStartActivity(MainActivity.newTaskIntent(context, singleListId)),
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -333,7 +328,7 @@ internal fun AgendaTaskRow(
|
||||
val context = LocalContext.current
|
||||
val title = row.title.ifBlank { context.getString(R.string.task_untitled) }
|
||||
val open = actionStartActivity(
|
||||
MainActivity.taskIntent(context, row.taskId, row.occurrenceStart?.toEpochMilliseconds(), returnHome = true),
|
||||
MainActivity.taskIntent(context, row.taskId, row.occurrenceStart?.toEpochMilliseconds()),
|
||||
)
|
||||
val onColor = if (colored) GlanceColorProvider(Color.White) else GlanceTheme.colors.onSurface
|
||||
val onColorVariant = if (colored) GlanceColorProvider(Color.White.copy(alpha = 0.8f)) else GlanceTheme.colors.onSurfaceVariant
|
||||
|
||||
@@ -39,6 +39,7 @@ import dagger.hilt.android.AndroidEntryPoint
|
||||
import de.jeanlucmakiola.agendula.R
|
||||
import de.jeanlucmakiola.agendula.data.prefs.Settings
|
||||
import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
|
||||
import de.jeanlucmakiola.agendula.data.prefs.ThemeMode
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TasksRepository
|
||||
import de.jeanlucmakiola.agendula.domain.SavedFilter
|
||||
import de.jeanlucmakiola.agendula.domain.SmartList
|
||||
@@ -134,12 +135,12 @@ class TaskWidgetConfigActivity : ComponentActivity() {
|
||||
rowColor = parseWidgetRowColor(state[WIDGET_ROW_COLOR_KEY])
|
||||
selectedListIds = parseWidgetListIds(state[WIDGET_LIST_IDS_KEY])
|
||||
}
|
||||
val dark = settings.themeMode.isDark(isSystemInDarkTheme())
|
||||
AgendulaTheme(
|
||||
darkTheme = dark,
|
||||
dynamicColor = settings.dynamicColor,
|
||||
pureBlack = settings.themeMode.isPureBlack,
|
||||
) {
|
||||
val dark = when (settings.themeMode) {
|
||||
ThemeMode.SYSTEM -> isSystemInDarkTheme()
|
||||
ThemeMode.LIGHT -> false
|
||||
ThemeMode.DARK -> true
|
||||
}
|
||||
AgendulaTheme(darkTheme = dark, dynamicColor = settings.dynamicColor) {
|
||||
Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.surface) {}
|
||||
WidgetFilterPicker(
|
||||
kind = kind,
|
||||
|
||||
@@ -3,11 +3,14 @@ package de.jeanlucmakiola.agendula.widget
|
||||
import android.content.Context
|
||||
import dagger.hilt.android.qualifiers.ApplicationContext
|
||||
import de.jeanlucmakiola.agendula.data.di.ApplicationScope
|
||||
import de.jeanlucmakiola.agendula.data.tasks.StoreChangeDebouncer
|
||||
import de.jeanlucmakiola.agendula.data.tasks.TasksDataSource
|
||||
import de.jeanlucmakiola.floret.glance.WidgetRollover
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.FlowPreview
|
||||
import kotlinx.coroutines.channels.Channel
|
||||
import kotlinx.coroutines.flow.debounce
|
||||
import kotlinx.coroutines.flow.receiveAsFlow
|
||||
import kotlinx.coroutines.launch
|
||||
import javax.inject.Inject
|
||||
import javax.inject.Singleton
|
||||
@@ -23,10 +26,16 @@ class TaskWidgetUpdater @Inject constructor(
|
||||
private val dataSource: TasksDataSource,
|
||||
@ApplicationScope private val scope: CoroutineScope,
|
||||
) {
|
||||
private val changes = StoreChangeDebouncer(scope, DEBOUNCE_MILLIS, dataSource::registerObserver, ::redraw)
|
||||
private val requests = Channel<Unit>(Channel.CONFLATED)
|
||||
private var observer: AutoCloseable? = null
|
||||
|
||||
@OptIn(FlowPreview::class)
|
||||
fun start() {
|
||||
if (!changes.start()) return
|
||||
if (observer != null) return
|
||||
observer = runCatching { dataSource.registerObserver { requests.trySend(Unit) } }.getOrNull()
|
||||
scope.launch(Dispatchers.IO) {
|
||||
requests.receiveAsFlow().debounce(DEBOUNCE_MILLIS).collect { redraw() }
|
||||
}
|
||||
scope.launch(Dispatchers.IO) {
|
||||
runCatching { WidgetRollover.sync(context, WIDGET_RECEIVER_CLASSES, ::widgetRolloverPendingIntent) }
|
||||
}
|
||||
@@ -35,7 +44,9 @@ class TaskWidgetUpdater @Inject constructor(
|
||||
}
|
||||
|
||||
/** Redraw soon; bursts collapse into one pass. */
|
||||
fun requestRefresh() = changes.request()
|
||||
fun requestRefresh() {
|
||||
requests.trySend(Unit)
|
||||
}
|
||||
|
||||
private suspend fun redraw() {
|
||||
runCatching {
|
||||
|
||||
@@ -100,7 +100,7 @@ private fun TodayWidgetBody(data: WidgetStatsData?, background: WidgetBackground
|
||||
WidgetHeaderAction(
|
||||
icon = ImageProvider(GlanceR.drawable.floret_ic_widget_add),
|
||||
contentDescription = context.getString(R.string.new_task),
|
||||
action = actionStartActivity(MainActivity.newTaskIntent(context, dueToday = true)),
|
||||
action = actionStartActivity(MainActivity.newTaskIntent(context)),
|
||||
)
|
||||
}
|
||||
Spacer(GlanceModifier.height(HeaderGap))
|
||||
|
||||
@@ -339,7 +339,7 @@ private fun ListDot(color: Int) {
|
||||
}
|
||||
|
||||
private fun openTask(context: Context, row: WidgetTaskRow): Action =
|
||||
actionStartActivity(MainActivity.taskIntent(context, row.taskId, row.occurrenceStart?.toEpochMilliseconds(), returnHome = true))
|
||||
actionStartActivity(MainActivity.taskIntent(context, row.taskId, row.occurrenceStart?.toEpochMilliseconds()))
|
||||
|
||||
private fun completeTask(row: WidgetTaskRow): Action =
|
||||
actionRunCallback<CompleteTaskAction>(
|
||||
|
||||
@@ -82,7 +82,7 @@ internal fun effectiveThemeMode(appThemeMode: ThemeMode, override: WidgetThemeMo
|
||||
override ?: when (appThemeMode) {
|
||||
ThemeMode.SYSTEM -> WidgetThemeMode.SYSTEM
|
||||
ThemeMode.LIGHT -> WidgetThemeMode.LIGHT
|
||||
ThemeMode.DARK, ThemeMode.BLACK -> WidgetThemeMode.DARK
|
||||
ThemeMode.DARK -> WidgetThemeMode.DARK
|
||||
}
|
||||
|
||||
/** The smart lists a widget can show, in picker order. */
|
||||
@@ -200,14 +200,12 @@ private fun headedRuns(runs: List<WidgetRun>): List<WidgetSection> =
|
||||
* (already sorted that way by [widgetRows]), otherwise one per [DueKind]
|
||||
* bucket — "Overdue" / "Today" / "Tomorrow" / "Later" / "No date" — in that
|
||||
* fixed order, since [rows] isn't due-sorted. Each run becomes one header
|
||||
* followed by its own standalone, independently coloured task pills. The Today
|
||||
* list ([todayList]) is one "Today" bucket, as a row may be there by its start.
|
||||
* followed by its own standalone, independently coloured task pills.
|
||||
*/
|
||||
internal fun widgetSections(
|
||||
rows: List<WidgetTaskRow>,
|
||||
groupByList: Boolean,
|
||||
listNames: Map<Long, String>,
|
||||
todayList: Boolean = false,
|
||||
dueBucketLabel: (DueKind?) -> String,
|
||||
): List<WidgetSection> {
|
||||
if (groupByList) {
|
||||
@@ -222,7 +220,7 @@ internal fun widgetSections(
|
||||
}
|
||||
return headedRuns(runs)
|
||||
}
|
||||
val buckets = rows.groupBy { if (todayList) DueKind.TODAY else it.dueKind }
|
||||
val buckets = rows.groupBy { it.dueKind }
|
||||
val runs = DueKind.entries.plus(null).mapNotNull { kind ->
|
||||
buckets[kind]?.takeIf { it.isNotEmpty() }
|
||||
?.let { WidgetRun("due:${kind?.name.orEmpty()}", dueBucketLabel(kind), it) }
|
||||
|
||||
@@ -7,11 +7,9 @@ import de.jeanlucmakiola.agendula.data.prefs.is24Hour
|
||||
import de.jeanlucmakiola.agendula.domain.SmartList
|
||||
import de.jeanlucmakiola.agendula.domain.Task
|
||||
import de.jeanlucmakiola.agendula.domain.TaskFilter
|
||||
import de.jeanlucmakiola.agendula.domain.TaskFiltering
|
||||
import de.jeanlucmakiola.agendula.domain.TaskList
|
||||
import de.jeanlucmakiola.agendula.domain.calendarDate
|
||||
import de.jeanlucmakiola.agendula.domain.comparator
|
||||
import de.jeanlucmakiola.floret.time.DayWindow
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.catch
|
||||
import kotlinx.coroutines.flow.combine
|
||||
@@ -47,15 +45,10 @@ internal sealed interface WidgetStatsData {
|
||||
|
||||
private const val MAX_TODAY_ROWS = 20
|
||||
|
||||
/** Whether this open task is on the Today widget's plate: in the app's Today, or overdue. */
|
||||
private fun Task.isDueToday(now: Instant, today: LocalDate, todayStart: Instant, todayEnd: Instant, zone: ZoneId): Boolean =
|
||||
TaskFiltering.isToday(this, todayStart, todayEnd, zone) ||
|
||||
due?.let { isOverdue(it, isAllDay, now, today, zone) } == true
|
||||
|
||||
/**
|
||||
* How far through today a set of [open] and [completed] tasks says you are:
|
||||
* the app's Today tasks done and still open ([TaskFiltering.isToday]) plus the
|
||||
* overdue ones, the open ones in [comparator] order, and those tasks as rows.
|
||||
* tasks done today (by [Task.completedAt]'s local date), tasks still open that
|
||||
* are overdue or due today (in [comparator] order), and those tasks as rows.
|
||||
*/
|
||||
internal fun todayProgress(
|
||||
open: List<Task>,
|
||||
@@ -65,9 +58,14 @@ internal fun todayProgress(
|
||||
today: LocalDate,
|
||||
zone: ZoneId,
|
||||
): Triple<Int, Int, List<WidgetTaskRow>> {
|
||||
val (todayStart, todayEnd) = DayWindow.today(now, zone)
|
||||
val done = completed.count { TaskFiltering.isToday(it, todayStart, todayEnd, zone) }
|
||||
val remaining = open.filter { it.isDueToday(now, today, todayStart, todayEnd, zone) }.sortedWith(comparator)
|
||||
val done = completed.count { task ->
|
||||
val at = task.completedAt ?: return@count false
|
||||
at.toLocalDate(zone) == today
|
||||
}
|
||||
val remaining = open.filter { task ->
|
||||
val due = task.due ?: return@filter false
|
||||
isOverdue(due, task.isAllDay, now, today, zone) || dueKind(due, task.isAllDay, today, zone) == DueKind.TODAY
|
||||
}.sortedWith(comparator)
|
||||
return Triple(done, remaining.size, remaining.take(MAX_TODAY_ROWS).map { it.toWidgetRow(now, today, zone) })
|
||||
}
|
||||
|
||||
@@ -78,29 +76,29 @@ internal fun upcoming(open: List<Task>, now: Instant, today: LocalDate, zone: Zo
|
||||
private const val MAX_UPCOMING_ROWS = 200
|
||||
|
||||
/**
|
||||
* Seven [WeekDay]s starting at [today]. Today's bucket holds what the Today
|
||||
* widget counts — the app's Today tasks plus every overdue one; every other day
|
||||
* holds the rest by their own due date.
|
||||
* Seven [WeekDay]s starting at [today]. Today's bucket folds in every overdue
|
||||
* task regardless of its own due day, since that's where the app's own
|
||||
* Overdue/Today smart lists put it; every other day matches its own due date.
|
||||
*/
|
||||
internal fun weekDays(open: List<Task>, comparator: Comparator<Task>, now: Instant, today: LocalDate, zone: ZoneId): List<WeekDay> {
|
||||
val (todayStart, todayEnd) = DayWindow.today(now, zone)
|
||||
val (todays, later) = open.partition { it.isDueToday(now, today, todayStart, todayEnd, zone) }
|
||||
return (0..6L).map { offset ->
|
||||
internal fun weekDays(open: List<Task>, comparator: Comparator<Task>, now: Instant, today: LocalDate, zone: ZoneId): List<WeekDay> =
|
||||
(0..6L).map { offset ->
|
||||
val date = today.plusDays(offset)
|
||||
val dayTasks = if (offset == 0L) {
|
||||
todays
|
||||
} else {
|
||||
later.filter { task -> task.due?.calendarDate(task.isAllDay, zone) == date }
|
||||
val dayTasks = open.filter { task ->
|
||||
val due = task.due ?: return@filter false
|
||||
if (offset == 0L) {
|
||||
isOverdue(due, task.isAllDay, now, today, zone) || due.calendarDate(task.isAllDay, zone) == date
|
||||
} else {
|
||||
due.calendarDate(task.isAllDay, zone) == date
|
||||
}
|
||||
}
|
||||
val overdueCount = if (offset == 0L) {
|
||||
dayTasks.count { task -> task.due?.let { isOverdue(it, task.isAllDay, now, today, zone) } == true }
|
||||
dayTasks.count { isOverdue(it.due!!, it.isAllDay, now, today, zone) }
|
||||
} else {
|
||||
0
|
||||
}
|
||||
val first = dayTasks.sortedWith(comparator).firstOrNull()?.toWidgetRow(now, today, zone)
|
||||
WeekDay(date, dayTasks.size, overdueCount, first)
|
||||
}
|
||||
}
|
||||
|
||||
/** One tile per visible list: its open, non-subtask count — a subtask whose parent is also open is left out. */
|
||||
internal fun listTiles(open: List<Task>, lists: List<TaskList>): List<ListTile> {
|
||||
|
||||
@@ -55,8 +55,8 @@
|
||||
<string name="settings_theme">السمة</string>
|
||||
<string name="settings_theme_light">فاتح</string>
|
||||
<string name="settings_theme_dark">داكن</string>
|
||||
<string name="settings_section_reminders">الإشعارات</string>
|
||||
<string name="settings_list_notifications">الصوت والاهتزاز</string>
|
||||
<string name="settings_section_reminders">التذكيرات</string>
|
||||
<string name="settings_list_notifications">الإشعارات</string>
|
||||
<string name="settings_group_data">البيانات</string>
|
||||
<string name="settings_group_app">التطبيق</string>
|
||||
<string name="settings_group_about">حول</string>
|
||||
@@ -65,7 +65,7 @@
|
||||
<string name="settings_section_storage">التخزين</string>
|
||||
<string name="settings_section_accounts">الحسابات</string>
|
||||
<string name="settings_list_reminder_inherits">الافتراضي (%1$s)</string>
|
||||
<string name="settings_section_task_form">نموذج مهمة جديدة</string>
|
||||
<string name="settings_section_task_form">نموذج مهمة</string>
|
||||
<string name="settings_about_support">دَعم التطوير</string>
|
||||
<string name="settings_about_version">الإصدار %1$s</string>
|
||||
<string name="settings_language">لغة التطبيق</string>
|
||||
@@ -73,7 +73,7 @@
|
||||
<string name="settings_translate">المساعدة في الترجمة</string>
|
||||
<string name="settings_theme_system">اتباع النظام</string>
|
||||
<string name="settings_dynamic_color">اللون الديناميكي</string>
|
||||
<string name="settings_reminders">تذكيرات المهام</string>
|
||||
<string name="settings_reminders">التذكيرات المستحقة</string>
|
||||
<string name="settings_exact_alarms">التوقيت الدقيق</string>
|
||||
<string name="settings_default_list">القائمة الافتراضية</string>
|
||||
<string name="settings_time_format">تنسيق الوقت</string>
|
||||
@@ -90,7 +90,7 @@
|
||||
<string name="settings_about_author">بواسطة Jean-Luc Makiola</string>
|
||||
<string name="settings_about_logo_desc">رمز تطبيق Agendula</string>
|
||||
<string name="settings_report_problem">الإبلاغ عن مشكلة</string>
|
||||
<string name="settings_default_reminder">التذكير الافتراضي</string>
|
||||
<string name="settings_default_reminder">متى لتذكير</string>
|
||||
<string name="settings_group_look">المظهر و السلوك</string>
|
||||
<string name="settings_bottom_add_bar">شريط الإضافة السريع السفلي</string>
|
||||
<string name="settings_time_format_12h">١٢-ساعة (٢:٠٠ م)</string>
|
||||
@@ -168,7 +168,7 @@
|
||||
<string name="reminder_unit_days">أيام</string>
|
||||
<string name="reminder_unit_weeks">أسابيع</string>
|
||||
<string name="settings_list_reminders_title">التذكيرات لكل قائمة</string>
|
||||
<string name="settings_list_reminders_hint">تجاوز الافتراضي لكل قائمة — بشكل منفصل للمحدد بوقت ومهام طوال اليوم. يمكن لقائمة الاحتفاظ بالافتراضي، إسقاطه أو تعيين خاصّته.</string>
|
||||
<string name="settings_list_reminders_hint">تجاوز التذكير الافتراضي للقوائم الفردية</string>
|
||||
<string name="lists_reorder_handle">اسحب لإعادة الترتيب</string>
|
||||
<string name="settings_list_notifications_hint">الصوت، الاهتزاز و الأهمية لتذكيرات هذه القائمة</string>
|
||||
<string name="smart_today">اليوم</string>
|
||||
@@ -446,8 +446,8 @@
|
||||
<string name="filter_missing">تم حذف عامل التصفية</string>
|
||||
<string name="view_filter_tags">تصفية حسب الوسم</string>
|
||||
<string name="filter_section_lists">القوائم</string>
|
||||
<string name="settings_appearance_subtitle">السمة، الألوان، تنسيق الوقت</string>
|
||||
<string name="settings_task_form_subtitle">الخانات الافتراضية و السلوك</string>
|
||||
<string name="settings_appearance_subtitle">السمة، اللون و تنسيق الوقت</string>
|
||||
<string name="settings_task_form_subtitle">الحقول، القائمة والمهام الفرعية الافتراضية</string>
|
||||
<string name="recurrence_on_days">%1$s في %2$s</string>
|
||||
<string name="recurrence_with_until">%1$s حتى %2$s</string>
|
||||
<plurals name="recurrence_with_count">
|
||||
@@ -521,7 +521,7 @@
|
||||
<string name="add_account_server_title">أين مهامك؟</string>
|
||||
<string name="add_account_working_reading_lists">جاري قراءة قوائم المهام خاصّتك</string>
|
||||
<string name="add_account_browser_title">جاري الانتظار لمتصفحك</string>
|
||||
<string name="add_account_browser_use_password">استخدم كلمة مرور بدلاً من ذلك</string>
|
||||
<string name="add_account_browser_use_password">استخدم كلمة مرور بدلاً</string>
|
||||
<string name="add_account_browser_open">فتح صفحة تسجيل الدخول</string>
|
||||
<string name="add_account_lists_title">أيّ القوائم يجب المزامنة؟</string>
|
||||
<string name="add_account_provider_unsupported">لا دعم للمهام عبر CalDAV</string>
|
||||
@@ -569,7 +569,7 @@
|
||||
<string name="add_account_browser_error_expired">تم إغلاق نافذة الموافقة قبل أن يرد الخادم.</string>
|
||||
<string name="add_account_browser_error_rate_limited">يرفض الخادم المحاولات المتكررة. انتظر بضع دقائق وحاول مرة أخرى.</string>
|
||||
<string name="add_account_browser_error_maintenance">الخادم في وضع الصيانة. حاول مرة أخرى بمجرد عودته.</string>
|
||||
<string name="add_account_browser_error_unavailable">لا يحتوي هذا الجهاز على متصفح يمكنه فتح صفحة تسجيل الدخول. استخدم كلمة مرور بدلاً من ذلك.</string>
|
||||
<string name="add_account_browser_error_unavailable">لا يحتوي هذا الجهاز على متصفح يمكنه فتح صفحة تسجيل الدخول. استخدم كلمة مرور بدلاً.</string>
|
||||
<string name="add_account_quirk_hint_fastmail">يحتاج Fastmail كلمة مرور تطبيق، ليس كلمة مرور حسابك — وCalDAV ليس على الخطة الأساسية.</string>
|
||||
<string name="add_account_quirk_hint_icloud">يحتاج iCloud كلمة مرور خاصة بتطبيق، التي يمكنك إنشاؤها في appleid.apple.com مع تفعيل المصادقة الثنائية.</string>
|
||||
<string name="add_account_setup_body">ستقوم بذلك في متصفحك، ثم العودة هنا لإكمال.</string>
|
||||
@@ -580,7 +580,7 @@
|
||||
<string name="add_account_browser_body">وافق على Agendula في المتصفح، ثم ارجع هنا. لا يتم إرسال كلمة مرورك مطلقًا إلى هذا التطبيق — يصدر الخادم كلمة مرور تطبيق منفصلة يمكنك إلغاؤها في أي وقت.</string>
|
||||
<string name="add_account_browser_insecure">صفحة تسجيل الدخول هذه غير مشفرة (http). أي شيء تكتبه هناك، بما في ذلك كلمة مرور حسابك، ينتقل بشكل غير مشفر.</string>
|
||||
<string name="add_account_browser_host_mismatch">الخادم أرسلنا إلى %1$s، لكنك كتبت %2$s. يعني ذلك عادةً أن إعداد overwrite.cli.url خاصّته غير صحيح.</string>
|
||||
<string name="add_account_origin_mismatch">أبلغ الخادم عن عنوانه كـ %1$s، الذي لا يستطيع هذا الجهاز الوصول، لذلك تم استخدام %2$s بدلاً من ذلك. من المحتمل أن يكون إعداد overwrite.cli.url أو trusted_proxies خاصّته غير صحيح.</string>
|
||||
<string name="add_account_origin_mismatch">أبلغ الخادم عن عنوانه كـ %1$s، الذي لا يستطيع هذا الجهاز الوصول، لذلك تم استخدام %2$s بدلاً. من المحتمل أن يكون إعداد overwrite.cli.url أو trusted_proxies خاصّته غير صحيح.</string>
|
||||
<string name="settings_licences_subtitle">المشاريع التي بنيت Agendula عليها</string>
|
||||
<string name="licences_intro">يتضمن Agendula العمل أدناه. اضغط على أي إدخال للحصول على شفرة المصدر الخاصة به.</string>
|
||||
<string name="licences_footer">يتم تضمين بعض من هذا الكود في شكل معدل. أين يكون هذا هو الحال، يتم إدراج كل تغيير في مستودع المصدر المرتبط أعلاه.</string>
|
||||
@@ -661,197 +661,4 @@
|
||||
<string name="list_save_failed_server">الخادم لن يقبل هذا التغيير.</string>
|
||||
<string name="list_delete_confirm_message">سيتم حذف ”%1$s“ وجميع مهامه. هذا لا يمكن التراجع عنه.</string>
|
||||
<string name="lists_empty_action">إنشاء قائمة</string>
|
||||
<string name="settings_dynamic_color_unavailable">متوفر على أندوريد ١٢ و أحدث</string>
|
||||
<string name="settings_reminders_subtitle">التذكيرات و التسليم</string>
|
||||
<string name="settings_form_fields_hint">الخانات المعروضة افتراضيًا على مهمة جديدة. الباقية تقع ضمن \"المزيد من الخانات\".</string>
|
||||
<string name="settings_dynamic_color_hint">استخدام الألوان من خلفيتك</string>
|
||||
<string name="settings_export_hint">حفظ قوائمك كملفات iCalendar</string>
|
||||
<string name="settings_import_hint">إحضار المهام من ملف iCalendar</string>
|
||||
<string name="settings_autofocus_title">تركيز العنوان على مهمة جديدة</string>
|
||||
<string name="settings_autofocus_title_hint">عند بدء مهمة جديدة، ضع المؤشر في حقل العنوان وافتح لوحة المفاتيح على الفور.</string>
|
||||
<string name="settings_storage_subtitle">أين مهامك تُبقى</string>
|
||||
<string name="settings_allday_reminder_time">وقت تذكير اليوم الكامل</string>
|
||||
<string name="settings_reliable_delivery_hint">أندرويد قد يؤخر التذكيرات لتوفير البطارية. استثنِ Agendula لكي تصل في الوقت المحدد.</string>
|
||||
<string name="settings_reliable_delivery_exempt">معفى من تحسين البطارية — تصل التذكيرات في الوقت المحدّد.</string>
|
||||
<string name="settings_translate_hint">إضافة أو تحسين لغة على Weblate</string>
|
||||
<string name="settings_reminders_hint">أعلمني عندما تكون مهمة مستحقة</string>
|
||||
<string name="settings_exact_alarms_allowed">تنطلق التذكيرات في الوقت المحدّد</string>
|
||||
<string name="settings_notifications_blocked_hint">التذكيرات لا يمكنها الوصول لك. اضغط للسماح بإشعارات لـ Agendula.</string>
|
||||
<string name="settings_exact_alarms_blocked">محظور — اضغط للسماح بالتذكيرات الدقيقة</string>
|
||||
<string name="settings_default_list_first">أول قائمة متاحة</string>
|
||||
<string name="settings_add_subtask_row">إظهار صف \"أضف مهمة فرعية\"</string>
|
||||
<string name="settings_add_subtask_row_hint">خانة إضافة في نهاية المهام الفرعية للمهمة الموسعة</string>
|
||||
<string name="settings_default_start_today">البداية الافتراضية إلى اليوم</string>
|
||||
<string name="settings_default_start_today_hint">ملأ مسبق بداية مهمة جديدة بتاريخ اليوم</string>
|
||||
<string name="settings_bottom_add_bar_hint">إضافة مهام من شريط مثبت إلى أسفل لقائمة، بدلاً من الزر العائم</string>
|
||||
<string name="settings_task_store_hint">كل مخزن يحتفظ بمهامه الخاصة. التبديل لا يؤدي لنقلهم — انسخهم أولاً، أو صدِّرهم من النسخ الاحتياطي والاستعادة.</string>
|
||||
<string name="settings_store_own_hint">التخزين خاصّة Agendula. لا شيء آخر للتثبيت.</string>
|
||||
<string name="settings_store_external_hint">مشاركة المهام مع التطبيق الذي يزامنهم</string>
|
||||
<string name="settings_store_external_missing">لا تطبيق مهام متوافق مثبّت</string>
|
||||
<string name="accounts_remove_wipe">إزالة و حذف المهام</string>
|
||||
<string name="list_delete_confirm_message_synced">”%1$s“ وجميع مهامه ستتم حذفها من الخادم، من كل جهاز آخر سُجِّل دخوله لهذا الحساب. هذا لا يمكن التراجع عنه.</string>
|
||||
<plurals name="home_today_progress_count">
|
||||
<item quantity="zero">تم %1$d من %2$d</item>
|
||||
<item quantity="one">تم %1$d من %2$d</item>
|
||||
<item quantity="two">تم %1$d من %2$d</item>
|
||||
<item quantity="few">تم %1$d من %2$d</item>
|
||||
<item quantity="many">تم %1$d من %2$d</item>
|
||||
<item quantity="other">تم %1$d من %2$d</item>
|
||||
</plurals>
|
||||
<plurals name="home_today_remaining_count">
|
||||
<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="list_where_device">على هذا الجهاز فقط</string>
|
||||
<string name="list_read_only">تتم مشاركة هذه القائمة معك للقراءة فقط، لذلك فإن اسمها ولونها للمالك للتغيير.</string>
|
||||
<string name="onboarding_no_provider_title">مُحتاج تطبيق مهام</string>
|
||||
<string name="onboarding_permission_title">السماح بالوصول إلى مهامك</string>
|
||||
<string name="onboarding_permission_body">Agendula يحتاج إذن لقراءة و كتابة مهامك. هذا هو الشيء الوحيد الذي يطلب له دائمًا.</string>
|
||||
<string name="onboarding_permission_button">منح الوصول إلى المهام</string>
|
||||
<string name="onboarding_welcome_sync_body">المزامنة عبر CalDAV مع الخادم أنت تختاره، أو الاحتفاظ بكل شيء على هذا الجهاز.</string>
|
||||
<string name="onboarding_welcome_offline_title">لا إنترنت، بالتصميم</string>
|
||||
<string name="onboarding_welcome_offline_body">هذا الإصدار من Agendula ليس لديه الوصول إلى الشبكة، لذلك فإنه لا يمكنه المزامنة أو الاتصال لأي شيء نفسه.</string>
|
||||
<string name="onboarding_sync_title">مزامنة مع خادمك الخاص؟</string>
|
||||
<string name="onboarding_sync_body">Agendula يدعم CalDAV — Nextcloud, Radicale, Posteo, Fastmail و أي شيء آخر يدعمه. لا حساب من خاصّتنا، أبدًا.</string>
|
||||
<plurals name="widget_today_progress_cd">
|
||||
<item quantity="zero">تم %1$d من %2$d</item>
|
||||
<item quantity="one">تم %1$d من %2$d</item>
|
||||
<item quantity="two">تم %1$d من %2$d</item>
|
||||
<item quantity="few">تم %1$d من %2$d</item>
|
||||
<item quantity="many">تم %1$d من %2$d</item>
|
||||
<item quantity="other">تم %1$d من %2$d</item>
|
||||
</plurals>
|
||||
<plurals name="sync_notice_more">
|
||||
<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="onboarding_no_provider_body">أنت اخترت للاحتفاظ بالمهام في تطبيق آخر، لكن لا واحد متوافق مثبّت. قم بتثبيت OpenTasks أو tasks.org، أو قم بالتبديل عودتًا إلى التخزين خاصّة Agendula.</string>
|
||||
<string name="onboarding_sync_connect">ربط حساب</string>
|
||||
<string name="onboarding_sync_devices_title">كل جهاز في وقت واحد</string>
|
||||
<string name="onboarding_sync_devices_body">ضع علامة صح لشيء ما هنا و سيتم وضع العلامة عليه في كل مكان.</string>
|
||||
<string name="onboarding_sync_copy_title">نسخة تبقَى بعد الهاتف</string>
|
||||
<string name="onboarding_sync_copy_body">تعيش مهامك على الخادم أيضًا، لذلك جهاز مفقود لا يعني فقدان العمل.</string>
|
||||
<string name="onboarding_sync_yours_title">لك الاختيار</string>
|
||||
<string name="onboarding_sync_yours_body">مستضاف ذاتيًا (Self-hosted) أو مزود أنت تدفع له بالفعل — Agendula فقط يخزن كلمة المرور.</string>
|
||||
<string name="onboarding_list_title">قائمتك الأولى</string>
|
||||
<string name="onboarding_list_body">تحافظ القوائم على فصل الأشياء. ابدأ بواحدة — يمكنك إضافة المزيد، وإعادة تسمية هذه القائمة، أيًّا كان الوقت.</string>
|
||||
<string name="onboarding_backup_title">احتفظ بنسخة</string>
|
||||
<string name="settings_section_backup">النسخ الاحتياطي والاستعادة</string>
|
||||
<string name="onboarding_backup_body_later">دون حساب، قوائمك تعيش فقط على هذا الجهاز. احفظهم كملفات iCalendar أي تطبيق مهام أو تقويم آخر يمكنه قراءتها، أيّا كان الوقت من الإعدادات ← النسخ الاحتياطي والاستعادة ← تصدير.</string>
|
||||
<string name="onboarding_quick_add_title">كيف ترغب في إضافة المهام؟</string>
|
||||
<string name="onboarding_quick_add_bar">شريط الإضافة السريع</string>
|
||||
<string name="onboarding_quick_add_bar_hint">خانة في أسفل كل قائمة: اكتب، اضغط إدخال، إلى التالي.</string>
|
||||
<string name="onboarding_quick_add_button">زر مهمة جديدة</string>
|
||||
<string name="onboarding_quick_add_button_hint">زر عائم يفتح النموذج الكامل.</string>
|
||||
<string name="onboarding_exact_alarms_title">صحيح على الوقت</string>
|
||||
<string name="onboarding_exact_alarms_body">أندوريد يسأل قبل أن يتمكن تطبيق من إعلامك في دقيقة محددة. اسمح به والتذكيرات تصل في موعد الاستحقاق خاصّتهم — بدونه قد يتأخروا بضع دقائق.</string>
|
||||
<string name="onboarding_exact_alarms_allow">السماح بالتوقيت الدقيق</string>
|
||||
<string name="onboarding_use_own_store">استخدم تخزين هذا الجهاز بدلاً من ذلك</string>
|
||||
<string name="widget_config_theme_follow_app">اتبع التطبيق</string>
|
||||
<string name="widget_config_theme_light">فاتح</string>
|
||||
<string name="widget_config_theme_dark">داكن</string>
|
||||
<string name="widget_config_row_color">ألوان خام</string>
|
||||
<string name="widget_config_row_color_neutral">محايد</string>
|
||||
<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>
|
||||
Loaded 100 of 165 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user