Start new installs with Lumi, Habits and Practice and sync apps and pins

A new profile now comes with Lumi, Habits and Practice installed and
pinned in that order on every device; Lists, Diary and Leaderboard wait
in More apps. Existing profiles keep their apps.

A choice nobody made, such as a new profile's apps, is stored at time 1
and never uploaded, so a newly signed-in device takes the account's apps
instead of removing them. The owner's install and remove choices keep
syncing per app in private.inbe.v1.app-preferences.

The pinned apps and their order sync as one record, app_order, in a new
collection private.inbe.v1.app-order that older versions skip. It is sent
only when the owner pins, moves or unpins an app; the newest order wins,
a pending local order wins a tie, and a record this version can't read
changes nothing without stopping the sync. An arriving order sets
app_order_received and the pins take it once, also after a restart. An
app removed on another device is unpinned here too.

Tests: storage sync round trips for app choices and order (defaults
never sent, stale and same-time records, unreadable records), the order
SQL, restore SQL, launcher policy encoding, and updated onboarding,
launcher, startup and Leaderboard UI expectations for the new defaults.
The Data screenshot scene installs Lists, which it opens from. The
Telegram flow fake gains HttpTransferPollLength, which sync_async has
called since c4babc97.
This commit is contained in:
waozi committed 2026-10-17 03:15:51 -03:00
1 parent 9046a06ac2
commit ca10b83379
27 files changed
+587 -75

No files matched your search

+1
View File
@@ -23,6 +23,7 @@
- Every practice is optional: Practice shows only installed ones. Wim Hof comes installed and can be removed; Meditation and Breathing Patterns come with the app and are added without a download.
- Manage practices lists every practice with its size and one button: Install, Buy for a paid practice, Cancel while it downloads, or Uninstall once it is on Practice. Uninstalling a downloaded practice asks once, then frees the space; one that comes with the app just leaves Practice. Drag a practice by its handle onto another to change the order Practice shows them in. Your progress stays either way.
- Lumi asks to download or unlock a practice before starting one that isn't on your device.
- A new install comes with Lumi, Habits and Practice, in that order; add Lists, Diary and Leaderboard from More apps. The apps you install or remove and the order of your pinned apps follow your account to your other devices, and a newly signed-in device takes your account's apps instead of replacing them.
### Removed
- Donations: the reminder, About's Donate button and Lumi's donation links. Dew is how you pay in Inner Breeze.
### Fixed
+19 -2
View File
@@ -381,12 +381,29 @@ configuration above; a checked build does not establish that configuration.
## Account app choices
A new profile comes with Lumi, Habits and Practice installed and pinned, in
that order; Lists, Diary and Leaderboard are added from More apps. Existing
profiles keep their apps.
Sync v6 uses `private.inbe.v1.app-preferences`. Each of the six `app_used_*`
keys is a separate timestamped record, including explicit zero values for
removals. Independent changes merge without overwriting unrelated selections.
Pending local choices win equal timestamps; newer remote choices win.
Invalid keys, values and timestamps cannot alter preferences. Versions, package
paths, release sequence floors and the automatic-update preference stay local.
Invalid keys, values and timestamps cannot alter preferences. Released
versions reject an unknown key in this collection and stop syncing, so a new
app's choice needs its own collection. A choice nobody made, such as a new
profile's apps, is stored at time 1 (`AppDefaultTime`) and never uploaded, so
a new device takes the account's apps instead of replacing them.
The pinned apps and their order are one record, `app_order`, in
`private.inbe.v1.app-order`: package names separated by commas, such as
`lumi,habits,practices`, at most 255 bytes. It is sent only when the owner
pins, moves or unpins an app. The newest order wins and a pending local order
wins a tie; versions that don't know the collection skip it, and a record this
version can't read changes nothing without stopping the sync. An arriving
order sets `app_order_received`, and the pins take it once. An app removed on
another device is unpinned here too. Versions, package paths, release
sequence floors and the automatic-update preference stay local.
All apps share the existing account, SQLite database and outbox. Diary entries
and photos use the owner-only encrypted cell collection on that same sync
account. Per-account files provide a local cache; they are not the only copy.
+2 -2
View File
@@ -384,7 +384,7 @@ app_draw_launcher :: (app: *InnerBreeze) {
app.launcher_favorite_count = LauncherPlaceFavorite(
app.launcher_favorites[:], app.launcher_favorite_count,
app.launcher_drag_route, target)
save_settings(app)
app_launcher_pins_changed(app)
}
} else if query.count == 0 && scrolled.opened &&
PointInBounds(point.x, point.y, scrolled.viewport) &&
@@ -393,7 +393,7 @@ app_draw_launcher :: (app: *InnerBreeze) {
app.launcher_favorite_count = LauncherToggleFavorite(
app.launcher_favorites[:], app.launcher_favorite_count,
app.launcher_drag_route)
save_settings(app)
app_launcher_pins_changed(app)
}
app.launcher_drag_key = 0
app.launcher_drag_moving = false
+14 -2
View File
@@ -20,20 +20,32 @@ app_launcher_is_favorite :: (app: *InnerBreeze, route: s32) -> bool {
app.launcher_favorite_count, route)
}
// The owner pinned, moved or unpinned an app. The pins and their order go
// to the account's other devices with the next sync.
app_launcher_pins_changed :: (app: *InnerBreeze) {
app_save_app_order(app)
save_settings(app)
}
app_launcher_uninstall :: (app: *InnerBreeze, route: s32) {
bit := app_nav_route_bit(route)
if bit == 0 { return }
mask := app.enabled_apps & ~bit
if !CellsSetEnabled(mask) { return }
app.enabled_apps = mask
if app_launcher_is_favorite(app, route) {
pinned := app_launcher_is_favorite(app, route)
if pinned {
app.launcher_favorite_count = LauncherToggleFavorite(
app.launcher_favorites[:], app.launcher_favorite_count, route)
}
app.launcher_drag_key = 0
app.launcher_drag_moving = false
app_update_app_navigation(app)
save_settings(app)
if pinned {
app_launcher_pins_changed(app)
} else {
save_settings(app)
}
app_block_current_click(app)
}
+24
View File
@@ -16,6 +16,7 @@
#import, file "../platform/environment.zi";
#import, file "route_list.zi";
#import, file "bottom_nav_policy.zi";
#import, file "launcher_policy.zi";
#import, file "app_route_state.zi";
#import, file "locale.zi";
#import, file "text_buffers.zi";
@@ -67,6 +68,7 @@ app_nav_route_available :: (app: *InnerBreeze, route: s32) -> bool {
c :: #system_library "c";
app_leave_practice_config :: (app: *InnerBreeze) #foreign c;
save_settings :: (app: *InnerBreeze) #foreign c;
app_take_app_order :: (app: *InnerBreeze, order: string) -> bool #foreign c;
sync_account_load :: (account: *AccountKeys) -> s32 #foreign c;
storage_get_setting_text :: (key: string) -> string #foreign c;
@@ -797,6 +799,7 @@ app_update_app_navigation :: (app: *InnerBreeze, add_cells: s32 = 0) {
app_sanitize_bottom_nav_routes(app)
}
// After a sync, the apps and pins the account's other devices changed.
#program_export
app_reload_app_choices :: (app: *InnerBreeze) {
previous_mask := app.enabled_apps
@@ -810,7 +813,27 @@ app_reload_app_choices :: (app: *InnerBreeze) {
mask &= ~bit
}
}
pins_changed := false
if SettingsReadInt(AppOrderReceivedKey, 0) != 0 {
pins_changed = app_take_app_order(app, storage_get_setting_text(AppOrderKey))
}
// An app removed on another device is unpinned here too, as when it
// is removed on this one.
removed := previous_mask & ~mask
routes := LauncherRoutes()
for index: cast(s32)0..cast(s32)routes.count - 1 {
route := routes[index]
if (app_nav_route_bit(route) & removed) != 0 &&
RouteListContains(app.launcher_favorites[:], app.launcher_favorite_count, route) {
app.launcher_favorite_count = LauncherToggleFavorite(
app.launcher_favorites[:], app.launcher_favorite_count, route)
pins_changed = true
}
}
if mask == app.enabled_apps {
if pins_changed {
save_settings(app)
}
return
}
app.enabled_apps = mask
@@ -826,4 +849,5 @@ app_reload_app_choices :: (app: *InnerBreeze) {
app.breathing.screen = ScreenAppSelection
}
}
save_settings(app)
}
+74 -17
View File
@@ -75,10 +75,11 @@ load_bottom_nav_routes :: (app: *InnerBreeze) {
if app == null {
return
}
// A new profile's apps, Lumi, Habits and Practice, in their order.
app.bottom_nav_route_count =
SettingsCacheInt("bottom_nav_route_count", 4)
app.bottom_nav_routes[0] =
SettingsCacheInt("bottom_nav_route_0", APP_NAV_ROUTE_ELIST)
SettingsCacheInt("bottom_nav_route_0", APP_NAV_ROUTE_LUMI)
app.bottom_nav_routes[1] =
SettingsCacheInt("bottom_nav_route_1", APP_NAV_ROUTE_HABITS)
app.bottom_nav_routes[2] =
@@ -112,10 +113,60 @@ load_bottom_nav_routes :: (app: *InnerBreeze) {
app.launcher_favorites[:], app.launcher_favorite_count, route)
}
} else {
app.launcher_favorite_count = LauncherDefaults(app.launcher_favorites[:],
DesktopPlatform() != 0)
app.launcher_favorite_count = LauncherDefaults(app.launcher_favorites[:])
}
}
// Pins another device of the account changed arrived before this device
// took them, for example when it closed during a practice.
if SettingsCacheInt(AppOrderReceivedKey, 0) != 0 {
order: [LAUNCHER_ORDER_TEXT_MAX + 1]u8
unused SettingsCacheCopyText(AppOrderKey, order[:])
unused app_take_app_order(app, AppTextFromCString(*order[0], LAUNCHER_ORDER_TEXT_MAX + 1))
}
}
// The pinned apps another device of the account sent replace this device's
// pins, once: a later change here stays here until the owner changes pins.
#program_export
app_take_app_order :: (app: *InnerBreeze, order: string) -> bool {
routes: [LAUNCHER_APP_COUNT]s32
count := LauncherOrderRoutes(order, routes[:])
changed := count != app.launcher_favorite_count
for index: cast(s32)0..count - 1 {
if routes[index] != app.launcher_favorites[index] {
changed = true
}
}
for index: cast(s32)0..count - 1 {
app.launcher_favorites[index] = routes[index]
}
app.launcher_favorite_count = count
if changed {
save_launcher_favorites(app)
}
unused SettingsStoreInt(AppOrderReceivedKey, 0)
return changed
}
// The owner changed the pins: their order goes to the account's other
// devices. A default or an order from another device is never sent back.
app_save_app_order :: (app: *InnerBreeze) {
if app == null || TelegramHostPresent() {
return
}
order: [LAUNCHER_ORDER_TEXT_MAX + 1]u8
unused LauncherOrderText(app.launcher_favorites[:], app.launcher_favorite_count, order[:])
unused SettingsStoreText(AppOrderKey, order[:])
}
save_launcher_favorites :: (app: *InnerBreeze) {
save_setting_int("launcher_favorite_count", app.launcher_favorite_count)
save_setting_int("launcher_favorite_0", app.launcher_favorites[0])
save_setting_int("launcher_favorite_1", app.launcher_favorites[1])
for index: cast(s32)2..cast(s32)app.launcher_favorites.count - 1 {
key := SettingsKeyIndexed("launcher_favorite_", index, "")
unused SettingsStoreInt(AppTextFromCString(*key.bytes[0], 48), app.launcher_favorites[index])
}
}
default_theme_source :: () -> s32 {
@@ -209,13 +260,7 @@ save_settings :: (app: *InnerBreeze) {
save_setting_int("navigation_mode", app.navigation_mode)
save_setting_int("navigation_placement", app.navigation_placement)
save_setting_int("navigation_collapsed", app.nav_rail_collapsed)
save_setting_int("launcher_favorite_count", app.launcher_favorite_count)
save_setting_int("launcher_favorite_0", app.launcher_favorites[0])
save_setting_int("launcher_favorite_1", app.launcher_favorites[1])
for index: cast(s32)2..cast(s32)app.launcher_favorites.count - 1 {
key := SettingsKeyIndexed("launcher_favorite_", index, "")
unused SettingsStoreInt(AppTextFromCString(*key.bytes[0], 48), app.launcher_favorites[index])
}
save_launcher_favorites(app)
save_setting_int("profile_picture_icon", app.profile_picture_icon)
save_setting_int("bottom_nav_route_count", app.bottom_nav_route_count)
save_setting_int("bottom_nav_route_0", app.bottom_nav_routes[0])
@@ -754,10 +799,10 @@ app_load_settings :: (app: *InnerBreeze) -> s32 {
app.exercise_manual_seen_mask =
manual_seen_mask & ((1 << EXERCISE_COUNT) - 1)
load_language_setting(app, settings_missing)
// Existing profiles retain their app choices. Fresh profiles open the Apps
// library with every bundled app available, without an install chooser.
// Existing profiles retain their app choices. A new profile comes with
// Lumi, Habits and Practice; the other apps are added from More apps.
app.enabled_apps = SettingsCacheInt("enabled_apps",
ifx settings_missing != 0 then APP_ALL else APP_LISTS | APP_RECOMMENDED) & APP_ALL
ifx settings_missing != 0 then APP_RECOMMENDED else APP_LISTS | APP_RECOMMENDED) & APP_ALL
for index: cast(s32)1..cast(s32)(PackageCount - 1) {
key := PackagePreferenceKey(index)
if SettingsCacheContains(key) {
@@ -772,17 +817,18 @@ app_load_settings :: (app: *InnerBreeze) -> s32 {
}
// Ordinary profiles migrate their saved app choices. A hosted delegate
// reads those choices without creating owner preference outbox rows.
// A new profile already has Lumi among its default apps.
if !TelegramHostPresent() && !SettingsCacheContains("lumi_introduced") {
if !SettingsCacheContains("app_used_lumi") {
if settings_missing == 0 && !SettingsCacheContains("app_used_lumi") {
app.enabled_apps |= APP_LUMI
save_setting_int("app_used_lumi", 1)
}
save_setting_int("enabled_apps", app.enabled_apps)
save_setting_int("lumi_introduced", 1)
}
// Leaderboard moved from Profile into its own app. Fresh profiles start
// with every app; existing ones get it installed once. Removing it later
// is respected.
// Leaderboard moved from Profile into its own app. Existing profiles get
// it installed once, and removing it later is respected. New profiles
// add it from More apps.
if !TelegramHostPresent() && !SettingsCacheContains("leaderboard_introduced") {
if settings_missing == 0 && !SettingsCacheContains("app_used_leaderboard") {
app.enabled_apps |= APP_LEADERBOARD
@@ -791,6 +837,17 @@ app_load_settings :: (app: *InnerBreeze) -> s32 {
}
save_setting_int("leaderboard_introduced", 1)
}
// Apps nobody chose, such as a new profile's, are stored as defaults: a
// choice from the account's other devices replaces them, and they are
// never sent, so a new device cannot remove the account's apps.
if !TelegramHostPresent() {
for index: cast(s32)1..cast(s32)(PackageCount - 1) {
key := PackagePreferenceKey(index)
if !SettingsCacheContains(key) {
unused SettingsStoreDefaultBool(key, (app.enabled_apps & PackageBit(index)) != 0)
}
}
}
app.apps_selected = SettingsCacheInt("apps_setup_done",
ifx settings_missing != 0 then 0 else 1)
+5 -5
View File
@@ -5,16 +5,16 @@ using AppNavRoute;
BOTTOM_NAV_MAX_ROUTES :: 7
// The apps a new profile comes with, in their order, then Settings.
BottomNavDefaults :: (routes: []s32) -> s32 {
if routes.count < 5 {
return 0
}
routes[0] = APP_NAV_ROUTE_LUMI
routes[1] = APP_NAV_ROUTE_ELIST
routes[2] = APP_NAV_ROUTE_HABITS
routes[3] = APP_NAV_ROUTE_PRACTICE
routes[4] = APP_NAV_ROUTE_SETTINGS
return 5
routes[1] = APP_NAV_ROUTE_HABITS
routes[2] = APP_NAV_ROUTE_PRACTICE
routes[3] = APP_NAV_ROUTE_SETTINGS
return 4
}
BottomNavSanitize :: (routes: []s32, count: s32,
+74 -6
View File
@@ -14,12 +14,12 @@ LauncherRoutes :: () -> [LAUNCHER_APP_COUNT]s32 {
APP_NAV_ROUTE_LEADERBOARD}
}
// Leaderboard is installed with the other apps but is not pinned.
LauncherDefaults :: (routes: []s32, desktop: bool) -> s32 {
defaults: [5]s32 = .{APP_NAV_ROUTE_LUMI,
APP_NAV_ROUTE_HABITS, APP_NAV_ROUTE_PRACTICE,
APP_NAV_ROUTE_ELIST, APP_NAV_ROUTE_DIARY}
count := cast(s32)(ifx desktop then 5 else 3)
// A new profile comes with Lumi, Habits and Practice installed and pinned,
// in this order. Every other app is added from More apps.
LauncherDefaults :: (routes: []s32) -> s32 {
defaults: [3]s32 = .{APP_NAV_ROUTE_LUMI,
APP_NAV_ROUTE_HABITS, APP_NAV_ROUTE_PRACTICE}
count := cast(s32)defaults.count
if routes.count < count { return 0 }
for index: cast(s32)0..count - 1 {
routes[index] = defaults[index]
@@ -27,6 +27,74 @@ LauncherDefaults :: (routes: []s32, desktop: bool) -> s32 {
return count
}
// The pinned order syncs between an account's devices as package names, the
// names in src/cells/catalog.zi, so it means the same apps on every version.
LAUNCHER_ORDER_TEXT_MAX :: 255
LauncherRouteName :: (route: s32) -> string {
if route == APP_NAV_ROUTE_DIARY { return "diary" }
if route == APP_NAV_ROUTE_HABITS { return "habits" }
if route == APP_NAV_ROUTE_ELIST { return "lists" }
if route == APP_NAV_ROUTE_LUMI { return "lumi" }
if route == APP_NAV_ROUTE_PRACTICE { return "practices" }
if route == APP_NAV_ROUTE_LEADERBOARD { return "leaderboard" }
return ""
}
LauncherRouteForName :: (name: string) -> s32 {
if name.count == 0 { return APP_NAV_ROUTE_NONE }
routes := LauncherRoutes()
for index: cast(s32)0..cast(s32)routes.count - 1 {
if LauncherRouteName(routes[index]) == name { return routes[index] }
}
return APP_NAV_ROUTE_NONE
}
// Writes the pinned apps as names separated by commas and returns the
// length. The output always ends with a zero byte.
LauncherOrderText :: (routes: []s32, count: s32, output: []u8) -> s32 {
if output.count == 0 { return 0 }
length: s32 = 0
limit := count
if limit > cast(s32)routes.count { limit = cast(s32)routes.count }
for index: cast(s32)0..limit - 1 {
name := LauncherRouteName(routes[index])
if name.count == 0 { continue }
needed := cast(s32)name.count
if length > 0 { needed += 1 }
if length + needed >= cast(s32)output.count { break }
if length > 0 {
output[length] = cast(u8)44
length += 1
}
for byte: name {
output[length] = byte
length += 1
}
}
output[length] = cast(u8)0
return length
}
// Reads an order written by any version. Apps this version doesn't have
// are left out, and the others keep their order.
LauncherOrderRoutes :: (text: string, routes: []s32) -> s32 {
count: s32 = 0
start: s64 = 0
while start <= text.count {
end := start
while end < text.count && text[end] != cast(u8)44 { end += 1 }
route := LauncherRouteForName(text[start:end])
if route != APP_NAV_ROUTE_NONE && count < cast(s32)routes.count &&
!RouteListContains(routes, count, route) {
routes[count] = route
count += 1
}
start = end + 1
}
return count
}
LauncherSanitizeFavorites :: (routes: []s32, count: s32) -> s32 {
allowed := LauncherRoutes()
return RouteListSanitize(routes, count, allowed[:])
+3
View File
@@ -916,6 +916,9 @@ setup_screenshot_scene :: (app: *InnerBreeze, request: *ScreenshotRequest) {
app.close_prompt_open = 1
app.close_prompt_result = cast(AppClosePromptResult)AppClosePromptNone
} else if scene_text == "data_from_navigation" {
// Data opens from Lists, which a new profile adds from More apps.
app.enabled_apps |= APP_LISTS
unused CellsSetEnabled(app.enabled_apps)
app.main_tab = APP_MAIN_TAB_ELIST
app.breathing.screen = ScreenEList
app_apply_nav_route(app, APP_NAV_ROUTE_DATA)
+16
View File
@@ -8,6 +8,7 @@ c :: #system_library "c";
storage_set_setting_int :: (key: string, value: s32) #foreign c;
storage_set_setting_text :: (key: string, value: string) #foreign c;
storage_set_setting_default_text :: (key: string, value: string) #foreign c;
storage_get_setting_int :: (key: string, fallback: s32) -> s32 #foreign c;
storage_list_settings :: (callback: SettingVisitor, user: *void) -> s32 #foreign c;
storage_settings_empty :: () -> s32 #foreign c;
@@ -95,6 +96,21 @@ SettingsStoreInt :: (key: string, value: s32) -> bool {
return SettingsStoreKeyInt(SettingsKeyText(key), value)
}
// A default the owner didn't choose. It never replaces a saved value, and
// a synced choice from the account replaces it.
SettingsStoreDefaultBool :: (key: string, value: bool) -> bool {
setting_key := SettingsKeyText(key)
if !SettingsKeyValid(setting_key) {
return false
}
if DataTemporary() {
return true
}
storage_set_setting_default_text(AppTextFromCString(*setting_key.bytes[0], setting_key.count + 1),
ifx value then "1" else "0")
return true
}
SettingsStoreText :: (key: string, value: []u8) -> bool {
return SettingsStoreKeyText(SettingsKeyText(key), value)
}
+2 -2
View File
@@ -763,8 +763,8 @@ using AppThemeSource;
if app == null {
return
}
// First-start Apps now includes every bundled application. Keep that
// same package set while the browser checks navigation during playback.
// The browser checks navigation through every bundled application
// during playback, so they are all installed for it.
if CellsSetEnabled(APP_ALL) {
app.enabled_apps = APP_ALL
app.apps_selected = 1
+10
View File
@@ -35,6 +35,16 @@ PackagePreferenceKey :: (index: s32) -> string {
return keys[index]
}
// The pinned apps' order syncs as one record of package names, in its own
// collection: a version that doesn't know it skips it.
AppOrderKey :: "app_order"
AppOrderCollection :: "private.inbe.v1.app-order"
// Set when another device's order arrives, until the pins take it.
AppOrderReceivedKey :: "app_order_received"
// A default is stored at this time, older than any choice, so a choice from
// the account replaces it. Defaults are never uploaded.
AppDefaultTime :: 1
AppPreferenceValid :: (key: string) -> bool {
return key == "app_used_lists" || key == "app_used_habits" ||
key == "app_used_practices" || key == "app_used_diary" || key == "app_used_lumi" ||
+65 -2
View File
@@ -395,7 +395,10 @@ storage_enqueue_all_sync_state :: () {
exec_sql("INSERT INTO sync_outbox(entity_type,entity_id,local_date,queued_at) SELECT 'elist_item',id,0,strftime('%s','now') FROM elist_items WHERE user_id=(SELECT id FROM users LIMIT 1) ON CONFLICT(entity_type,entity_id,local_date) DO UPDATE SET queued_at=excluded.queued_at")
exec_sql("INSERT INTO sync_outbox(entity_type,entity_id,local_date,queued_at) SELECT 'habit_entry',id,0,strftime('%s','now') FROM habit_entries WHERE user_id=(SELECT id FROM users LIMIT 1) ON CONFLICT(entity_type,entity_id,local_date) DO UPDATE SET queued_at=excluded.queued_at")
exec_sql("INSERT INTO sync_outbox(entity_type,entity_id,local_date,queued_at) SELECT 'habit_change',id,0,strftime('%s','now') FROM habit_changes WHERE user_id=(SELECT id FROM users LIMIT 1) ON CONFLICT(entity_type,entity_id,local_date) DO UPDATE SET queued_at=excluded.queued_at")
exec_sql("INSERT INTO sync_outbox(entity_type,entity_id,local_date,queued_at) SELECT 'app_preference',key,0,updated_at FROM settings WHERE user_id=(SELECT id FROM users LIMIT 1) AND key IN ('app_used_lists','app_used_habits','app_used_practices','app_used_diary','app_used_lumi','app_used_leaderboard') ON CONFLICT(entity_type,entity_id,local_date) DO UPDATE SET queued_at=excluded.queued_at")
// A default app choice (stored at AppDefaultTime) is not a choice and
// never goes out, so a new device cannot replace the account's apps.
exec_sql("INSERT INTO sync_outbox(entity_type,entity_id,local_date,queued_at) SELECT 'app_preference',key,0,updated_at FROM settings WHERE user_id=(SELECT id FROM users LIMIT 1) AND key IN ('app_used_lists','app_used_habits','app_used_practices','app_used_diary','app_used_lumi','app_used_leaderboard') AND updated_at>1 ON CONFLICT(entity_type,entity_id,local_date) DO UPDATE SET queued_at=excluded.queued_at")
exec_sql("INSERT INTO sync_outbox(entity_type,entity_id,local_date,queued_at) SELECT 'app_order',key,0,updated_at FROM settings WHERE user_id=(SELECT id FROM users LIMIT 1) AND key='app_order' AND updated_at>1 ON CONFLICT(entity_type,entity_id,local_date) DO UPDATE SET queued_at=excluded.queued_at")
exec_sql("INSERT INTO sync_outbox(entity_type,entity_id,local_date,queued_at) SELECT 'cell_record',key,0,updated_at FROM settings WHERE user_id=(SELECT id FROM users LIMIT 1) AND (key LIKE 'cell.lumi.%' OR key LIKE 'cell.diary.%' OR key LIKE 'cell.feedback.%') ON CONFLICT(entity_type,entity_id,local_date) DO UPDATE SET queued_at=excluded.queued_at")
if owns_transaction != 0 {
exec_sql("COMMIT")
@@ -736,12 +739,41 @@ storage_set_setting_text :: (key: string, value: string) {
if AppPreferenceValid(key) {
unused storage_enqueue_sync_entity("app_preference", key, 0)
}
if key == AppOrderKey {
unused storage_enqueue_sync_entity("app_order", key, 0)
}
if storage_state_handle().settings_write_depth <= 0 {
storage_schedule_persist()
}
}
}
// Stores a default the owner didn't choose, such as a new profile's apps.
// It never replaces a saved value, is never uploaded, and is stored at
// AppDefaultTime, so a choice from the account's other devices replaces it.
#program_export
storage_set_setting_default_text :: (key: string, value: string) {
statement: *void = null
if storage_db_handle() == null || key.count == 0 {
return
}
if SqlitePrepareText(storage_db_handle(),
"INSERT INTO settings(user_id,key,value,updated_at) VALUES(?1,?2,?3,?4) ON CONFLICT(user_id,key) DO NOTHING",
-1, *statement, null) != SQLITE_OK {
return
}
bind_text(statement, 1, AppTextFromCString(storage_user_id_buffer(), 64))
bind_text(statement, 2, key)
bind_text(statement, 3, value)
SqliteBindInt64(statement, 4, AppDefaultTime)
rc := SqliteStep(statement)
SqliteFinalize(statement)
if rc == SQLITE_DONE && sqlite3_changes(storage_db_handle()) > 0 &&
storage_state_handle().settings_write_depth <= 0 {
storage_schedule_persist()
}
}
#program_export
storage_settings_begin_write :: () {
database := storage_db_handle()
@@ -1294,6 +1326,18 @@ storage_append_app_preference_payload_json :: (json: *StorageJsonBuilder, key: s
if !AppPreferenceValid(key) {
return 0
}
return storage_append_setting_record_json(json, key, 16)
}
storage_append_app_order_payload_json :: (json: *StorageJsonBuilder, key: string) -> s32 {
if key != AppOrderKey {
return 0
}
return storage_append_setting_record_json(json, key, 256)
}
// One setting as a synced record: its key, value and the time it changed.
storage_append_setting_record_json :: (json: *StorageJsonBuilder, key: string, value_capacity: s32) -> s32 {
statement: *void = null
if SqlitePrepareText(storage_db_handle(),
"SELECT value,updated_at FROM settings WHERE user_id=?1 AND key=?2", -1,
@@ -1311,7 +1355,7 @@ storage_append_app_preference_payload_json :: (json: *StorageJsonBuilder, key: s
storage_json_builder_append_text(json, "{")
storage_json_builder_key_value_text(json, "key", key)
storage_json_builder_append_text(json, ",")
storage_json_builder_key_value_text(json, "value", AppTextFromCString(SqliteColumnText(statement, 0), 16))
storage_json_builder_key_value_text(json, "value", AppTextFromCString(SqliteColumnText(statement, 0), value_capacity))
storage_json_builder_append_text(json, ",\"updated_at\":")
storage_json_builder_append_epoch(json, SqliteColumnInt64(statement, 1))
storage_json_builder_append_text(json, "}")
@@ -1342,6 +1386,8 @@ storage_append_sync_op_payload :: (json: *StorageJsonBuilder, entity_type: strin
found = storage_append_cell_payload_json(json, entity_id)
} else if entity_type == "app_preference" {
found = storage_append_app_preference_payload_json(json, entity_id)
} else if entity_type == "app_order" {
found = storage_append_app_order_payload_json(json, entity_id)
} else if storage_compare_text(entity_type, "habit") == 0 {
found = storage_append_habit_payload_json(json, entity_id)
@@ -1376,6 +1422,9 @@ storage_encrypted_collection_for_entity :: (entity_type: string, entity_id: stri
if entity_type == "app_preference" {
return "private.inbe.v1.app-preferences"
}
if entity_type == "app_order" {
return AppOrderCollection
}
if entity_type.count == 0 {
return ""
}
@@ -2127,6 +2176,9 @@ storage_decrypted_array_name :: (collection: string) -> string {
if collection == "private.inbe.v1.app-preferences" {
return "app_preferences"
}
if collection == AppOrderCollection {
return "app_order"
}
if storage_compare_text(collection, "private.inbe.v1.habits") == 0 {
return "habits"
}
@@ -2296,6 +2348,17 @@ storage_apply_decrypted_record :: (collection: string, record_id: string, plaint
if ok != 0 {
storage_set_setting_int("apps_setup_done", 1)
}
} else if array_name == "app_order" {
// A record this version can't read, such as another key a newer
// version adds here, changes nothing and doesn't stop the sync.
records := Scan.FieldAt(record_response, Scan.FieldAt(record_response, 0, "changes"), "app_order")
ok = 1
if Scan.ArrayCount(record_response, records) == 1 {
ok = storage_exec_json_user_sql(SyncAppOrderSQL, record_response)
if ok != 0 && sqlite3_changes(storage_db_handle()) > 0 {
storage_set_setting_int(AppOrderReceivedKey, 1)
}
}
} else if storage_compare_text(array_name, "habits") == 0 {
ok = ifx (storage_reconcile_remote_habit_ids(record_response) != 0 && storage_apply_sync_habits_json(record_response) != 0) then (1) else (0)
+19
View File
@@ -165,6 +165,25 @@ OR (excluded.updated_at = settings.updated_at AND NOT EXISTS (
))
SQL
// The pinned apps' order from another device: the newest order wins, and a
// pending local order wins a tie. The value is a list of package names.
SyncAppOrderSQL :: #string SQL
INSERT INTO settings(user_id,key,value,updated_at)
SELECT ?2,'app_order',json_extract(value,'$.value'),
CAST(strftime('%s',json_extract(value,'$.updated_at')) AS INTEGER)
FROM json_each(?1,'$.changes.app_order')
WHERE json_extract(value,'$.key')='app_order'
AND json_type(value,'$.value')='text'
AND length(CAST(json_extract(value,'$.value') AS BLOB))<=255
AND strftime('%s',json_extract(value,'$.updated_at')) IS NOT NULL
ON CONFLICT(user_id,key) DO UPDATE SET value=excluded.value,updated_at=excluded.updated_at
WHERE excluded.updated_at > settings.updated_at
OR (excluded.updated_at = settings.updated_at AND excluded.value != settings.value AND NOT EXISTS (
SELECT 1 FROM sync_outbox WHERE entity_type='app_order'
AND entity_id=settings.key AND local_date=0
))
SQL
// Local unacknowledged edits win ties; a remote record never queues itself.
SyncCellRecordsSQL :: #string SQL
INSERT INTO settings(user_id,key,value,updated_at)
+1 -1
View File
@@ -270,7 +270,7 @@ app_draw_dock :: (app: *InnerBreeze, over_practice: bool) {
app.launcher_favorite_count = LauncherPlaceFavorite(
app.launcher_favorites[:], app.launcher_favorite_count,
app.launcher_drag_route, result.drop_index)
save_settings(app)
app_launcher_pins_changed(app)
}
app.launcher_drag_key = 0
app.launcher_drag_moving = false
+4 -5
View File
@@ -46,12 +46,11 @@ int main(void)
memset(&app, 0, sizeof(app));
app_reset_bottom_nav_routes(&app);
assert(app.bottom_nav_route_count == 5);
assert(app.bottom_nav_route_count == 4);
assert(app.bottom_nav_routes[0] == AppNavRoute_APP_NAV_ROUTE_LUMI);
assert(app.bottom_nav_routes[1] == AppNavRoute_APP_NAV_ROUTE_ELIST);
assert(app.bottom_nav_routes[2] == AppNavRoute_APP_NAV_ROUTE_HABITS);
assert(app.bottom_nav_routes[3] == AppNavRoute_APP_NAV_ROUTE_PRACTICE);
assert(app.bottom_nav_routes[4] == AppNavRoute_APP_NAV_ROUTE_SETTINGS);
assert(app.bottom_nav_routes[1] == AppNavRoute_APP_NAV_ROUTE_HABITS);
assert(app.bottom_nav_routes[2] == AppNavRoute_APP_NAV_ROUTE_PRACTICE);
assert(app.bottom_nav_routes[3] == AppNavRoute_APP_NAV_ROUTE_SETTINGS);
account_present = 0;
account_alias = "";
app_nav_profile_identity(&app, out, sizeof(name), sub, sizeof(subtitle));
+30 -1
View File
@@ -54,4 +54,33 @@ assert value("cells_auto_update") == "0"
assert value("package_sequence_diary") == "10"
assert value("app_used_lists") == "1"
assert value("app_used_practices") == "1"
print("Account app choices: removals, independent merge, conflict handling, account isolation and device settings passed")
# The pinned apps' order: the newest wins, a pending local order wins a tie,
# and a record this version can't read changes nothing.
order_sql = re.search(r"SyncAppOrderSQL :: #string SQL\n(.*?)\nSQL", source, re.S)[1]
def order(value, timestamp, key="app_order"):
record = dict(key=key, value=value, updated_at=timestamp)
database.execute(order_sql, (json.dumps(dict(changes=dict(app_order=[record]))), "account"))
order("lumi,diary,habits", "1970-01-01T00:03:20Z")
assert value("app_order") == "lumi,diary,habits", "a first order was not taken"
order("practices", "1970-01-01T00:01:40Z")
assert value("app_order") == "lumi,diary,habits", "an older order replaced a newer one"
database.execute("INSERT INTO sync_outbox(entity_type,entity_id,local_date,queued_at) VALUES('app_order','app_order',0,200)")
order("habits", "1970-01-01T00:03:20Z")
assert value("app_order") == "lumi,diary,habits", "a remote order beat a pending local one at the same time"
order("diary", "1970-01-01T00:05:00Z")
assert value("app_order") == "diary"
order("lumi", "1970-01-01T00:10:00Z", key="app_order_tablet")
order("lumi", "invalid")
order("x" * 256, "1970-01-01T00:10:00Z")
record = dict(key="app_order", value=dict(apps="lumi"), updated_at="1970-01-01T00:10:00Z")
database.execute(order_sql, (json.dumps(dict(changes=dict(app_order=[record]))), "account"))
assert value("app_order") == "diary", "an unreadable order changed the pins"
assert database.execute("SELECT COUNT(*) FROM settings WHERE key='app_order_tablet'").fetchone()[0] == 0
order("", "1970-01-01T00:10:00Z")
assert value("app_order") == "", "an empty order did not unpin everything"
print("Account app choices: removals, independent merge, conflict handling, account isolation, device settings and pinned order passed")
+6 -7
View File
@@ -7,11 +7,10 @@ using AppNavRoute;
Answer :: () -> s32 {
routes: [7]s32
count := BottomNavDefaults(routes[:])
if count != 5 || routes[0] != APP_NAV_ROUTE_LUMI ||
routes[1] != APP_NAV_ROUTE_ELIST ||
routes[2] != APP_NAV_ROUTE_HABITS ||
routes[3] != APP_NAV_ROUTE_PRACTICE ||
routes[4] != APP_NAV_ROUTE_SETTINGS { return 2 }
if count != 4 || routes[0] != APP_NAV_ROUTE_LUMI ||
routes[1] != APP_NAV_ROUTE_HABITS ||
routes[2] != APP_NAV_ROUTE_PRACTICE ||
routes[3] != APP_NAV_ROUTE_SETTINGS { return 2 }
routes[0] = APP_NAV_ROUTE_HABITS
routes[1] = APP_NAV_ROUTE_PROFILE
routes[2] = APP_NAV_ROUTE_SETTINGS
@@ -52,8 +51,8 @@ Answer :: () -> s32 {
count = BottomNavSanitize(limited[:], 5, false)
if count != 5 || limited[4] != APP_NAV_ROUTE_SETTINGS { return 12 }
count = BottomNavSanitize(routes[:], 9, true)
if count != 5 || routes[0] != APP_NAV_ROUTE_LUMI ||
routes[4] != APP_NAV_ROUTE_SETTINGS { return 9 }
if count != 4 || routes[0] != APP_NAV_ROUTE_LUMI ||
routes[3] != APP_NAV_ROUTE_SETTINGS { return 9 }
short: [2]s32
if BottomNavDefaults(short[:]) != 0 ||
+18 -4
View File
@@ -119,8 +119,21 @@ with tempfile.TemporaryDirectory(prefix="inbe-app-choices-") as temporary:
saved = settings(profile)
assert saved["apps_setup_done"] == "0"
assert saved["language_setup_done"] == "1"
assert saved["enabled_apps"] == "63"
assert [int(saved[f"launcher_favorite_{i}"]) for i in range(5)] == [12, 1, 2, 3, 11]
# A new profile comes with Lumi, Habits and Practice, pinned in that
# order. They are defaults, not choices: stored at time 1 and not
# queued, so an account's apps replace them after sign-in.
assert saved["enabled_apps"] == "22"
assert saved["launcher_favorite_count"] == "3"
assert [int(saved[f"launcher_favorite_{i}"]) for i in range(3)] == [12, 1, 2]
with sqlite3.connect(profile / "inbe.db", timeout=5) as db:
defaults = {key: (value, updated) for key, value, updated in db.execute(
"SELECT key,value,updated_at FROM settings WHERE key LIKE 'app_used_%'")}
queued = db.execute("SELECT COUNT(*) FROM sync_outbox WHERE entity_type IN "
"('app_preference','app_order')").fetchone()[0]
assert defaults == {f"app_used_{name}": (str(int(name in ("habits", "practices", "lumi"))), 1)
for name in ("lists", "habits", "practices", "diary", "lumi", "leaderboard")}, defaults
assert queued == 0, "a new profile queued its default apps"
assert "app_order" not in saved, "a new profile sent its default pins"
# Closing before opening a tile keeps first-start Apps on restart.
with application(profile, "resume-apps") as (window, log):
capture(window, "resumed-apps")
@@ -146,7 +159,8 @@ with tempfile.TemporaryDirectory(prefix="inbe-app-choices-") as temporary:
tap(window, 180, 104)
command("xdotool", "type", "--clearmodifiers", "Lists")
time.sleep(.3)
tap(window, 180, 228)
# Lists is not installed, so its card is the first in More apps.
tap(window, 180, 270)
wait_setting(profile, "apps_setup_done", 1)
wait_setting(profile, "main_tab", 2)
assert "screen=21->16" in log.read_text(), log.read_text()
@@ -290,7 +304,7 @@ with tempfile.TemporaryDirectory(prefix="inbe-app-choices-") as temporary:
capture(window, "existing-data-lists")
result.update(
first_start_apps_library=True, system_language=True,
default_favorites_lumi_habits_practices=True, restart_in_onboarding=True,
default_apps_lumi_habits_practice=True, default_apps_not_sent=True, restart_in_onboarding=True,
open_tile_completes_setup=True, explicit_feature_cli=True,
same_runtime_feature_property=True, mini_lists_only_and_zero_apps=True,
mini_starts_practice_without_profile_writes=True,
+9
View File
@@ -108,6 +108,15 @@ HttpTransferPoll :: (transfer: *HttpTransfer, status: *s32) -> s32 {
return 1
}
// As Kryon's: HttpTransferPoll that also gives the answer's length, which
// the flows' answers do not have.
HttpTransferPollLength :: (transfer: *HttpTransfer, status: *s32, length: *s64) -> s32 {
if length != null {
length.* = 0
}
return HttpTransferPoll(transfer, status)
}
HttpTransferCancel :: (transfer: *HttpTransfer) {
operation := FlowFindOperation(transfer.handle)
if operation != null {
+34 -7
View File
@@ -6,16 +6,43 @@ using AppNavRoute;
#program_export
Answer :: () -> s32 {
favorites: [LAUNCHER_APP_COUNT]s32
if LauncherDefaults(favorites[:], true) != 5 ||
favorites[0] != APP_NAV_ROUTE_LUMI || favorites[4] != APP_NAV_ROUTE_DIARY {
// A new profile pins Lumi, Habits and Practice, in that order, on every
// device; the other apps wait in More apps.
if LauncherDefaults(favorites[:]) != 3 ||
favorites[0] != APP_NAV_ROUTE_LUMI || favorites[1] != APP_NAV_ROUTE_HABITS ||
favorites[2] != APP_NAV_ROUTE_PRACTICE {
return 18
}
// Leaderboard is installed with every profile but never pinned by default.
for index: cast(s32)0..cast(s32)4 {
if favorites[index] == APP_NAV_ROUTE_LEADERBOARD { return 20 }
short: [2]s32
if LauncherDefaults(short[:]) != 0 { return 19 }
order: [LAUNCHER_ORDER_TEXT_MAX + 1]u8
length := LauncherOrderText(favorites[:], 3, order[:])
if length != 21 || TextView(order[:length]) != "lumi,habits,practices" || order[length] != cast(u8)0 {
return 20
}
if LauncherDefaults(favorites[:], false) != 3 ||
favorites[2] != APP_NAV_ROUTE_PRACTICE { return 19 }
// Every app round-trips by name; unknown and repeated names drop out.
read: [LAUNCHER_APP_COUNT]s32
if LauncherOrderRoutes("diary,chess,lumi,,diary,leaderboard,lists", read[:]) != 4 ||
read[0] != APP_NAV_ROUTE_DIARY || read[1] != APP_NAV_ROUTE_LUMI ||
read[2] != APP_NAV_ROUTE_LEADERBOARD || read[3] != APP_NAV_ROUTE_ELIST {
return 22
}
if LauncherOrderRoutes("", read[:]) != 0 || LauncherOrderText(read[:], 0, order[:]) != 0 ||
order[0] != cast(u8)0 {
return 23
}
every := LauncherRoutes()
length = LauncherOrderText(every[:], cast(s32)every.count, order[:])
if LauncherOrderRoutes(TextView(order[:length]), read[:]) != LAUNCHER_APP_COUNT {
return 24
}
for index: cast(s32)0..LAUNCHER_APP_COUNT - 1 {
if read[index] != every[index] { return 25 }
}
// A full buffer keeps whole names only.
tiny: [12]u8
length = LauncherOrderText(favorites[:], 3, tiny[:])
if length != 11 || TextView(tiny[:length]) != "lumi,habits" { return 26 }
favorites[0] = APP_NAV_ROUTE_HABITS
favorites[1] = APP_NAV_ROUTE_PRACTICE
count := LauncherToggleFavorite(favorites[:], 2, APP_NAV_ROUTE_DIARY)
+2 -1
View File
@@ -274,7 +274,8 @@ with contextlib.ExitStack() as stack:
user = db.execute("SELECT id FROM users WHERE kind='local' LIMIT 1").fetchone()[0]
assert settings(profile)["language_setup_done"] == "0", "Fresh start skipped the language picker"
assert settings(profile)["apps_setup_done"] == "0"
assert favorites(profile) == [12, 1, 2, 3, 11], "Desktop defaults omitted installed apps"
assert favorites(profile) == [12, 1, 2], "New profiles do not pin Lumi, Habits and Practice"
assert settings(profile)["enabled_apps"] == "22", "New profiles do not install Lumi, Habits and Practice"
assert settings(profile)["theme"] == "9" and settings(profile)["theme_source"] == "0"
assert settings(profile)["theme_mode"] == "2"
# Merely opening and closing the picker does not complete setup.
+3 -2
View File
@@ -84,10 +84,11 @@ with tempfile.TemporaryDirectory(prefix="inbe-leaderboard-") as directory:
saved = dict(db.execute("SELECT key,value FROM settings WHERE user_id=?", (user,)))
favorites = [int(saved[f"launcher_favorite_{i}"])
for i in range(int(saved.get("launcher_favorite_count", 0)))]
assert int(saved["enabled_apps"]) & 32, "Leaderboard is not installed for a new profile"
# A new profile adds Leaderboard from More apps.
assert not int(saved["enabled_apps"]) & 32, "Leaderboard was installed for a new profile"
assert LEADERBOARD_ROUTE not in favorites, "Leaderboard was pinned by default"
settings = {"language": "en", "language_system": 0, "language_setup_done": 1,
"apps_setup_done": 1, "main_tab": 5, "tutorial_seen": 1,
"apps_setup_done": 1, "app_used_leaderboard": 1, "main_tab": 5, "tutorial_seen": 1,
"habits_guide_seen": 1, "lumi_guides_seen": 127, "launcher_guide_seen": 1, "package_updates_allowed": 0,
"apps_last_update_check": 1900000000,
# Pinned here, so the page has no "back to Apps" bar and
+6 -6
View File
@@ -125,19 +125,19 @@ with tempfile.TemporaryDirectory(prefix="inbe-startup-quit-") as temporary, cont
saved = settings(profile)
assert saved["enabled_apps"] == "22", "Startup changed saved app preferences"
order = [int(saved[f"launcher_favorite_{i}"]) for i in range(int(saved["launcher_favorite_count"]))]
assert order == [12, 1, 2, 3, 11], "Desktop defaults omitted an installed app: " + str(order)
assert order == [12, 1, 2], "Defaults are not Lumi, Habits and Practice: " + str(order)
deadline = time.monotonic() + 2
while "->0" not in log.read_text():
assert time.monotonic() < deadline, "Practices click was ignored\n" + log.read_text()
time.sleep(.05)
command("import", "-window", window, str(OUTPUT / "practices-open.png"))
# Diary is pinned but not installed, so the dock leaves it out;
# its card in the Apps library installs and opens it.
# Diary is not installed; its card in More apps installs and
# opens it.
click(window, 44, 660) # Apps, in the sidebar's bottom corner.
time.sleep(.4)
# Diary, the fifth pinned card: Apps fits five 144 wide cards
# in a row at this width.
click(window, 804, 228)
# Diary, the first card in More apps, under the row of three
# pinned cards.
click(window, 160, 380)
deadline = time.monotonic() + 2
while "screen=0->22" not in log.read_text():
assert time.monotonic() < deadline, "Diary click was ignored\n" + log.read_text()
+134
View File
@@ -26,6 +26,7 @@
#import, file "../src/cells/diary_records.zi";
#import, file "../src/cells/package_files.zi";
#import, file "../src/storage/cell_records.zi";
#import, file "../src/cells/catalog.zi";
#import, file "../src/storage/sync_nodes.zi";
#import, file "../src/storage/sync_node_storage.zi";
#import, file "../src/storage/sqlite.zi";
@@ -1836,6 +1837,137 @@ test_cell_records_round_trip :: () {
storage_close()
}
// The app choices a new profile starts with, stored as defaults.
store_default_apps :: () {
storage_set_setting_default_text("app_used_lists", "0")
storage_set_setting_default_text("app_used_habits", "1")
storage_set_setting_default_text("app_used_practices", "1")
storage_set_setting_default_text("app_used_diary", "0")
storage_set_setting_default_text("app_used_lumi", "1")
storage_set_setting_default_text("app_used_leaderboard", "0")
}
// A new device's default apps are never sent, so they cannot remove the
// account's apps. The owner's choices reach the account's other devices,
// each app on its own, and an older record never undoes a newer choice.
test_app_choices_sync_between_devices :: () {
first := make_root("sync-apps-a")
second := make_root("sync-apps-b")
check_true("init apps device a", storage_init(first) != 0)
set_account()
store_default_apps()
storage_set_setting_default_text("app_used_diary", "1")
check_true("a default never replaces a stored value", storage_get_setting_text("app_used_diary") == "0")
check_int("defaults are stored at the oldest time",
read_db_count("SELECT COUNT(*) FROM settings WHERE key LIKE 'app_used_%' AND updated_at=1"), 6)
check_int("defaults are not queued", read_db_count("SELECT COUNT(*) FROM sync_outbox"), 0)
// The owner installs Diary and removes Habits on device A.
storage_set_setting_int("app_used_diary", 1)
storage_set_setting_int("app_used_habits", 0)
check_true("device a payload", build_payload())
check_int("only the owner's two choices go out",
read_db_count("SELECT COUNT(*) FROM sync_outbox WHERE entity_type='app_preference'"), 2)
check_true("choices go in the app preferences collection",
contains(payload(), "private.inbe.v1.app-preferences"))
copy: TextBuffer
append(*copy, records_array())
storage_close()
check_true("init apps device b", storage_init(second) != 0)
set_account()
store_default_apps()
check_true("device b payload", build_payload())
check_true("a new device's defaults never go out",
!contains(payload(), "private.inbe.v1.app-preferences"))
check_true("device b applies a's choices",
storage_apply_sync_response_json(response_with(3, TextFromCString(*copy.bytes[0]))) != 0)
check_true("Diary installed on a is installed on b", storage_get_setting_text("app_used_diary") == "1")
check_true("Habits removed on a is removed on b", storage_get_setting_text("app_used_habits") == "0")
check_true("b keeps its other apps",
storage_get_setting_text("app_used_practices") == "1" && storage_get_setting_text("app_used_lists") == "0")
check_int("b does not send a's choices back",
read_db_count("SELECT COUNT(*) FROM sync_outbox WHERE entity_type='app_preference'"), 0)
// An older device's record of an earlier choice does not undo Diary.
check_true("an older choice applies without error",
storage_apply_decrypted_record("private.inbe.v1.app-preferences", "app_used_diary",
"{\"key\":\"app_used_diary\",\"value\":\"0\",\"updated_at\":\"2023-11-14T22:13:20Z\"}") != 0)
check_true("an older choice keeps the newer one", storage_get_setting_text("app_used_diary") == "1")
check_true("a later removal applies",
storage_apply_decrypted_record("private.inbe.v1.app-preferences", "app_used_diary",
"{\"key\":\"app_used_diary\",\"value\":\"0\",\"updated_at\":\"2030-03-17T17:46:40Z\"}") != 0)
check_true("the later removal wins", storage_get_setting_text("app_used_diary") == "0")
storage_close()
}
app_order_received :: () -> s32 {
return storage_get_setting_int(AppOrderReceivedKey, 0)
}
// The pinned apps' order goes to the account's other devices in its own
// collection, which older versions skip. The newest order wins, a pending
// local order wins a tie, and a record this version can't read changes
// nothing without stopping the sync.
test_app_order_syncs_between_devices :: () {
first := make_root("sync-order-a")
second := make_root("sync-order-b")
check_true("init order device a", storage_init(first) != 0)
set_account()
storage_set_setting_text(AppOrderKey, "lumi,diary,habits")
check_true("order payload", build_payload())
check_true("the order has its own collection", contains(payload(), "private.inbe.v1.app-order"))
check_true("the order is encrypted", !contains(payload(), "lumi,diary,habits"))
copy: TextBuffer
append(*copy, records_array())
storage_close()
check_true("init order device b", storage_init(second) != 0)
set_account()
check_true("device b applies the order",
storage_apply_sync_response_json(response_with(4, TextFromCString(*copy.bytes[0]))) != 0)
check_true("b has a's order", storage_get_setting_text(AppOrderKey) == "lumi,diary,habits")
check_int("b's pins take the order", app_order_received(), 1)
check_int("b does not send a's order back",
read_db_count("SELECT COUNT(*) FROM sync_outbox WHERE entity_type='app_order'"), 0)
storage_set_setting_int(AppOrderReceivedKey, 0)
check_true("an older order applies without error",
storage_apply_decrypted_record(AppOrderCollection, AppOrderKey,
"{\"key\":\"app_order\",\"value\":\"practices\",\"updated_at\":\"2023-11-14T22:13:20Z\"}") != 0)
check_true("an older order keeps the newer one", storage_get_setting_text(AppOrderKey) == "lumi,diary,habits")
check_int("an older order is not taken", app_order_received(), 0)
unreadable: [4]string = .[
"{\"key\":\"app_order_tablet\",\"value\":\"lumi\",\"updated_at\":\"2030-03-17T17:46:40Z\"}",
"{\"key\":\"app_order\",\"value\":{\"apps\":\"lumi\"},\"updated_at\":\"2030-03-17T17:46:40Z\"}",
"{\"key\":\"app_order\",\"value\":\"lumi\"}",
"{\"key\":\"app_order\",\"value\":\"lumi\",\"updated_at\":\"2030-03-17T17:46:40Z\"},{\"key\":\"app_order\",\"value\":\"diary\",\"updated_at\":\"2030-03-17T17:46:40Z\"}"
]
for plaintext: unreadable {
check_true("an unreadable order doesn't stop the sync",
storage_apply_decrypted_record(AppOrderCollection, AppOrderKey, plaintext) != 0)
}
check_true("an unreadable order changes nothing", storage_get_setting_text(AppOrderKey) == "lumi,diary,habits")
check_int("an unreadable order is not taken", app_order_received(), 0)
// The owner changes the pins on b while a's same-time order is on its way.
storage_set_setting_text(AppOrderKey, "habits")
exec_db_sql("UPDATE settings SET updated_at=1800000000 WHERE key='app_order'")
check_int("b's own order is queued",
read_db_count("SELECT COUNT(*) FROM sync_outbox WHERE entity_type='app_order'"), 1)
check_true("a same-time order applies without error",
storage_apply_decrypted_record(AppOrderCollection, AppOrderKey,
"{\"key\":\"app_order\",\"value\":\"diary\",\"updated_at\":\"2027-01-15T08:00:00Z\"}") != 0)
check_true("a pending local order wins a tie", storage_get_setting_text(AppOrderKey) == "habits")
check_true("a later order applies",
storage_apply_decrypted_record(AppOrderCollection, AppOrderKey,
"{\"key\":\"app_order\",\"value\":\"diary\",\"updated_at\":\"2030-03-17T17:46:40Z\"}") != 0)
check_true("the later order wins", storage_get_setting_text(AppOrderKey) == "diary")
check_int("the later order is taken", app_order_received(), 1)
// Nothing pinned is an order too.
check_true("an empty order applies",
storage_apply_decrypted_record(AppOrderCollection, AppOrderKey,
"{\"key\":\"app_order\",\"value\":\"\",\"updated_at\":\"2030-03-17T17:46:41Z\"}") != 0)
check_true("an empty order unpins everything", storage_get_setting_text(AppOrderKey) == "")
storage_close()
}
#program_export
Check :: () -> s32 {
guard := support_begin("/tmp/inbe-storage-sync-zi-test/")
@@ -1893,5 +2025,7 @@ Check :: () -> s32 {
test_waiting_review_merges()
test_questions_and_entries_sync()
test_kept_records_upload_kept()
test_app_choices_sync_between_devices()
test_app_order_syncs_between_devices()
return failures
}
+5 -1
View File
@@ -41,7 +41,7 @@ def restore_statements():
assert enqueue, "storage_enqueue_all_sync_state"
inserts = re.findall(r'exec_sql\("(INSERT INTO sync_outbox[^"]*)"\)',
enqueue.group(1))
assert len(inserts) == 9, inserts
assert len(inserts) == 10, inserts
return clear + inserts
@@ -60,6 +60,7 @@ def insert_row(database, table, values):
ENTITIES = [
("habit", "h1", 0), ("habit", "h2", 0), ("habit_day", "h1", 20260101),
("app_preference", "app_used_lists", 0), ("app_preference", "app_used_diary", 0),
("app_order", "app_order", 0),
("session", "s1", 0), ("elist_list", "l1", 0), ("elist_item", "i1", 0),
("habit_entry", "e1", 0), ("habit_change", "c1", 0),
("cell_record", "cell.lumi.message.history", 0),
@@ -87,6 +88,9 @@ def open_database():
insert_row(database, "settings", {"user_id": "u1", "key": "app_used_lists", "value": "0", "updated_at": 2})
insert_row(database, "settings", {"user_id": "u1", "key": "app_used_diary", "value": "1", "updated_at": 2})
insert_row(database, "settings", {"user_id": "u1", "key": "cells_auto_update", "value": "0", "updated_at": 2})
insert_row(database, "settings", {"user_id": "u1", "key": "app_order", "value": "lumi,diary", "updated_at": 2})
# A default nobody chose is never queued.
insert_row(database, "settings", {"user_id": "u1", "key": "app_used_leaderboard", "value": "0", "updated_at": 1})
for key in ("cell.lumi.message.history", "cell.diary.entry.today", "cell.feedback.report"):
insert_row(database, "settings", {"user_id": "u1", "key": key, "value": "{}", "updated_at": 2})
insert_row(database, "users", {"id": "u2"})
+7 -2
View File
@@ -489,9 +489,14 @@ CheckOrdinarySettings :: () {
flow_host_hosted = false
fixture_settings_app = InnerBreeze.{}
unused app_load_settings(*fixture_settings_app)
// A new profile's apps are defaults, not choices: they are stored but
// never sent, so they cannot replace the account's apps.
Expect("ordinary profile still introduces Lumi",
storage_get_setting_int("app_used_lumi", 0) == 1 &&
storage_get_setting_int("lumi_introduced", 0) == 1 && OutboxCount() == 1)
storage_get_setting_int("lumi_introduced", 0) == 1 && OutboxCount() == 0)
Expect("new profile defaults are Lumi, Habits and Practice",
fixture_settings_app.enabled_apps == APP_RECOMMENDED &&
db_select_int64_text("SELECT COUNT(*) FROM settings WHERE key LIKE 'app_used_%' AND updated_at=1", -1) == 6)
fixture_settings_app.apps_selected = 1
fixture_settings_app.enabled_apps = APP_LUMI
save_settings(*fixture_settings_app)
@@ -499,7 +504,7 @@ CheckOrdinarySettings :: () {
db_select_int64_text("SELECT COUNT(*) FROM settings WHERE key LIKE 'app_used_%'", -1) == 6 &&
storage_get_setting_int("app_used_diary", -1) == 0 &&
storage_get_setting_int("app_used_leaderboard", -1) == 0 &&
storage_get_setting_int("app_used_lumi", -1) == 1 && OutboxCount() == 6)
storage_get_setting_int("app_used_lumi", -1) == 1 && OutboxCount() == 2)
}
CheckCreatePreservesOwner :: () {