From 1da5dea5d03445e707a5fc729956d57a1b8d4323 Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Sun, 19 Apr 2026 05:33:35 +0600 Subject: [PATCH 01/15] feat: integrate preferenceChangePublisher to GeneralSettingsWriter --- .../java/com/fsck/k9/preferences/GeneralSettingsWriter.kt | 7 +++++++ .../src/main/java/com/fsck/k9/preferences/KoinModule.kt | 8 +++++++- 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/legacy/core/src/main/java/com/fsck/k9/preferences/GeneralSettingsWriter.kt b/legacy/core/src/main/java/com/fsck/k9/preferences/GeneralSettingsWriter.kt index 233aed69f4a..2251ea7d334 100644 --- a/legacy/core/src/main/java/com/fsck/k9/preferences/GeneralSettingsWriter.kt +++ b/legacy/core/src/main/java/com/fsck/k9/preferences/GeneralSettingsWriter.kt @@ -2,12 +2,15 @@ package com.fsck.k9.preferences import com.fsck.k9.Preferences import net.thunderbird.core.logging.legacy.Log +import net.thunderbird.core.preference.PreferenceChangePublisher +import net.thunderbird.core.preference.getPreferenceScope import net.thunderbird.core.preference.storage.StorageEditor import net.thunderbird.feature.account.storage.legacy.LegacyAccountStorageHandler internal class GeneralSettingsWriter( private val preferences: Preferences, private val generalSettingsManager: DefaultGeneralSettingsManager, + private val changePublisher: PreferenceChangePublisher, ) { fun write(settings: InternalSettingsMap): Boolean { // Convert general settings to the string representation used in preference storage @@ -32,6 +35,10 @@ internal class GeneralSettingsWriter( Log.v("Committed general settings to the preference storage.") generalSettingsManager.loadSettings() + mergedSettings.keys.forEach { + val preferenceScope = getPreferenceScope(it) + changePublisher.publish(scope = preferenceScope) + } true } else { diff --git a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt index 98f93394e8d..5f824093079 100644 --- a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt +++ b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt @@ -175,7 +175,13 @@ val preferencesModule = module { factory { GeneralSettingsValidator() } factory { GeneralSettingsUpgrader() } - factory { GeneralSettingsWriter(preferences = get(), generalSettingsManager = get()) } + factory { + GeneralSettingsWriter( + preferences = get(), + generalSettingsManager = get(), + changePublisher = get(), + ) + } factory { AccountSettingsValidator() } From 30cc24e3e4e68e4aed346513c3226e4b289cd008 Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Thu, 30 Apr 2026 19:03:10 +0600 Subject: [PATCH 02/15] refactor(DefaultDisplayVisualSettingsPreferenceManager): remove preferenceChangeBroker and stop implementing PreferenceChangeSubscriber. --- .../DefaultDisplayVisualSettingsPreferenceManager.kt | 12 +----------- .../main/java/com/fsck/k9/preferences/KoinModule.kt | 1 - 2 files changed, 1 insertion(+), 12 deletions(-) diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DefaultDisplayVisualSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DefaultDisplayVisualSettingsPreferenceManager.kt index 594129673bb..94e3c4b9fef 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DefaultDisplayVisualSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DefaultDisplayVisualSettingsPreferenceManager.kt @@ -15,8 +15,6 @@ import kotlinx.coroutines.launch import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock import net.thunderbird.core.logging.Logger -import net.thunderbird.core.preference.PreferenceChangeBroker -import net.thunderbird.core.preference.PreferenceChangeSubscriber import net.thunderbird.core.preference.display.visualSettings.message.list.MessageListPreferencesManager import net.thunderbird.core.preference.storage.Storage import net.thunderbird.core.preference.storage.StorageEditor @@ -30,15 +28,11 @@ class DefaultDisplayVisualSettingsPreferenceManager( private val logger: Logger, private val storagePersister: StoragePersister, private val storageEditor: StorageEditor, - preferenceChangeBroker: PreferenceChangeBroker, private val messageListPreferences: MessageListPreferencesManager, private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO, private val scope: CoroutineScope = CoroutineScope(SupervisorJob()), -) : DisplayVisualSettingsPreferenceManager, PreferenceChangeSubscriber { +) : DisplayVisualSettingsPreferenceManager { - init { - preferenceChangeBroker.subscribe(this) - } private val internalConfigState = MutableStateFlow(value = loadConfig()) private val configState: StateFlow = combine( internalConfigState, @@ -142,8 +136,4 @@ class DefaultDisplayVisualSettingsPreferenceManager( override fun getConfig() = configState.value override fun getConfigFlow(): Flow = configState - - override fun receive() { - internalConfigState.update { loadConfig() } - } } diff --git a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt index 5f824093079..b8291951543 100644 --- a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt +++ b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt @@ -83,7 +83,6 @@ val preferencesModule = module { storagePersister = get(), storageEditor = get().createStorageEditor(), messageListPreferences = get(), - preferenceChangeBroker = get(), ) } single { From 84e7b337c5fae849f13f5a1f538e73c70588a189 Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Thu, 30 Apr 2026 20:40:20 +0600 Subject: [PATCH 03/15] feat: add PreferenceScope --- .../core/preference/PreferenceScope.kt | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceScope.kt diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceScope.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceScope.kt new file mode 100644 index 00000000000..b820e89289d --- /dev/null +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceScope.kt @@ -0,0 +1,15 @@ +package net.thunderbird.core.preference + +enum class PreferenceScope { + ALL, + DEBUGGING, + DISPLAY_CORE, + DISPLAY_INBOX, + DISPLAY_MISC, + DISPLAY_VISUAL, + DISPLAY_VISUAL_MESSAGE_LIST, + INTERACTION, + NETWORK, + NOTIFICATION, + PRIVACY, +} From 0188f8d35f72442f9e9106e112119b660f9d9301 Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Thu, 30 Apr 2026 20:49:59 +0600 Subject: [PATCH 04/15] refactor: add emission scope support to PreferenceChangePublisher. --- .../core/preference/PreferenceChangePublisher.kt | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceChangePublisher.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceChangePublisher.kt index 66061e49f84..44949cc1d2b 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceChangePublisher.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceChangePublisher.kt @@ -2,11 +2,15 @@ package net.thunderbird.core.preference /** * Publishes changes of preferences to all subscribers. + * The change can be scoped to a specific category of preferences or applied globally. + * @see PreferenceScope for available scopes of preference changes. */ interface PreferenceChangePublisher { /** * Publish a change in the preferences. + * @param scope Defines which category of preferences has changed. + * By default, [PreferenceScope.ALL] is used, indicating a global change affecting all preferences. */ - fun publish() + fun publish(scope: PreferenceScope = PreferenceScope.ALL) } From 44c48a18038ad00da82e99470abdc0aa30533701 Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Thu, 30 Apr 2026 23:13:06 +0600 Subject: [PATCH 05/15] refactor: add scope support to PreferenceChangeSubscriber for scoped preference change notifications. --- .../core/preference/PreferenceChangeSubscriber.kt | 6 ++++-- .../core/preference/DefaultPreferenceChangeBroker.kt | 4 ++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceChangeSubscriber.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceChangeSubscriber.kt index bd7feb17ccd..6fd11347de2 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceChangeSubscriber.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceChangeSubscriber.kt @@ -6,7 +6,9 @@ package net.thunderbird.core.preference fun interface PreferenceChangeSubscriber { /** - * Called when preferences change. + * Called when preferences within a given scope have changed. + * @param scope The [PreferenceScope] indicating which category of preferences + * has been updated. */ - fun receive() + fun receive(scope: PreferenceScope) } diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/DefaultPreferenceChangeBroker.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/DefaultPreferenceChangeBroker.kt index 75ddb974993..aba0979e215 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/DefaultPreferenceChangeBroker.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/DefaultPreferenceChangeBroker.kt @@ -18,11 +18,11 @@ class DefaultPreferenceChangeBroker( } } - override fun publish() { + override fun publish(scope: PreferenceScope) { val currentSubscribers = synchronized(lock) { HashSet(subscribers) } for (subscriber in currentSubscribers) { - subscriber.receive() + subscriber.receive(scope) } } } From 911bc4dcfc49195dd70698fbffe572e3b646b08d Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Thu, 30 Apr 2026 23:28:54 +0600 Subject: [PATCH 06/15] feat: support scoped preference change handling in DefaultDebuggingSettingsPreferenceManager --- .../DebuggingSettingsPreferenceManager.kt | 17 ++++++++++++++--- ...DefaultDebuggingSettingsPreferenceManager.kt | 16 +++++++++++++++- .../java/com/fsck/k9/preferences/KoinModule.kt | 1 + 3 files changed, 30 insertions(+), 4 deletions(-) diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DebuggingSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DebuggingSettingsPreferenceManager.kt index d149fec3de0..6a96f06b7cc 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DebuggingSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DebuggingSettingsPreferenceManager.kt @@ -2,8 +2,19 @@ package net.thunderbird.core.preference.debugging import net.thunderbird.core.preference.PreferenceManager -const val KEY_ENABLE_DEBUG_LOGGING = "enableDebugLogging" -const val KEY_ENABLE_SYNC_DEBUG_LOGGING = "enableSyncDebugLogging" -const val KEY_ENABLE_SENSITIVE_LOGGING = "enableSensitiveLogging" +enum class DebugSettingKey(val value: String) { + + EnableDebugLogging("enableDebugLogging"), + EnableSyncDebugLogging("enableSyncDebugLogging"), + EnableSensitiveLogging("enableSensitiveLogging"), + ; + + companion object { + + fun isValid(value: String): Boolean { + return entries.any { it.value == value } + } + } +} interface DebuggingSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DefaultDebuggingSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DefaultDebuggingSettingsPreferenceManager.kt index 258a5ef6ab4..309c544b0f8 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DefaultDebuggingSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DefaultDebuggingSettingsPreferenceManager.kt @@ -14,6 +14,9 @@ import net.thunderbird.core.common.appConfig.PlatformConfigProvider import net.thunderbird.core.logging.LogLevel import net.thunderbird.core.logging.LogLevelManager import net.thunderbird.core.logging.Logger +import net.thunderbird.core.preference.PreferenceChangeBroker +import net.thunderbird.core.preference.PreferenceChangeSubscriber +import net.thunderbird.core.preference.PreferenceScope import net.thunderbird.core.preference.storage.Storage import net.thunderbird.core.preference.storage.StorageEditor import net.thunderbird.core.preference.storage.StoragePersister @@ -28,7 +31,12 @@ class DefaultDebuggingSettingsPreferenceManager( private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO, private var scope: CoroutineScope = CoroutineScope(SupervisorJob()), private val platformConfigProvider: PlatformConfigProvider, -) : DebuggingSettingsPreferenceManager { + preferenceChangeBroker: PreferenceChangeBroker, +) : DebuggingSettingsPreferenceManager, PreferenceChangeSubscriber { + + init { + preferenceChangeBroker.subscribe(this) + } private val configState: MutableStateFlow = MutableStateFlow(value = loadConfig()) private val mutex = Mutex() private val storage: Storage @@ -79,4 +87,10 @@ class DefaultDebuggingSettingsPreferenceManager( logLevelManager.restoreDefault() } } + + override fun receive(scope: PreferenceScope) { + if(scope == PreferenceScope.ALL || scope == PreferenceScope.DEBUGGING) { + configState.update { loadConfig() } + } + } } diff --git a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt index b8291951543..7d469820f7e 100644 --- a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt +++ b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt @@ -129,6 +129,7 @@ val preferencesModule = module { storageEditor = get().createStorageEditor(), logLevelManager = get(), platformConfigProvider = get(), + preferenceChangeBroker = get(), ) } single { From 6e28dc34bfc8f1c7c481d18686de2f3bfc387363 Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Thu, 30 Apr 2026 23:32:21 +0600 Subject: [PATCH 07/15] feat: support scoped preference change handling in Display Settings preference managers. --- .../DisplayCoreSettingsPreferenceManager.kt | 23 ++++++-- .../DisplayInboxSettingsPreferenceManager.kt | 23 ++++++-- .../DisplayMiscSettingsPreferenceManager.kt | 15 ++++- .../DisplayVisualSettingsPreferenceManager.kt | 31 ++++++---- .../list/MessageListPreferencesManager.kt | 31 ++++++---- ...ultDisplayCoreSettingsPreferenceManager.kt | 15 ++++- ...ltDisplayInboxSettingsPreferenceManager.kt | 15 ++++- ...ultDisplayMiscSettingsPreferenceManager.kt | 16 ++++- ...tDisplayVisualSettingsPreferenceManager.kt | 16 ++++- .../DefaultMessageListPreferencesManager.kt | 16 ++++- .../DefaultNotificationPreferenceManager.kt | 59 ++++++++++++------- .../com/fsck/k9/preferences/KoinModule.kt | 5 ++ 12 files changed, 205 insertions(+), 60 deletions(-) diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DisplayCoreSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DisplayCoreSettingsPreferenceManager.kt index 968d6a5420a..c6655447abd 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DisplayCoreSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DisplayCoreSettingsPreferenceManager.kt @@ -2,11 +2,22 @@ package net.thunderbird.core.preference.display.coreSettings import net.thunderbird.core.preference.PreferenceManager -const val KEY_FIXED_MESSAGE_VIEW_THEME = "fixedMessageViewTheme" -const val KEY_MESSAGE_VIEW_THEME = "messageViewTheme" -const val KEY_MESSAGE_COMPOSE_THEME = "messageComposeTheme" -const val KEY_APP_LANGUAGE = "language" -const val KEY_SPLIT_VIEW_MODE = "splitViewMode" -const val KEY_THEME = "theme" +enum class DisplayCoreSettingKey(val value: String) { + + FixedMessageViewTheme("fixedMessageViewTheme"), + MessageViewTheme("messageViewTheme"), + MessageComposeTheme("messageComposeTheme"), + AppLanguage("language"), + SplitViewMode("splitViewMode"), + Theme("theme"), + ; + + companion object { + + fun isValid(value: String): Boolean { + return entries.any { it.value == value } + } + } +} interface DisplayCoreSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DisplayInboxSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DisplayInboxSettingsPreferenceManager.kt index e38647f74a5..c6bb73cd9d1 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DisplayInboxSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DisplayInboxSettingsPreferenceManager.kt @@ -2,11 +2,22 @@ package net.thunderbird.core.preference.display.inboxSettings import net.thunderbird.core.preference.PreferenceManager -const val KEY_MESSAGE_LIST_SENDER_ABOVE_SUBJECT = "messageListSenderAboveSubject" -const val KEY_SHOW_COMPOSE_BUTTON_ON_MESSAGE_LIST = "showComposeButtonOnMessageList" -const val KEY_SHOW_MESSAGE_LIST_STARS = "messageListStars" -const val KEY_SHOW_STAR_COUNT = "showStarredCount" -const val KEY_SHOW_UNIFIED_INBOX = "showUnifiedInbox" -const val KEY_THREAD_VIEW_ENABLED = "isThreadedViewEnabled" +enum class DisplayInboxSettingKey(val value: String) { + + MessageListSenderAboveSubject("messageListSenderAboveSubject"), + ShowComposeButtonOnMessageList("showComposeButtonOnMessageList"), + ShowMessageListStars("messageListStars"), + ShowStarCount("showStarredCount"), + ShowUnifiedInbox("showUnifiedInbox"), + ThreadViewEnabled("isThreadedViewEnabled"), + ; + + companion object { + + fun isValid(value: String): Boolean { + return entries.any { it.value == value } + } + } +} interface DisplayInboxSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DisplayMiscSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DisplayMiscSettingsPreferenceManager.kt index 7e35af6dc41..1afa5a08190 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DisplayMiscSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DisplayMiscSettingsPreferenceManager.kt @@ -2,7 +2,18 @@ package net.thunderbird.core.preference.display.miscSettings import net.thunderbird.core.preference.PreferenceManager -const val KEY_SHOW_RECENT_CHANGES = "showRecentChanges" -const val KEY_SHOULD_SHOW_SETUP_ARCHIVE_FOLDER_DIALOG = "shouldShowSetupArchiveFolderDialog" +enum class DisplayMiscSettingKey(val value: String) { + + ShowRecentChanges("showRecentChanges"), + ShouldShowSetupArchiveFolderDialog("shouldShowSetupArchiveFolderDialog"), + ; + + companion object { + + fun isValid(value: String): Boolean { + return entries.any { it.value == value } + } + } +} interface DisplayMiscSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DisplayVisualSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DisplayVisualSettingsPreferenceManager.kt index 210d1f9063b..9854eb9994c 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DisplayVisualSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DisplayVisualSettingsPreferenceManager.kt @@ -2,15 +2,26 @@ package net.thunderbird.core.preference.display.visualSettings import net.thunderbird.core.preference.PreferenceManager -const val KEY_ANIMATION = "animations" -const val KEY_MESSAGE_VIEW_FIXED_WIDTH_FONT = "messageViewFixedWidthFont" -const val KEY_AUTO_FIT_WIDTH = "autofitWidth" -const val KEY_MESSAGE_VIEW_BODY_CONTENT_TYPE = "messageViewBodyContentType" -const val KEY_DRAWER_EXPAND_ALL_FOLDER = "drawerExpandAllFolder" -const val KEY_MESSAGE_VIEW_ARCHIVE_ACTION_VISIBLE = "messageViewArchiveActionVisible" -const val KEY_MESSAGE_VIEW_DELETE_ACTION_VISIBLE = "messageViewDeleteActionVisible" -const val KEY_MESSAGE_VIEW_MOVE_ACTION_VISIBLE = "messageViewMoveActionVisible" -const val KEY_MESSAGE_VIEW_COPY_ACTION_VISIBLE = "messageViewCopyActionVisible" -const val KEY_MESSAGE_VIEW_SPAM_ACTION_VISIBLE = "messageViewSpamActionVisible" +enum class DisplayVisualSettingKey(val value: String) { + + Animation("animations"), + MessageViewFixedWidthFont("messageViewFixedWidthFont"), + AutoFitWidth("autofitWidth"), + MessageViewBodyContentType("messageViewBodyContentType"), + DrawerExpandAllFolder("drawerExpandAllFolder"), + MessageViewArchiveActionVisible("messageViewArchiveActionVisible"), + MessageViewDeleteActionVisible("messageViewDeleteActionVisible"), + MessageViewMoveActionVisible("messageViewMoveActionVisible"), + MessageViewCopyActionVisible("messageViewCopyActionVisible"), + MessageViewSpamActionVisible("messageViewSpamActionVisible"), + ; + + companion object { + + fun isValid(value: String): Boolean { + return entries.any { it.value == value } + } + } +} interface DisplayVisualSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/MessageListPreferencesManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/MessageListPreferencesManager.kt index 7544915552b..c31cf0c143a 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/MessageListPreferencesManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/MessageListPreferencesManager.kt @@ -2,15 +2,26 @@ package net.thunderbird.core.preference.display.visualSettings.message.list import net.thunderbird.core.preference.PreferenceManager -const val KEY_COLORIZE_MISSING_CONTACT_PICTURE = "colorizeMissingContactPictures" -const val KEY_CHANGE_REGISTERED_NAME_COLOR = "changeRegisteredNameColor" -const val KEY_USE_BACKGROUND_AS_UNREAD_INDICATOR = "isUseBackgroundAsUnreadIndicator" -const val KEY_SHOW_CORRESPONDENT_NAMES = "showCorrespondentNames" -const val KEY_SHOW_CONTACT_NAME = "showContactName" -const val KEY_SHOW_CONTACT_PICTURE = "showContactPicture" -const val KEY_MESSAGE_LIST_VIEW_PREVIEW_LINES = "messageListPreviewLines" -const val KEY_MESSAGE_LIST_VIEW_DENSITY = "messageListDensity" -const val KEY_REGISTERED_NAME_COLOR = "registeredNameColor" -const val KEY_MESSAGE_LIST_DATE_TIME_FORMAT = "messageListDateTimeFormat" +enum class DisplayMessageListSettingKey(val value: String) { + + ColorizeMissingContactPicture("colorizeMissingContactPictures"), + ChangeRegisteredNameColor("changeRegisteredNameColor"), + UseBackgroundAsUnreadIndicator("isUseBackgroundAsUnreadIndicator"), + ShowCorrespondentNames("showCorrespondentNames"), + ShowContactName("showContactName"), + ShowContactPicture("showContactPicture"), + MessageListPreviewLines("messageListPreviewLines"), + MessageListDensity("messageListDensity"), + RegisteredNameColor("registeredNameColor"), + MessageListDateTimeFormat("messageListDateTimeFormat"), + ; + + companion object { + + fun isValid(value: String): Boolean { + return entries.any { it.value == value } + } + } +} interface MessageListPreferencesManager : PreferenceManager diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DefaultDisplayCoreSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DefaultDisplayCoreSettingsPreferenceManager.kt index a8bcda29690..12fcc6f7a0e 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DefaultDisplayCoreSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DefaultDisplayCoreSettingsPreferenceManager.kt @@ -11,6 +11,9 @@ import kotlinx.coroutines.launch import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock import net.thunderbird.core.logging.Logger +import net.thunderbird.core.preference.PreferenceChangeBroker +import net.thunderbird.core.preference.PreferenceChangeSubscriber +import net.thunderbird.core.preference.PreferenceScope import net.thunderbird.core.preference.storage.Storage import net.thunderbird.core.preference.storage.StorageEditor import net.thunderbird.core.preference.storage.StoragePersister @@ -25,8 +28,12 @@ class DefaultDisplayCoreSettingsPreferenceManager( private val storageEditor: StorageEditor, private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO, private var scope: CoroutineScope = CoroutineScope(SupervisorJob()), -) : DisplayCoreSettingsPreferenceManager { + preferenceChangeBroker: PreferenceChangeBroker, +) : DisplayCoreSettingsPreferenceManager, PreferenceChangeSubscriber { + init { + preferenceChangeBroker.subscribe(this) + } private val configState: MutableStateFlow = MutableStateFlow(value = loadConfig()) private val mutex = Mutex() private val storage: Storage @@ -88,4 +95,10 @@ class DefaultDisplayCoreSettingsPreferenceManager( } } } + + override fun receive(scope: PreferenceScope) { + if (scope == PreferenceScope.ALL || scope == PreferenceScope.DISPLAY_CORE) { + configState.update { loadConfig() } + } + } } diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DefaultDisplayInboxSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DefaultDisplayInboxSettingsPreferenceManager.kt index 62ac95ceb8e..143eafac68f 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DefaultDisplayInboxSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DefaultDisplayInboxSettingsPreferenceManager.kt @@ -11,6 +11,9 @@ import kotlinx.coroutines.launch import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock import net.thunderbird.core.logging.Logger +import net.thunderbird.core.preference.PreferenceChangeBroker +import net.thunderbird.core.preference.PreferenceChangeSubscriber +import net.thunderbird.core.preference.PreferenceScope import net.thunderbird.core.preference.storage.Storage import net.thunderbird.core.preference.storage.StorageEditor import net.thunderbird.core.preference.storage.StoragePersister @@ -23,8 +26,12 @@ class DefaultDisplayInboxSettingsPreferenceManager( private val storageEditor: StorageEditor, private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO, private var scope: CoroutineScope = CoroutineScope(SupervisorJob()), -) : DisplayInboxSettingsPreferenceManager { + preferenceChangeBroker: PreferenceChangeBroker, +) : DisplayInboxSettingsPreferenceManager, PreferenceChangeSubscriber { + init { + preferenceChangeBroker.subscribe(this) + } private val configState: MutableStateFlow = MutableStateFlow(value = loadConfig()) private val mutex = Mutex() private val storage: Storage @@ -95,4 +102,10 @@ class DefaultDisplayInboxSettingsPreferenceManager( } } } + + override fun receive(scope: PreferenceScope) { + if (scope == PreferenceScope.ALL || scope == PreferenceScope.DISPLAY_INBOX) { + configState.update { loadConfig() } + } + } } diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DefaultDisplayMiscSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DefaultDisplayMiscSettingsPreferenceManager.kt index 052d8e0b4a4..96936f5cd5c 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DefaultDisplayMiscSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DefaultDisplayMiscSettingsPreferenceManager.kt @@ -11,6 +11,9 @@ import kotlinx.coroutines.launch import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock import net.thunderbird.core.logging.Logger +import net.thunderbird.core.preference.PreferenceChangeBroker +import net.thunderbird.core.preference.PreferenceChangeSubscriber +import net.thunderbird.core.preference.PreferenceScope import net.thunderbird.core.preference.storage.Storage import net.thunderbird.core.preference.storage.StorageEditor import net.thunderbird.core.preference.storage.StoragePersister @@ -23,7 +26,12 @@ class DefaultDisplayMiscSettingsPreferenceManager( private val storageEditor: StorageEditor, private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO, private var scope: CoroutineScope = CoroutineScope(SupervisorJob()), -) : DisplayMiscSettingsPreferenceManager { + preferenceChangeBroker: PreferenceChangeBroker, +) : DisplayMiscSettingsPreferenceManager, PreferenceChangeSubscriber { + + init { + preferenceChangeBroker.subscribe(this) + } private val configState: MutableStateFlow = MutableStateFlow(value = loadConfig()) private val mutex = Mutex() private val storage: Storage @@ -64,4 +72,10 @@ class DefaultDisplayMiscSettingsPreferenceManager( } } } + + override fun receive(scope: PreferenceScope) { + if (scope == PreferenceScope.ALL || scope == PreferenceScope.DISPLAY_MISC) { + configState.update { loadConfig() } + } + } } diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DefaultDisplayVisualSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DefaultDisplayVisualSettingsPreferenceManager.kt index 94e3c4b9fef..96336f02a43 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DefaultDisplayVisualSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DefaultDisplayVisualSettingsPreferenceManager.kt @@ -15,6 +15,9 @@ import kotlinx.coroutines.launch import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock import net.thunderbird.core.logging.Logger +import net.thunderbird.core.preference.PreferenceChangeBroker +import net.thunderbird.core.preference.PreferenceChangeSubscriber +import net.thunderbird.core.preference.PreferenceScope import net.thunderbird.core.preference.display.visualSettings.message.list.MessageListPreferencesManager import net.thunderbird.core.preference.storage.Storage import net.thunderbird.core.preference.storage.StorageEditor @@ -31,7 +34,12 @@ class DefaultDisplayVisualSettingsPreferenceManager( private val messageListPreferences: MessageListPreferencesManager, private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO, private val scope: CoroutineScope = CoroutineScope(SupervisorJob()), -) : DisplayVisualSettingsPreferenceManager { + preferenceChangeBroker: PreferenceChangeBroker, +) : DisplayVisualSettingsPreferenceManager, PreferenceChangeSubscriber { + + init { + preferenceChangeBroker.subscribe(this) + } private val internalConfigState = MutableStateFlow(value = loadConfig()) private val configState: StateFlow = combine( @@ -136,4 +144,10 @@ class DefaultDisplayVisualSettingsPreferenceManager( override fun getConfig() = configState.value override fun getConfigFlow(): Flow = configState + + override fun receive(scope: PreferenceScope) { + if (scope == PreferenceScope.ALL || scope == PreferenceScope.DISPLAY_VISUAL) { + internalConfigState.update { loadConfig() } + } + } } diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/DefaultMessageListPreferencesManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/DefaultMessageListPreferencesManager.kt index d4f0b897ecb..9f0f950c793 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/DefaultMessageListPreferencesManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/DefaultMessageListPreferencesManager.kt @@ -4,6 +4,9 @@ import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.update import net.thunderbird.core.logging.Logger +import net.thunderbird.core.preference.PreferenceChangeBroker +import net.thunderbird.core.preference.PreferenceChangeSubscriber +import net.thunderbird.core.preference.PreferenceScope import net.thunderbird.core.preference.storage.Storage import net.thunderbird.core.preference.storage.StorageEditor import net.thunderbird.core.preference.storage.getEnumOrDefault @@ -15,7 +18,12 @@ class DefaultMessageListPreferencesManager( private val logger: Logger, private val storage: Storage, private val storageEditor: StorageEditor, -) : MessageListPreferencesManager { + preferenceChangeBroker: PreferenceChangeBroker, +) : MessageListPreferencesManager, PreferenceChangeSubscriber { + + init { + preferenceChangeBroker.subscribe(this) + } private val preferences = MutableStateFlow(value = loadPreferences()) override fun save(config: DisplayMessageListSettings) { logger.debug(TAG) { "save() called with: config = $config" } @@ -84,4 +92,10 @@ class DefaultMessageListPreferencesManager( override fun getConfig(): DisplayMessageListSettings = preferences.value override fun getConfigFlow(): Flow = preferences + + override fun receive(scope: PreferenceScope) { + if (scope == PreferenceScope.ALL || scope == PreferenceScope.DISPLAY_VISUAL_MESSAGE_LIST) { + preferences.update { loadPreferences() } + } + } } diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/notification/DefaultNotificationPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/notification/DefaultNotificationPreferenceManager.kt index 1d3d4201e20..c34d7bab422 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/notification/DefaultNotificationPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/notification/DefaultNotificationPreferenceManager.kt @@ -13,6 +13,9 @@ import kotlinx.coroutines.sync.withLock import net.thunderbird.core.common.notification.NotificationActionTokens import net.thunderbird.core.logging.Logger import net.thunderbird.core.preference.NotificationQuickDelete +import net.thunderbird.core.preference.PreferenceChangeBroker +import net.thunderbird.core.preference.PreferenceChangeSubscriber +import net.thunderbird.core.preference.PreferenceScope import net.thunderbird.core.preference.storage.Storage import net.thunderbird.core.preference.storage.StorageEditor import net.thunderbird.core.preference.storage.StoragePersister @@ -27,7 +30,12 @@ class DefaultNotificationPreferenceManager( private val storageEditor: StorageEditor, private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO, private var scope: CoroutineScope = CoroutineScope(SupervisorJob()), -) : NotificationPreferenceManager { + preferenceChangeBroker: PreferenceChangeBroker, +) : NotificationPreferenceManager, PreferenceChangeSubscriber { + + init { + preferenceChangeBroker.subscribe(this) + } private val mutex = Mutex() private val storage: Storage get() = storagePersister.loadValues() @@ -39,7 +47,7 @@ class DefaultNotificationPreferenceManager( private fun getConfigFromStorage(storage: Storage): NotificationPreference { val notificationQuickDeleteBehaviour = storage.getEnumOrDefault( - key = KEY_NOTIFICATION_QUICK_DELETE_BEHAVIOUR, + key = NotificationSettingKey.NotificationQuickDeleteBehaviour.value, default = NOTIFICATION_PREFERENCE_DEFAULT_QUICK_DELETE_BEHAVIOUR, ) val isSummaryDeleteActionEnabled = resolveSummaryDeleteActionEnabled( @@ -49,37 +57,37 @@ class DefaultNotificationPreferenceManager( return NotificationPreference( isQuietTimeEnabled = storage.getBoolean( - key = KEY_QUIET_TIME_ENABLED, + key = NotificationSettingKey.QuietTimeEnabled.value, defValue = NOTIFICATION_PREFERENCE_DEFAULT_IS_QUIET_TIME_ENABLED, ), quietTimeStarts = storage.getStringOrDefault( - key = KEY_QUIET_TIME_STARTS, + key = NotificationSettingKey.QuietTimeStarts.value, defValue = NOTIFICATION_PREFERENCE_DEFAULT_QUIET_TIME_STARTS, ), quietTimeEnds = storage.getStringOrDefault( - key = KEY_QUIET_TIME_ENDS, + key = NotificationSettingKey.QuietTimeEnds.value, defValue = NOTIFICATION_PREFERENCE_DEFAULT_QUIET_TIME_END, ), isNotificationDuringQuietTimeEnabled = storage.getBoolean( - key = KEY_NOTIFICATION_DURING_QUIET_TIME_ENABLED, + key = NotificationSettingKey.NotificationDuringQuietTimeEnabled.value, defValue = NOTIFICATION_PREFERENCE_DEFAULT_IS_NOTIFICATION_DURING_QUIET_TIME_ENABLED, ), messageActionsOrder = NotificationActionTokens.parseOrder( storage.getStringOrDefault( - key = KEY_MESSAGE_ACTIONS_ORDER, + key = NotificationSettingKey.MessageActionsOrder.value, defValue = NotificationActionTokens.serializeOrder( NOTIFICATION_PREFERENCE_DEFAULT_MESSAGE_ACTIONS_ORDER, ), ), ), messageActionsCutoff = storage.getInt( - key = KEY_MESSAGE_ACTIONS_CUTOFF, + key = NotificationSettingKey.MessageActionsCutoff.value, defValue = NOTIFICATION_PREFERENCE_DEFAULT_MESSAGE_ACTIONS_CUTOFF, ), isSummaryDeleteActionEnabled = isSummaryDeleteActionEnabled, notificationQuickDeleteBehaviour = notificationQuickDeleteBehaviour, lockScreenNotificationVisibility = storage.getEnumOrDefault( - key = KEY_LOCK_SCREEN_NOTIFICATION_VISIBILITY, + key = NotificationSettingKey.LockScreenNotificationVisibility.value, default = NOTIFICATION_PREFERENCE_DEFAULT_LOCK_SCREEN_NOTIFICATION_VISIBILITY, ), ) @@ -89,14 +97,14 @@ class DefaultNotificationPreferenceManager( storage: Storage, quickDeleteBehaviour: NotificationQuickDelete, ): Boolean { - return if (storage.contains(KEY_IS_SUMMARY_DELETE_ACTION_ENABLED)) { + return if (storage.contains(NotificationSettingKey.IsSummaryDeleteActionEnabled.value)) { storage.getBoolean( - key = KEY_IS_SUMMARY_DELETE_ACTION_ENABLED, + key = NotificationSettingKey.IsSummaryDeleteActionEnabled.value, defValue = NOTIFICATION_PREFERENCE_DEFAULT_IS_SUMMARY_DELETE_ACTION_ENABLED, ) } else { val derivedValue = quickDeleteBehaviour == NotificationQuickDelete.ALWAYS - storageEditor.putBoolean(KEY_IS_SUMMARY_DELETE_ACTION_ENABLED, derivedValue) + storageEditor.putBoolean(NotificationSettingKey.IsSummaryDeleteActionEnabled.value, derivedValue) storageEditor.commit() derivedValue } @@ -109,28 +117,31 @@ class DefaultNotificationPreferenceManager( logger.debug(TAG) { "writeConfig() called with: config = $config" } scope.launch(ioDispatcher) { mutex.withLock { - storageEditor.putString(KEY_QUIET_TIME_ENDS, config.quietTimeEnds) - storageEditor.putString(KEY_QUIET_TIME_STARTS, config.quietTimeStarts) + storageEditor.putString(NotificationSettingKey.QuietTimeEnds.value, config.quietTimeEnds) + storageEditor.putString(NotificationSettingKey.QuietTimeStarts.value, config.quietTimeStarts) storageEditor.putBoolean( - KEY_QUIET_TIME_ENABLED, + NotificationSettingKey.QuietTimeEnabled.value, config.isQuietTimeEnabled, ) storageEditor.putBoolean( - KEY_NOTIFICATION_DURING_QUIET_TIME_ENABLED, + NotificationSettingKey.NotificationDuringQuietTimeEnabled.value, config.isNotificationDuringQuietTimeEnabled, ) storageEditor.putString( - KEY_MESSAGE_ACTIONS_ORDER, + NotificationSettingKey.MessageActionsOrder.value, NotificationActionTokens.serializeOrder(config.messageActionsOrder), ) - storageEditor.putInt(KEY_MESSAGE_ACTIONS_CUTOFF, config.messageActionsCutoff) - storageEditor.putBoolean(KEY_IS_SUMMARY_DELETE_ACTION_ENABLED, config.isSummaryDeleteActionEnabled) + storageEditor.putInt(NotificationSettingKey.MessageActionsCutoff.value, config.messageActionsCutoff) + storageEditor.putBoolean( + NotificationSettingKey.IsSummaryDeleteActionEnabled.value, + config.isSummaryDeleteActionEnabled, + ) storageEditor.putEnum( - KEY_NOTIFICATION_QUICK_DELETE_BEHAVIOUR, + NotificationSettingKey.NotificationQuickDeleteBehaviour.value, config.notificationQuickDeleteBehaviour, ) storageEditor.putEnum( - KEY_LOCK_SCREEN_NOTIFICATION_VISIBILITY, + NotificationSettingKey.LockScreenNotificationVisibility.value, config.lockScreenNotificationVisibility, ) storageEditor.commit().also { commited -> @@ -140,4 +151,10 @@ class DefaultNotificationPreferenceManager( configState.update { config } } } + + override fun receive(scope: PreferenceScope) { + if (scope == PreferenceScope.ALL || scope == PreferenceScope.NOTIFICATION) { + configState.update { getConfigFromStorage(storage) } + } + } } diff --git a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt index 7d469820f7e..dce1e5822a1 100644 --- a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt +++ b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt @@ -68,6 +68,7 @@ val preferencesModule = module { logger = get(), storagePersister = get(), storageEditor = get().createStorageEditor(), + preferenceChangeBroker = get(), ) } single { @@ -75,6 +76,7 @@ val preferencesModule = module { logger = get(), storagePersister = get(), storageEditor = get().createStorageEditor(), + preferenceChangeBroker = get(), ) } single { @@ -83,6 +85,7 @@ val preferencesModule = module { storagePersister = get(), storageEditor = get().createStorageEditor(), messageListPreferences = get(), + preferenceChangeBroker = get(), ) } single { @@ -90,6 +93,7 @@ val preferencesModule = module { logger = get(), storagePersister = get(), storageEditor = get().createStorageEditor(), + preferenceChangeBroker = get(), ) } single { @@ -113,6 +117,7 @@ val preferencesModule = module { logger = get(), storage = get(), storageEditor = get(), + preferenceChangeBroker = get(), ) } single { From 9868698cbdecd2b29b70b315a04f0066cb466955 Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Thu, 30 Apr 2026 23:35:25 +0600 Subject: [PATCH 08/15] feat: support scoped preference change handling in DefaultInteractionSettingsPreferenceManager --- .../InteractionSettingsPreferenceManager.kt | 32 ++++++++++++------- ...ultInteractionSettingsPreferenceManager.kt | 16 +++++++++- .../com/fsck/k9/preferences/KoinModule.kt | 1 + 3 files changed, 37 insertions(+), 12 deletions(-) diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/InteractionSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/InteractionSettingsPreferenceManager.kt index 818df9ce425..fa9fb37d97e 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/InteractionSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/InteractionSettingsPreferenceManager.kt @@ -2,16 +2,26 @@ package net.thunderbird.core.preference.interaction import net.thunderbird.core.preference.PreferenceManager -const val KEY_USE_VOLUME_KEYS_FOR_NAVIGATION = "useVolumeKeysForNavigation" -const val KEY_MESSAGE_VIEW_POST_DELETE_ACTION = "messageViewPostDeleteAction" -const val KEY_MESSAGE_VIEW_POST_MARK_AS_UNREAD_ACTION = "messageViewPostMarkAsReadAction" -const val KEY_SWIPE_ACTION_LEFT = "swipeLeftAction" -const val KEY_SWIPE_ACTION_RIGHT = "swipeRightAction" -const val KEY_CONFIRM_DELETE = "confirmDelete" -const val KEY_CONFIRM_DISCARD_MESSAGE = "confirmDiscardMessage" -const val KEY_CONFIRM_DELETE_STARRED = "confirmDeleteStarred" -const val KEY_CONFIRM_SPAM = "confirmSpam" -const val KEY_CONFIRM_DELETE_FROM_NOTIFICATION = "confirmDeleteFromNotification" -const val KEY_CONFIRM_MARK_ALL_READ = "confirmMarkAllRead" +enum class InteractionSettingKey(val value: String) { + + UseVolumeKeysForNavigation("useVolumeKeysForNavigation"), + MessageViewPostDeleteAction("messageViewPostDeleteAction"), + SwipeActionLeft("swipeLeftAction"), + SwipeActionRight("swipeRightAction"), + ConfirmDelete("confirmDelete"), + ConfirmDiscardMessage("confirmDiscardMessage"), + ConfirmDeleteStarred("confirmDeleteStarred"), + ConfirmSpam("confirmSpam"), + ConfirmDeleteFromNotification("confirmDeleteFromNotification"), + ConfirmMarkAllRead("confirmMarkAllRead"), + ; + + companion object { + + fun isValid(value: String): Boolean { + return entries.any { it.value == value } + } + } +} interface InteractionSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/DefaultInteractionSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/DefaultInteractionSettingsPreferenceManager.kt index 4688fd8a3ca..0ea48daae36 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/DefaultInteractionSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/DefaultInteractionSettingsPreferenceManager.kt @@ -12,6 +12,9 @@ import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock import net.thunderbird.core.common.action.SwipeActions import net.thunderbird.core.logging.Logger +import net.thunderbird.core.preference.PreferenceChangeBroker +import net.thunderbird.core.preference.PreferenceChangeSubscriber +import net.thunderbird.core.preference.PreferenceScope import net.thunderbird.core.preference.storage.Storage import net.thunderbird.core.preference.storage.StorageEditor import net.thunderbird.core.preference.storage.StoragePersister @@ -26,7 +29,12 @@ class DefaultInteractionSettingsPreferenceManager( private val storageEditor: StorageEditor, private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO, private var scope: CoroutineScope = CoroutineScope(SupervisorJob()), -) : InteractionSettingsPreferenceManager { + preferenceChangeBroker: PreferenceChangeBroker, +) : InteractionSettingsPreferenceManager, PreferenceChangeSubscriber { + + init { + preferenceChangeBroker.subscribe(this) + } private val configState: MutableStateFlow = MutableStateFlow(value = loadConfig()) private val mutex = Mutex() @@ -109,4 +117,10 @@ class DefaultInteractionSettingsPreferenceManager( } } } + + override fun receive(scope: PreferenceScope) { + if(scope == PreferenceScope.ALL || scope == PreferenceScope.INTERACTION) { + configState.update { loadConfig() } + } + } } diff --git a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt index dce1e5822a1..4a3623b4c98 100644 --- a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt +++ b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt @@ -101,6 +101,7 @@ val preferencesModule = module { logger = get(), storagePersister = get(), storageEditor = get().createStorageEditor(), + preferenceChangeBroker = get(), ) } single { From 28b782a322271c03187d6b4e845687640c39c586 Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Thu, 30 Apr 2026 23:38:12 +0600 Subject: [PATCH 09/15] feat: support scoped preference change handling in DefaultNetworkSettingsPreferenceManager --- .../network/NetworkSettingsPreferenceManager.kt | 13 ++++++++++++- .../DefaultNetworkSettingsPreferenceManager.kt | 16 +++++++++++++++- .../java/com/fsck/k9/preferences/KoinModule.kt | 1 + 3 files changed, 28 insertions(+), 2 deletions(-) diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/network/NetworkSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/network/NetworkSettingsPreferenceManager.kt index bd97a95a932..8cc480219c8 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/network/NetworkSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/network/NetworkSettingsPreferenceManager.kt @@ -2,6 +2,17 @@ package net.thunderbird.core.preference.network import net.thunderbird.core.preference.PreferenceManager -const val KEY_BG_OPS = "backgroundOperations" +enum class NetworkSettingKey(val value: String) { + BackgroundOperations("backgroundOperations"), + ; +} + + companion object { + + fun isValid(value: String): Boolean { + return entries.any { it.value == value } + } + } +} interface NetworkSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/network/DefaultNetworkSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/network/DefaultNetworkSettingsPreferenceManager.kt index 2f47d06de08..5a05821539a 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/network/DefaultNetworkSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/network/DefaultNetworkSettingsPreferenceManager.kt @@ -11,6 +11,9 @@ import kotlinx.coroutines.launch import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock import net.thunderbird.core.logging.Logger +import net.thunderbird.core.preference.PreferenceChangeBroker +import net.thunderbird.core.preference.PreferenceChangeSubscriber +import net.thunderbird.core.preference.PreferenceScope import net.thunderbird.core.preference.storage.Storage import net.thunderbird.core.preference.storage.StorageEditor import net.thunderbird.core.preference.storage.StoragePersister @@ -25,7 +28,12 @@ class DefaultNetworkSettingsPreferenceManager( private val storageEditor: StorageEditor, private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO, private var scope: CoroutineScope = CoroutineScope(SupervisorJob()), -) : NetworkSettingsPreferenceManager { + preferenceChangeBroker: PreferenceChangeBroker, +) : NetworkSettingsPreferenceManager, PreferenceChangeSubscriber { + + init { + preferenceChangeBroker.subscribe(this) + } private val configState: MutableStateFlow = MutableStateFlow(value = loadConfig()) private val mutex = Mutex() private val storage: Storage @@ -55,4 +63,10 @@ class DefaultNetworkSettingsPreferenceManager( } } } + + override fun receive(scope: PreferenceScope) { + if(scope == PreferenceScope.ALL || scope == PreferenceScope.NETWORK) { + configState.update { loadConfig() } + } + } } diff --git a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt index 4a3623b4c98..41f999d6e3d 100644 --- a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt +++ b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt @@ -126,6 +126,7 @@ val preferencesModule = module { logger = get(), storagePersister = get(), storageEditor = get().createStorageEditor(), + preferenceChangeBroker = get(), ) } single { From 0bac953461bdcd783612c4b2651edb38489f1852 Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Thu, 30 Apr 2026 23:59:32 +0600 Subject: [PATCH 10/15] feat: support scoped preference change handling in DefaultNotificationPreferenceManager --- .../NotificationPreferenceManager.kt | 27 ++++++++++++------- .../DefaultNotificationPreferenceManager.kt | 2 +- .../com/fsck/k9/preferences/KoinModule.kt | 1 + 3 files changed, 20 insertions(+), 10 deletions(-) diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/notification/NotificationPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/notification/NotificationPreferenceManager.kt index e25be0dce7d..0ff4e99f37f 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/notification/NotificationPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/notification/NotificationPreferenceManager.kt @@ -2,15 +2,24 @@ package net.thunderbird.core.preference.notification import net.thunderbird.core.preference.PreferenceManager -const val KEY_QUIET_TIME_ENDS = "quietTimeEnds" -const val KEY_QUIET_TIME_STARTS = "quietTimeStarts" -const val KEY_QUIET_TIME_ENABLED = "quietTimeEnabled" -const val KEY_NOTIFICATION_DURING_QUIET_TIME_ENABLED = "notificationDuringQuietTimeEnabled" -const val KEY_MESSAGE_ACTIONS_ORDER = "messageActionsOrder" -const val KEY_MESSAGE_ACTIONS_CUTOFF = "messageActionsCutoff" -const val KEY_IS_SUMMARY_DELETE_ACTION_ENABLED = "isSummaryDeleteActionEnabled" +enum class NotificationSettingKey(val value: String) { -const val KEY_NOTIFICATION_QUICK_DELETE_BEHAVIOUR = "notificationQuickDelete" -const val KEY_LOCK_SCREEN_NOTIFICATION_VISIBILITY = "lockScreenNotificationVisibility" + QuietTimeEnds("quietTimeEnds"), + QuietTimeStarts("quietTimeStarts"), + QuietTimeEnabled("quietTimeEnabled"), + NotificationDuringQuietTimeEnabled("notificationDuringQuietTimeEnabled"), + MessageActionsOrder("messageActionsOrder"), + MessageActionsCutoff("messageActionsCutoff"), + IsSummaryDeleteActionEnabled("isSummaryDeleteActionEnabled"), + NotificationQuickDeleteBehaviour("notificationQuickDelete"), + LockScreenNotificationVisibility("lockScreenNotificationVisibility"), + ; + companion object { + + fun isValid(value: String): Boolean { + return entries.any { it.value == value } + } + } +} interface NotificationPreferenceManager : PreferenceManager diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/notification/DefaultNotificationPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/notification/DefaultNotificationPreferenceManager.kt index c34d7bab422..06eb6d9d73d 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/notification/DefaultNotificationPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/notification/DefaultNotificationPreferenceManager.kt @@ -31,7 +31,7 @@ class DefaultNotificationPreferenceManager( private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO, private var scope: CoroutineScope = CoroutineScope(SupervisorJob()), preferenceChangeBroker: PreferenceChangeBroker, -) : NotificationPreferenceManager, PreferenceChangeSubscriber { +) : NotificationPreferenceManager, PreferenceChangeSubscriber { init { preferenceChangeBroker.subscribe(this) diff --git a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt index 41f999d6e3d..56024ab92cf 100644 --- a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt +++ b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt @@ -61,6 +61,7 @@ val preferencesModule = module { logger = get(), storagePersister = get(), storageEditor = get().createStorageEditor(), + preferenceChangeBroker = get(), ) } single { From 66f5c5b15ae321bc962dd0019a63fd2802fd26ed Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Fri, 1 May 2026 05:04:18 +0600 Subject: [PATCH 11/15] feat: support scoped preference change handling in DefaultPrivacySettingsPreferenceManager --- .../privacy/PrivacySettingsPreferenceManager.kt | 15 +++++++++++++-- .../DefaultPrivacySettingsPreferenceManager.kt | 16 +++++++++++++++- .../java/com/fsck/k9/preferences/KoinModule.kt | 1 + 3 files changed, 29 insertions(+), 3 deletions(-) diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/PrivacySettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/PrivacySettingsPreferenceManager.kt index 60e3fafe561..ec9791f460a 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/PrivacySettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/PrivacySettingsPreferenceManager.kt @@ -2,7 +2,18 @@ package net.thunderbird.core.preference.privacy import net.thunderbird.core.preference.PreferenceManager -const val KEY_HIDE_TIME_ZONE = "hideTimeZone" -const val KEY_HIDE_USER_AGENT = "hideUserAgent" +enum class PrivacySettingKey(val value: String) { + + HideTimeZone("hideTimeZone"), + HideUserAgent("hideUserAgent"), + ; + + companion object { + + fun isValid(value: String): Boolean { + return entries.any { it.value == value } + } + } +} interface PrivacySettingsPreferenceManager : PreferenceManager diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/DefaultPrivacySettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/DefaultPrivacySettingsPreferenceManager.kt index 51bbcd0c568..2e4d6131339 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/DefaultPrivacySettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/DefaultPrivacySettingsPreferenceManager.kt @@ -11,6 +11,9 @@ import kotlinx.coroutines.launch import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock import net.thunderbird.core.logging.Logger +import net.thunderbird.core.preference.PreferenceChangeBroker +import net.thunderbird.core.preference.PreferenceChangeSubscriber +import net.thunderbird.core.preference.PreferenceScope import net.thunderbird.core.preference.storage.Storage import net.thunderbird.core.preference.storage.StorageEditor import net.thunderbird.core.preference.storage.StoragePersister @@ -23,7 +26,12 @@ class DefaultPrivacySettingsPreferenceManager( private val storageEditor: StorageEditor, private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO, private var scope: CoroutineScope = CoroutineScope(SupervisorJob()), -) : PrivacySettingsPreferenceManager { + preferenceChangeBroker: PreferenceChangeBroker, +) : PrivacySettingsPreferenceManager, PreferenceChangeSubscriber { + + init { + preferenceChangeBroker.subscribe(this) + } private val configState: MutableStateFlow = MutableStateFlow(value = loadConfig()) private val mutex = Mutex() private val storage: Storage @@ -61,4 +69,10 @@ class DefaultPrivacySettingsPreferenceManager( } } } + + override fun receive(scope: PreferenceScope) { + if(scope == PreferenceScope.ALL || scope == PreferenceScope.PRIVACY) { + configState.update { loadConfig() } + } + } } diff --git a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt index 56024ab92cf..a7ae38c22f9 100644 --- a/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt +++ b/legacy/core/src/main/java/com/fsck/k9/preferences/KoinModule.kt @@ -54,6 +54,7 @@ val preferencesModule = module { logger = get(), storagePersister = get(), storageEditor = get().createStorageEditor(), + preferenceChangeBroker = get(), ) } single { From a4457d4da7b2b8f5af54e7c65c6b8dfd6ec5e841 Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Fri, 1 May 2026 07:31:41 +0600 Subject: [PATCH 12/15] refactor: replace preference key constants with sealed enum-based values to group preference keys --- .../NetworkSettingsPreferenceManager.kt | 7 --- ...faultDebuggingSettingsPreferenceManager.kt | 14 ++--- ...ultDisplayCoreSettingsPreferenceManager.kt | 24 +++---- ...ltDisplayInboxSettingsPreferenceManager.kt | 24 +++---- ...ultDisplayMiscSettingsPreferenceManager.kt | 8 +-- ...tDisplayVisualSettingsPreferenceManager.kt | 43 +++++++------ .../DefaultMessageListPreferencesManager.kt | 55 ++++++++++------ ...ultInteractionSettingsPreferenceManager.kt | 63 ++++++++++++------- ...DefaultNetworkSettingsPreferenceManager.kt | 9 ++- .../DefaultNotificationPreferenceManager.kt | 2 +- ...DefaultPrivacySettingsPreferenceManager.kt | 10 +-- 11 files changed, 147 insertions(+), 112 deletions(-) diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/network/NetworkSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/network/NetworkSettingsPreferenceManager.kt index 8cc480219c8..b9eec8e8dfb 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/network/NetworkSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/network/NetworkSettingsPreferenceManager.kt @@ -8,11 +8,4 @@ enum class NetworkSettingKey(val value: String) { ; } - companion object { - - fun isValid(value: String): Boolean { - return entries.any { it.value == value } - } - } -} interface NetworkSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DefaultDebuggingSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DefaultDebuggingSettingsPreferenceManager.kt index 309c544b0f8..ba22abf2590 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DefaultDebuggingSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DefaultDebuggingSettingsPreferenceManager.kt @@ -53,15 +53,15 @@ class DefaultDebuggingSettingsPreferenceManager( private fun loadConfig(): DebuggingSettings = DebuggingSettings( isDebugLoggingEnabled = storage.getBoolean( - KEY_ENABLE_DEBUG_LOGGING, + DebugSettingKey.EnableDebugLogging.value, platformConfigProvider.isDebug, ), isSyncLoggingEnabled = storage.getBoolean( - KEY_ENABLE_SYNC_DEBUG_LOGGING, + DebugSettingKey.EnableSyncDebugLogging.value, DEBUGGING_SETTINGS_DEFAULT_IS_SYNC_LOGGING_ENABLED, ), isSensitiveLoggingEnabled = storage.getBoolean( - key = KEY_ENABLE_SENSITIVE_LOGGING, + key = DebugSettingKey.EnableSensitiveLogging.value, defValue = DEBUGGING_SETTINGS_DEFAULT_SENSITIVE_LOGGING_ENABLED, ), ).also(::updateDebugLogLevel) @@ -70,9 +70,9 @@ class DefaultDebuggingSettingsPreferenceManager( logger.debug(TAG) { "writeConfig() called with: config = $config" } scope.launch(ioDispatcher) { mutex.withLock { - storageEditor.putBoolean(KEY_ENABLE_DEBUG_LOGGING, config.isDebugLoggingEnabled) - storageEditor.putBoolean(KEY_ENABLE_SYNC_DEBUG_LOGGING, config.isSyncLoggingEnabled) - storageEditor.putBoolean(KEY_ENABLE_SENSITIVE_LOGGING, config.isSensitiveLoggingEnabled) + storageEditor.putBoolean(DebugSettingKey.EnableDebugLogging.value, config.isDebugLoggingEnabled) + storageEditor.putBoolean(DebugSettingKey.EnableSyncDebugLogging.value, config.isSyncLoggingEnabled) + storageEditor.putBoolean(DebugSettingKey.EnableSensitiveLogging.value, config.isSensitiveLoggingEnabled) storageEditor.commit().also { commited -> logger.verbose(TAG) { "writeConfig: storageEditor.commit() resulted in: $commited" } } @@ -89,7 +89,7 @@ class DefaultDebuggingSettingsPreferenceManager( } override fun receive(scope: PreferenceScope) { - if(scope == PreferenceScope.ALL || scope == PreferenceScope.DEBUGGING) { + if (scope == PreferenceScope.ALL || scope == PreferenceScope.DEBUGGING) { configState.update { loadConfig() } } } diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DefaultDisplayCoreSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DefaultDisplayCoreSettingsPreferenceManager.kt index 12fcc6f7a0e..47843bfcc7f 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DefaultDisplayCoreSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DefaultDisplayCoreSettingsPreferenceManager.kt @@ -51,24 +51,24 @@ class DefaultDisplayCoreSettingsPreferenceManager( private fun loadConfig(): DisplayCoreSettings = DisplayCoreSettings( fixedMessageViewTheme = storage.getBoolean( - KEY_FIXED_MESSAGE_VIEW_THEME, + DisplayCoreSettingKey.FixedMessageViewTheme.value, DISPLAY_SETTINGS_DEFAULT_FIXED_MESSAGE_VIEW_THEME, ), - appTheme = storage.getEnumOrDefault(KEY_THEME, DISPLAY_SETTINGS_DEFAULT_APP_THEME), + appTheme = storage.getEnumOrDefault(DisplayCoreSettingKey.Theme.value, DISPLAY_SETTINGS_DEFAULT_APP_THEME), messageViewTheme = storage.getEnumOrDefault( - KEY_MESSAGE_VIEW_THEME, + DisplayCoreSettingKey.MessageViewTheme.value, DISPLAY_SETTINGS_DEFAULT_MESSAGE_VIEW_THEME, ), messageComposeTheme = storage.getEnumOrDefault( - KEY_MESSAGE_COMPOSE_THEME, + DisplayCoreSettingKey.MessageComposeTheme.value, DISPLAY_SETTINGS_DEFAULT_MESSAGE_COMPOSE_THEME, ), appLanguage = storage.getStringOrDefault( - KEY_APP_LANGUAGE, + DisplayCoreSettingKey.AppLanguage.value, DISPLAY_SETTINGS_DEFAULT_APP_LANGUAGE, ), splitViewMode = storage.getEnumOrDefault( - KEY_SPLIT_VIEW_MODE, + DisplayCoreSettingKey.SplitViewMode.value, DISPLAY_SETTINGS_DEFAULT_SPLIT_VIEW_MODE, ), ) @@ -77,18 +77,18 @@ class DefaultDisplayCoreSettingsPreferenceManager( logger.debug(TAG) { "writeConfig() called with: config = $config" } scope.launch(ioDispatcher) { mutex.withLock { - storageEditor.putEnum(KEY_THEME, config.appTheme) - storageEditor.putEnum(KEY_MESSAGE_VIEW_THEME, config.messageViewTheme) + storageEditor.putEnum(DisplayCoreSettingKey.Theme.value, config.appTheme) + storageEditor.putEnum(DisplayCoreSettingKey.MessageViewTheme.value, config.messageViewTheme) storageEditor.putEnum( - KEY_MESSAGE_COMPOSE_THEME, + DisplayCoreSettingKey.MessageComposeTheme.value, config.messageComposeTheme, ) storageEditor.putBoolean( - KEY_FIXED_MESSAGE_VIEW_THEME, + DisplayCoreSettingKey.FixedMessageViewTheme.value, config.fixedMessageViewTheme, ) - storageEditor.putString(KEY_APP_LANGUAGE, config.appLanguage) - storageEditor.putEnum(KEY_SPLIT_VIEW_MODE, config.splitViewMode) + storageEditor.putString(DisplayCoreSettingKey.AppLanguage.value, config.appLanguage) + storageEditor.putEnum(DisplayCoreSettingKey.SplitViewMode.value, config.splitViewMode) storageEditor.commit().also { commited -> logger.verbose(TAG) { "writeConfig: storageEditor.commit() resulted in: $commited" } } diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DefaultDisplayInboxSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DefaultDisplayInboxSettingsPreferenceManager.kt index 143eafac68f..4c76ecedc11 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DefaultDisplayInboxSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DefaultDisplayInboxSettingsPreferenceManager.kt @@ -49,27 +49,27 @@ class DefaultDisplayInboxSettingsPreferenceManager( private fun loadConfig(): DisplayInboxSettings = DisplayInboxSettings( isShowUnifiedInbox = storage.getBoolean( - KEY_SHOW_UNIFIED_INBOX, + DisplayInboxSettingKey.ShowUnifiedInbox.value, DISPLAY_SETTINGS_DEFAULT_IS_SHOW_UNIFIED_INBOX, ), isShowComposeButtonOnMessageList = storage.getBoolean( - KEY_SHOW_COMPOSE_BUTTON_ON_MESSAGE_LIST, + DisplayInboxSettingKey.ShowComposeButtonOnMessageList.value, DISPLAY_SETTINGS_DEFAULT_IS_SHOW_COMPOSE_BUTTON_ON_MESSAGE_LIST, ), isThreadedViewEnabled = storage.getBoolean( - KEY_THREAD_VIEW_ENABLED, + DisplayInboxSettingKey.ThreadViewEnabled.value, DISPLAY_SETTINGS_DEFAULT_IS_THREAD_VIEW_ENABLED, ), isShowStarredCount = storage.getBoolean( - KEY_SHOW_STAR_COUNT, + DisplayInboxSettingKey.ShowStarCount.value, DISPLAY_SETTINGS_DEFAULT_IS_SHOW_STAR_COUNT, ), isShowMessageListStars = storage.getBoolean( - KEY_SHOW_MESSAGE_LIST_STARS, + DisplayInboxSettingKey.ShowMessageListStars.value, DISPLAY_SETTINGS_DEFAULT_IS_SHOW_MESSAGE_LIST_STAR, ), isMessageListSenderAboveSubject = storage.getBoolean( - KEY_MESSAGE_LIST_SENDER_ABOVE_SUBJECT, + DisplayInboxSettingKey.MessageListSenderAboveSubject.value, DISPLAY_SETTINGS_DEFAULT_IS_MESSAGE_LIST_SENDER_ABOVE_SUBJECT, ), ) @@ -79,23 +79,23 @@ class DefaultDisplayInboxSettingsPreferenceManager( scope.launch(ioDispatcher) { mutex.withLock { storageEditor.putBoolean( - KEY_MESSAGE_LIST_SENDER_ABOVE_SUBJECT, + DisplayInboxSettingKey.MessageListSenderAboveSubject.value, config.isMessageListSenderAboveSubject, ) storageEditor.putBoolean( - KEY_SHOW_MESSAGE_LIST_STARS, + DisplayInboxSettingKey.ShowMessageListStars.value, config.isShowMessageListStars, ) storageEditor.putBoolean( - KEY_SHOW_COMPOSE_BUTTON_ON_MESSAGE_LIST, + DisplayInboxSettingKey.ShowComposeButtonOnMessageList.value, config.isShowComposeButtonOnMessageList, ) storageEditor.putBoolean( - KEY_THREAD_VIEW_ENABLED, + DisplayInboxSettingKey.ThreadViewEnabled.value, config.isThreadedViewEnabled, ) - storageEditor.putBoolean(KEY_SHOW_UNIFIED_INBOX, config.isShowUnifiedInbox) - storageEditor.putBoolean(KEY_SHOW_STAR_COUNT, config.isShowStarredCount) + storageEditor.putBoolean(DisplayInboxSettingKey.ShowUnifiedInbox.value, config.isShowUnifiedInbox) + storageEditor.putBoolean(DisplayInboxSettingKey.ShowStarCount.value, config.isShowStarredCount) storageEditor.commit().also { commited -> logger.verbose(TAG) { "writeConfig: storageEditor.commit() resulted in: $commited" } } diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DefaultDisplayMiscSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DefaultDisplayMiscSettingsPreferenceManager.kt index 96936f5cd5c..cb2a42a3a1f 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DefaultDisplayMiscSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DefaultDisplayMiscSettingsPreferenceManager.kt @@ -48,11 +48,11 @@ class DefaultDisplayMiscSettingsPreferenceManager( private fun loadConfig(): DisplayMiscSettings = DisplayMiscSettings( showRecentChanges = storage.getBoolean( - KEY_SHOW_RECENT_CHANGES, + DisplayMiscSettingKey.ShowRecentChanges.value, DISPLAY_SETTINGS_DEFAULT_SHOW_RECENT_CHANGES, ), shouldShowSetupArchiveFolderDialog = storage.getBoolean( - KEY_SHOULD_SHOW_SETUP_ARCHIVE_FOLDER_DIALOG, + DisplayMiscSettingKey.ShouldShowSetupArchiveFolderDialog.value, DISPLAY_SETTINGS_DEFAULT_SHOULD_SHOW_SETUP_ARCHIVE_FOLDER_DIALOG, ), ) @@ -62,10 +62,10 @@ class DefaultDisplayMiscSettingsPreferenceManager( scope.launch(ioDispatcher) { mutex.withLock { storageEditor.putBoolean( - KEY_SHOULD_SHOW_SETUP_ARCHIVE_FOLDER_DIALOG, + DisplayMiscSettingKey.ShouldShowSetupArchiveFolderDialog.value, config.shouldShowSetupArchiveFolderDialog, ) - storageEditor.putBoolean(KEY_SHOW_RECENT_CHANGES, config.showRecentChanges) + storageEditor.putBoolean(DisplayMiscSettingKey.ShowRecentChanges.value, config.showRecentChanges) storageEditor.commit().also { commited -> logger.verbose(TAG) { "writeConfig: storageEditor.commit() resulted in: $commited" } } diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DefaultDisplayVisualSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DefaultDisplayVisualSettingsPreferenceManager.kt index 96336f02a43..6b361a63994 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DefaultDisplayVisualSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DefaultDisplayVisualSettingsPreferenceManager.kt @@ -60,43 +60,43 @@ class DefaultDisplayVisualSettingsPreferenceManager( private fun loadConfig(): DisplayVisualSettings = DisplayVisualSettings( isUseMessageViewFixedWidthFont = storage.getBoolean( - KEY_MESSAGE_VIEW_FIXED_WIDTH_FONT, + DisplayVisualSettingKey.MessageViewFixedWidthFont.value, DISPLAY_SETTINGS_DEFAULT_IS_USE_MESSAGE_VIEW_FIXED_WIDTH_FONT, ), isAutoFitWidth = storage.getBoolean( - KEY_AUTO_FIT_WIDTH, + DisplayVisualSettingKey.AutoFitWidth.value, DISPLAY_SETTINGS_DEFAULT_IS_AUTO_FIT_WIDTH, ), isShowAnimations = storage.getBoolean( - KEY_ANIMATION, + DisplayVisualSettingKey.Animation.value, DISPLAY_SETTINGS_DEFAULT_IS_SHOW_ANIMATION, ), bodyContentType = storage.getEnumOrDefault( - KEY_MESSAGE_VIEW_BODY_CONTENT_TYPE, + DisplayVisualSettingKey.MessageViewBodyContentType.value, DISPLAY_SETTINGS_DEFAULT_BODY_CONTENT_TYPE, ), drawerExpandAllFolder = storage.getBoolean( - KEY_DRAWER_EXPAND_ALL_FOLDER, + DisplayVisualSettingKey.DrawerExpandAllFolder.value, DISPLAY_SETTINGS_DEFAULT_DRAWER_EXPAND_ALL_FOLDER, ), isMessageViewArchiveActionVisible = storage.getBoolean( - KEY_MESSAGE_VIEW_ARCHIVE_ACTION_VISIBLE, + DisplayVisualSettingKey.MessageViewArchiveActionVisible.value, DISPLAY_SETTINGS_DEFAULT_MESSAGE_VIEW_ARCHIVE_ACTION_VISIBLE, ), isMessageViewDeleteActionVisible = storage.getBoolean( - KEY_MESSAGE_VIEW_DELETE_ACTION_VISIBLE, + DisplayVisualSettingKey.MessageViewDeleteActionVisible.value, DISPLAY_SETTINGS_DEFAULT_MESSAGE_VIEW_DELETE_ACTION_VISIBLE, ), isMessageViewMoveActionVisible = storage.getBoolean( - KEY_MESSAGE_VIEW_MOVE_ACTION_VISIBLE, + DisplayVisualSettingKey.MessageViewMoveActionVisible.value, DISPLAY_SETTINGS_DEFAULT_MESSAGE_VIEW_MOVE_ACTION_VISIBLE, ), isMessageViewCopyActionVisible = storage.getBoolean( - KEY_MESSAGE_VIEW_COPY_ACTION_VISIBLE, + DisplayVisualSettingKey.MessageViewCopyActionVisible.value, DISPLAY_SETTINGS_DEFAULT_MESSAGE_VIEW_COPY_ACTION_VISIBLE, ), isMessageViewSpamActionVisible = storage.getBoolean( - KEY_MESSAGE_VIEW_SPAM_ACTION_VISIBLE, + DisplayVisualSettingKey.MessageViewSpamActionVisible.value, DISPLAY_SETTINGS_DEFAULT_MESSAGE_VIEW_SPAM_ACTION_VISIBLE, ), ) @@ -105,33 +105,36 @@ class DefaultDisplayVisualSettingsPreferenceManager( logger.debug(TAG) { "writeConfig() called with: config = $config" } scope.launch(ioDispatcher) { mutex.withLock { - storageEditor.putBoolean(KEY_ANIMATION, config.isShowAnimations) + storageEditor.putBoolean(DisplayVisualSettingKey.Animation.value, config.isShowAnimations) storageEditor.putBoolean( - KEY_MESSAGE_VIEW_FIXED_WIDTH_FONT, + DisplayVisualSettingKey.MessageViewFixedWidthFont.value, config.isUseMessageViewFixedWidthFont, ) - storageEditor.putBoolean(KEY_AUTO_FIT_WIDTH, config.isAutoFitWidth) - storageEditor.putEnum(KEY_MESSAGE_VIEW_BODY_CONTENT_TYPE, config.bodyContentType) - storageEditor.putBoolean(KEY_DRAWER_EXPAND_ALL_FOLDER, config.drawerExpandAllFolder) + storageEditor.putBoolean(DisplayVisualSettingKey.AutoFitWidth.value, config.isAutoFitWidth) + storageEditor.putEnum(DisplayVisualSettingKey.MessageViewBodyContentType.value, config.bodyContentType) + storageEditor.putBoolean( + DisplayVisualSettingKey.DrawerExpandAllFolder.value, + config.drawerExpandAllFolder, + ) messageListPreferences.save(config.messageListSettings) storageEditor.putBoolean( - KEY_MESSAGE_VIEW_ARCHIVE_ACTION_VISIBLE, + DisplayVisualSettingKey.MessageViewArchiveActionVisible.value, config.isMessageViewArchiveActionVisible, ) storageEditor.putBoolean( - KEY_MESSAGE_VIEW_DELETE_ACTION_VISIBLE, + DisplayVisualSettingKey.MessageViewDeleteActionVisible.value, config.isMessageViewDeleteActionVisible, ) storageEditor.putBoolean( - KEY_MESSAGE_VIEW_MOVE_ACTION_VISIBLE, + DisplayVisualSettingKey.MessageViewMoveActionVisible.value, config.isMessageViewMoveActionVisible, ) storageEditor.putBoolean( - KEY_MESSAGE_VIEW_COPY_ACTION_VISIBLE, + DisplayVisualSettingKey.MessageViewCopyActionVisible.value, config.isMessageViewCopyActionVisible, ) storageEditor.putBoolean( - KEY_MESSAGE_VIEW_SPAM_ACTION_VISIBLE, + DisplayVisualSettingKey.MessageViewSpamActionVisible.value, config.isMessageViewSpamActionVisible, ) storageEditor.commit().also { commited -> diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/DefaultMessageListPreferencesManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/DefaultMessageListPreferencesManager.kt index 9f0f950c793..e554a704903 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/DefaultMessageListPreferencesManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/DefaultMessageListPreferencesManager.kt @@ -33,58 +33,73 @@ class DefaultMessageListPreferencesManager( private fun loadPreferences(): DisplayMessageListSettings = DisplayMessageListSettings( isColorizeMissingContactPictures = storage.getBoolean( - KEY_COLORIZE_MISSING_CONTACT_PICTURE, + DisplayMessageListSettingKey.ColorizeMissingContactPicture.value, MESSAGE_LIST_SETTINGS_DEFAULT_IS_COLORIZE_MISSING_CONTACT_PICTURE, ), isChangeContactNameColor = storage.getBoolean( - KEY_CHANGE_REGISTERED_NAME_COLOR, + DisplayMessageListSettingKey.ChangeRegisteredNameColor.value, MESSAGE_LIST_SETTINGS_DEFAULT_IS_CHANGE_CONTACT_NAME_COLOR, ), isUseBackgroundAsUnreadIndicator = storage.getBoolean( - KEY_USE_BACKGROUND_AS_UNREAD_INDICATOR, + DisplayMessageListSettingKey.UseBackgroundAsUnreadIndicator.value, MESSAGE_LIST_SETTINGS_DEFAULT_IS_USE_BACKGROUND_AS_INDICATOR, ), isShowCorrespondentNames = storage.getBoolean( - KEY_SHOW_CORRESPONDENT_NAMES, + DisplayMessageListSettingKey.ShowCorrespondentNames.value, MESSAGE_LIST_SETTINGS_DEFAULT_IS_SHOW_CORRESPONDENT_NAMES, ), isShowContactName = storage.getBoolean( - KEY_SHOW_CONTACT_NAME, + DisplayMessageListSettingKey.ShowContactName.value, MESSAGE_LIST_SETTINGS_DEFAULT_IS_SHOW_CONTACT_NAME, ), isShowContactPicture = storage.getBoolean( - KEY_SHOW_CONTACT_PICTURE, + DisplayMessageListSettingKey.ShowContactPicture.value, MESSAGE_LIST_SETTINGS_DEFAULT_IS_SHOW_CONTACT_PICTURE, ), previewLines = storage.getInt( - KEY_MESSAGE_LIST_VIEW_PREVIEW_LINES, + DisplayMessageListSettingKey.MessageListPreviewLines.value, MESSAGE_LIST_SETTINGS_DEFAULT_PREVIEW_LINES, ), uiDensity = storage.getEnumOrDefault( - KEY_MESSAGE_LIST_VIEW_DENSITY, + DisplayMessageListSettingKey.MessageListDensity.value, MESSAGE_LIST_SETTINGS_DEFAULT_UI_DENSITY, ), contactNameColor = storage.getInt( - KEY_REGISTERED_NAME_COLOR, + DisplayMessageListSettingKey.RegisteredNameColor.value, DISPLAY_SETTINGS_DEFAULT_CONTACT_NAME_COLOR, ), dateTimeFormat = storage.getEnumOrDefault( - KEY_MESSAGE_LIST_DATE_TIME_FORMAT, + DisplayMessageListSettingKey.MessageListDateTimeFormat.value, MESSAGE_LIST_SETTINGS_DEFAULT_DATE_TIME_FORMAT, ), ) private fun write(preferences: DisplayMessageListSettings) { - storageEditor.putBoolean(KEY_CHANGE_REGISTERED_NAME_COLOR, preferences.isChangeContactNameColor) - storageEditor.putBoolean(KEY_COLORIZE_MISSING_CONTACT_PICTURE, preferences.isColorizeMissingContactPictures) - storageEditor.putBoolean(KEY_SHOW_CONTACT_PICTURE, preferences.isShowContactPicture) - storageEditor.putBoolean(KEY_USE_BACKGROUND_AS_UNREAD_INDICATOR, preferences.isUseBackgroundAsUnreadIndicator) - storageEditor.putBoolean(KEY_SHOW_CONTACT_NAME, preferences.isShowContactName) - storageEditor.putBoolean(KEY_SHOW_CORRESPONDENT_NAMES, preferences.isShowCorrespondentNames) - storageEditor.putInt(KEY_MESSAGE_LIST_VIEW_PREVIEW_LINES, preferences.previewLines) - storageEditor.putInt(KEY_REGISTERED_NAME_COLOR, preferences.contactNameColor) - storageEditor.putEnum(KEY_MESSAGE_LIST_VIEW_DENSITY, preferences.uiDensity) - storageEditor.putEnum(KEY_MESSAGE_LIST_DATE_TIME_FORMAT, preferences.dateTimeFormat) + storageEditor.putBoolean( + DisplayMessageListSettingKey.ChangeRegisteredNameColor.value, + preferences.isChangeContactNameColor, + ) + storageEditor.putBoolean( + DisplayMessageListSettingKey.ColorizeMissingContactPicture.value, + preferences.isColorizeMissingContactPictures, + ) + storageEditor.putBoolean( + DisplayMessageListSettingKey.ShowContactPicture.value, + preferences.isShowContactPicture, + ) + storageEditor.putBoolean( + DisplayMessageListSettingKey.UseBackgroundAsUnreadIndicator.value, + preferences.isUseBackgroundAsUnreadIndicator, + ) + storageEditor.putBoolean(DisplayMessageListSettingKey.ShowContactName.value, preferences.isShowContactName) + storageEditor.putBoolean( + DisplayMessageListSettingKey.ShowCorrespondentNames.value, + preferences.isShowCorrespondentNames, + ) + storageEditor.putInt(DisplayMessageListSettingKey.MessageListPreviewLines.value, preferences.previewLines) + storageEditor.putInt(DisplayMessageListSettingKey.RegisteredNameColor.value, preferences.contactNameColor) + storageEditor.putEnum(DisplayMessageListSettingKey.MessageListDensity.value, preferences.uiDensity) + storageEditor.putEnum(DisplayMessageListSettingKey.MessageListDateTimeFormat.value, preferences.dateTimeFormat) storageEditor.commit().also { commited -> logger.verbose(TAG) { "writeConfig: storageEditor.commit() resulted in: $commited" } } diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/DefaultInteractionSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/DefaultInteractionSettingsPreferenceManager.kt index 0ea48daae36..16114e911e2 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/DefaultInteractionSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/DefaultInteractionSettingsPreferenceManager.kt @@ -52,11 +52,11 @@ class DefaultInteractionSettingsPreferenceManager( private fun loadConfig(): InteractionSettings = InteractionSettings( useVolumeKeysForNavigation = storage.getBoolean( - KEY_USE_VOLUME_KEYS_FOR_NAVIGATION, + InteractionSettingKey.UseVolumeKeysForNavigation.value, INTERACTION_SETTINGS_DEFAULT_USE_VOLUME_KEYS_NAVIGATION, ), messageViewPostRemoveNavigation = storage.getStringOrDefault( - KEY_MESSAGE_VIEW_POST_DELETE_ACTION, + InteractionSettingKey.MessageViewPostDeleteAction.value, INTERACTION_SETTINGS_DEFAULT_MESSAGE_VIEW_POST_REMOVE_NAVIGATION, ), messageViewPostMarkAsUnreadNavigation = storage.getEnumOrDefault( @@ -65,30 +65,36 @@ class DefaultInteractionSettingsPreferenceManager( ), swipeActions = SwipeActions( leftAction = storage.getEnumOrDefault( - key = KEY_SWIPE_ACTION_LEFT, + key = InteractionSettingKey.SwipeActionLeft.value, default = INTERACTION_SETTINGS_DEFAULT_SWIPE_ACTION.leftAction, ), rightAction = storage.getEnumOrDefault( - key = KEY_SWIPE_ACTION_RIGHT, + key = InteractionSettingKey.SwipeActionRight.value, default = INTERACTION_SETTINGS_DEFAULT_SWIPE_ACTION.rightAction, ), ), - isConfirmDelete = storage.getBoolean(KEY_CONFIRM_DELETE, INTERACTION_SETTINGS_DEFAULT_CONFIRM_DELETE), + isConfirmDelete = storage.getBoolean( + InteractionSettingKey.ConfirmDelete.value, + INTERACTION_SETTINGS_DEFAULT_CONFIRM_DELETE, + ), isConfirmDeleteStarred = storage.getBoolean( - KEY_CONFIRM_DELETE_STARRED, + InteractionSettingKey.ConfirmDeleteStarred.value, INTERACTION_SETTINGS_DEFAULT_CONFIRM_DELETE_STARRED, ), isConfirmDeleteFromNotification = storage.getBoolean( - KEY_CONFIRM_DELETE_FROM_NOTIFICATION, + InteractionSettingKey.ConfirmDeleteFromNotification.value, INTERACTION_SETTINGS_DEFAULT_CONFIRM_DELETE_FROM_NOTIFICATION, ), - isConfirmSpam = storage.getBoolean(KEY_CONFIRM_SPAM, INTERACTION_SETTINGS_DEFAULT_CONFIRM_SPAM), + isConfirmSpam = storage.getBoolean( + InteractionSettingKey.ConfirmSpam.value, + INTERACTION_SETTINGS_DEFAULT_CONFIRM_SPAM, + ), isConfirmDiscardMessage = storage.getBoolean( - KEY_CONFIRM_DISCARD_MESSAGE, + InteractionSettingKey.ConfirmDiscardMessage.value, INTERACTION_SETTINGS_DEFAULT_CONFIRM_DISCARD_MESSAGE, ), isConfirmMarkAllRead = storage.getBoolean( - KEY_CONFIRM_MARK_ALL_READ, + InteractionSettingKey.ConfirmMarkAllRead.value, INTERACTION_SETTINGS_DEFAULT_CONFIRM_MARK_ALL_READ, ), ) @@ -97,20 +103,35 @@ class DefaultInteractionSettingsPreferenceManager( logger.debug(TAG) { "writeConfig() called with: config = $config" } scope.launch(ioDispatcher) { mutex.withLock { - storageEditor.putBoolean(KEY_USE_VOLUME_KEYS_FOR_NAVIGATION, config.useVolumeKeysForNavigation) - storageEditor.putString(KEY_MESSAGE_VIEW_POST_DELETE_ACTION, config.messageViewPostRemoveNavigation) + storageEditor.putBoolean( + InteractionSettingKey.UseVolumeKeysForNavigation.value, + config.useVolumeKeysForNavigation, + ) + storageEditor.putString( + InteractionSettingKey.MessageViewPostDeleteAction.value, + config.messageViewPostRemoveNavigation, + ) storageEditor.putEnum( KEY_MESSAGE_VIEW_POST_MARK_AS_UNREAD_ACTION, config.messageViewPostMarkAsUnreadNavigation, ) - storageEditor.putEnum(KEY_SWIPE_ACTION_LEFT, config.swipeActions.leftAction) - storageEditor.putEnum(KEY_SWIPE_ACTION_RIGHT, config.swipeActions.rightAction) - storageEditor.putBoolean(KEY_CONFIRM_DELETE, config.isConfirmDelete) - storageEditor.putBoolean(KEY_CONFIRM_DISCARD_MESSAGE, config.isConfirmDiscardMessage) - storageEditor.putBoolean(KEY_CONFIRM_DELETE_STARRED, config.isConfirmDeleteStarred) - storageEditor.putBoolean(KEY_CONFIRM_SPAM, config.isConfirmSpam) - storageEditor.putBoolean(KEY_CONFIRM_DELETE_FROM_NOTIFICATION, config.isConfirmDeleteFromNotification) - storageEditor.putBoolean(KEY_CONFIRM_MARK_ALL_READ, config.isConfirmMarkAllRead) + storageEditor.putEnum(InteractionSettingKey.SwipeActionLeft.value, config.swipeActions.leftAction) + storageEditor.putEnum(InteractionSettingKey.SwipeActionRight.value, config.swipeActions.rightAction) + storageEditor.putBoolean(InteractionSettingKey.ConfirmDelete.value, config.isConfirmDelete) + storageEditor.putBoolean( + InteractionSettingKey.ConfirmDiscardMessage.value, + config.isConfirmDiscardMessage, + ) + storageEditor.putBoolean( + InteractionSettingKey.ConfirmDeleteStarred.value, + config.isConfirmDeleteStarred, + ) + storageEditor.putBoolean(InteractionSettingKey.ConfirmSpam.value, config.isConfirmSpam) + storageEditor.putBoolean( + InteractionSettingKey.ConfirmDeleteFromNotification.value, + config.isConfirmDeleteFromNotification, + ) + storageEditor.putBoolean(InteractionSettingKey.ConfirmMarkAllRead.value, config.isConfirmMarkAllRead) storageEditor.commit().also { commited -> logger.verbose(TAG) { "writeConfig: storageEditor.commit() resulted in: $commited" } } @@ -119,7 +140,7 @@ class DefaultInteractionSettingsPreferenceManager( } override fun receive(scope: PreferenceScope) { - if(scope == PreferenceScope.ALL || scope == PreferenceScope.INTERACTION) { + if (scope == PreferenceScope.ALL || scope == PreferenceScope.INTERACTION) { configState.update { loadConfig() } } } diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/network/DefaultNetworkSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/network/DefaultNetworkSettingsPreferenceManager.kt index 5a05821539a..473797f54ff 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/network/DefaultNetworkSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/network/DefaultNetworkSettingsPreferenceManager.kt @@ -49,14 +49,17 @@ class DefaultNetworkSettingsPreferenceManager( } private fun loadConfig(): NetworkSettings = NetworkSettings( - backgroundOps = storage.getEnumOrDefault(KEY_BG_OPS, NETWORK_SETTINGS_DEFAULT_BACKGROUND_OPS), + backgroundOps = storage.getEnumOrDefault( + NetworkSettingKey.BackgroundOperations.value, + NETWORK_SETTINGS_DEFAULT_BACKGROUND_OPS, + ), ) private fun writeConfig(config: NetworkSettings) { logger.debug(TAG) { "writeConfig() called with: config = $config" } scope.launch(ioDispatcher) { mutex.withLock { - storageEditor.putEnum(KEY_BG_OPS, config.backgroundOps) + storageEditor.putEnum(NetworkSettingKey.BackgroundOperations.value, config.backgroundOps) storageEditor.commit().also { commited -> logger.verbose(TAG) { "writeConfig: storageEditor.commit() resulted in: $commited" } } @@ -65,7 +68,7 @@ class DefaultNetworkSettingsPreferenceManager( } override fun receive(scope: PreferenceScope) { - if(scope == PreferenceScope.ALL || scope == PreferenceScope.NETWORK) { + if (scope == PreferenceScope.ALL || scope == PreferenceScope.NETWORK) { configState.update { loadConfig() } } } diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/notification/DefaultNotificationPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/notification/DefaultNotificationPreferenceManager.kt index 06eb6d9d73d..c34d7bab422 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/notification/DefaultNotificationPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/notification/DefaultNotificationPreferenceManager.kt @@ -31,7 +31,7 @@ class DefaultNotificationPreferenceManager( private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO, private var scope: CoroutineScope = CoroutineScope(SupervisorJob()), preferenceChangeBroker: PreferenceChangeBroker, -) : NotificationPreferenceManager, PreferenceChangeSubscriber { +) : NotificationPreferenceManager, PreferenceChangeSubscriber { init { preferenceChangeBroker.subscribe(this) diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/DefaultPrivacySettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/DefaultPrivacySettingsPreferenceManager.kt index 2e4d6131339..9dd126d910f 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/DefaultPrivacySettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/DefaultPrivacySettingsPreferenceManager.kt @@ -48,11 +48,11 @@ class DefaultPrivacySettingsPreferenceManager( private fun loadConfig(): PrivacySettings = PrivacySettings( isHideTimeZone = storage.getBoolean( - key = KEY_HIDE_TIME_ZONE, + key = PrivacySettingKey.HideTimeZone.value, defValue = PRIVACY_SETTINGS_DEFAULT_HIDE_TIME_ZONE, ), isHideUserAgent = storage.getBoolean( - key = KEY_HIDE_USER_AGENT, + key = PrivacySettingKey.HideUserAgent.value, defValue = PRIVACY_SETTINGS_DEFAULT_HIDE_USER_AGENT, ), ) @@ -61,8 +61,8 @@ class DefaultPrivacySettingsPreferenceManager( logger.debug(TAG) { "writeConfig() called with: config = $config" } scope.launch(ioDispatcher) { mutex.withLock { - storageEditor.putBoolean(KEY_HIDE_TIME_ZONE, config.isHideTimeZone) - storageEditor.putBoolean(KEY_HIDE_USER_AGENT, config.isHideUserAgent) + storageEditor.putBoolean(PrivacySettingKey.HideTimeZone.value, config.isHideTimeZone) + storageEditor.putBoolean(PrivacySettingKey.HideUserAgent.value, config.isHideUserAgent) storageEditor.commit().also { commited -> logger.verbose(TAG) { "writeConfig: storageEditor.commit() resulted in: $commited" } } @@ -71,7 +71,7 @@ class DefaultPrivacySettingsPreferenceManager( } override fun receive(scope: PreferenceScope) { - if(scope == PreferenceScope.ALL || scope == PreferenceScope.PRIVACY) { + if (scope == PreferenceScope.ALL || scope == PreferenceScope.PRIVACY) { configState.update { loadConfig() } } } From 5f1867a28a1a3e3c79d7a87e55a3c6dc4c607951 Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Fri, 1 May 2026 08:43:15 +0600 Subject: [PATCH 13/15] feat: add PreferenceScopeRegistry --- .../preference/PreferenceScopeRegistry.kt | 51 +++++++++++++++++++ .../DebuggingSettingsPreferenceManager.kt | 8 --- .../DisplayCoreSettingsPreferenceManager.kt | 8 --- .../DisplayInboxSettingsPreferenceManager.kt | 8 --- .../DisplayMiscSettingsPreferenceManager.kt | 8 --- .../DisplayVisualSettingsPreferenceManager.kt | 8 --- .../list/MessageListPreferencesManager.kt | 8 --- .../InteractionSettingsPreferenceManager.kt | 9 +--- .../NetworkSettingsPreferenceManager.kt | 2 - .../NotificationPreferenceManager.kt | 8 --- .../PrivacySettingsPreferenceManager.kt | 8 --- ...ultInteractionSettingsPreferenceManager.kt | 4 +- 12 files changed, 54 insertions(+), 76 deletions(-) create mode 100644 core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceScopeRegistry.kt diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceScopeRegistry.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceScopeRegistry.kt new file mode 100644 index 00000000000..e26e1c21592 --- /dev/null +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/PreferenceScopeRegistry.kt @@ -0,0 +1,51 @@ +package net.thunderbird.core.preference + +import net.thunderbird.core.preference.debugging.DebugSettingKey +import net.thunderbird.core.preference.display.coreSettings.DisplayCoreSettingKey +import net.thunderbird.core.preference.display.inboxSettings.DisplayInboxSettingKey +import net.thunderbird.core.preference.display.miscSettings.DisplayMiscSettingKey +import net.thunderbird.core.preference.display.visualSettings.DisplayVisualSettingKey +import net.thunderbird.core.preference.display.visualSettings.message.list.DisplayMessageListSettingKey +import net.thunderbird.core.preference.interaction.InteractionSettingKey +import net.thunderbird.core.preference.network.NetworkSettingKey +import net.thunderbird.core.preference.notification.NotificationSettingKey +import net.thunderbird.core.preference.privacy.PrivacySettingKey + +object PreferenceScopeRegistry { + + private val map: Map = buildMap { + + DebugSettingKey.entries.forEach { put(it.value, PreferenceScope.DEBUGGING) } + InteractionSettingKey.entries.forEach { put(it.value, PreferenceScope.INTERACTION) } + NetworkSettingKey.entries.forEach { put(it.value, PreferenceScope.NETWORK) } + NotificationSettingKey.entries.forEach { put(it.value, PreferenceScope.NOTIFICATION) } + PrivacySettingKey.entries.forEach { put(it.value, PreferenceScope.PRIVACY) } + + DisplayCoreSettingKey.entries.forEach { + put(it.value, PreferenceScope.DISPLAY_CORE) + } + + DisplayInboxSettingKey.entries.forEach { + put(it.value, PreferenceScope.DISPLAY_INBOX) + } + + DisplayMiscSettingKey.entries.forEach { + put(it.value, PreferenceScope.DISPLAY_MISC) + } + + DisplayVisualSettingKey.entries.forEach { + put(it.value, PreferenceScope.DISPLAY_VISUAL) + } + + DisplayMessageListSettingKey.entries.forEach { + put(it.value, PreferenceScope.DISPLAY_VISUAL_MESSAGE_LIST) + } + } + + fun getScope(key: String): PreferenceScope = + map[key] ?: PreferenceScope.ALL +} + +fun getPreferenceScope(changedKey: String): PreferenceScope { + return PreferenceScopeRegistry.getScope(changedKey) +} diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DebuggingSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DebuggingSettingsPreferenceManager.kt index 6a96f06b7cc..644f4850db4 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DebuggingSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/debugging/DebuggingSettingsPreferenceManager.kt @@ -7,14 +7,6 @@ enum class DebugSettingKey(val value: String) { EnableDebugLogging("enableDebugLogging"), EnableSyncDebugLogging("enableSyncDebugLogging"), EnableSensitiveLogging("enableSensitiveLogging"), - ; - - companion object { - - fun isValid(value: String): Boolean { - return entries.any { it.value == value } - } - } } interface DebuggingSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DisplayCoreSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DisplayCoreSettingsPreferenceManager.kt index c6655447abd..f8f49653142 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DisplayCoreSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/coreSettings/DisplayCoreSettingsPreferenceManager.kt @@ -10,14 +10,6 @@ enum class DisplayCoreSettingKey(val value: String) { AppLanguage("language"), SplitViewMode("splitViewMode"), Theme("theme"), - ; - - companion object { - - fun isValid(value: String): Boolean { - return entries.any { it.value == value } - } - } } interface DisplayCoreSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DisplayInboxSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DisplayInboxSettingsPreferenceManager.kt index c6bb73cd9d1..0c5b8479033 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DisplayInboxSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/inboxSettings/DisplayInboxSettingsPreferenceManager.kt @@ -10,14 +10,6 @@ enum class DisplayInboxSettingKey(val value: String) { ShowStarCount("showStarredCount"), ShowUnifiedInbox("showUnifiedInbox"), ThreadViewEnabled("isThreadedViewEnabled"), - ; - - companion object { - - fun isValid(value: String): Boolean { - return entries.any { it.value == value } - } - } } interface DisplayInboxSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DisplayMiscSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DisplayMiscSettingsPreferenceManager.kt index 1afa5a08190..7c76709fcff 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DisplayMiscSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/miscSettings/DisplayMiscSettingsPreferenceManager.kt @@ -6,14 +6,6 @@ enum class DisplayMiscSettingKey(val value: String) { ShowRecentChanges("showRecentChanges"), ShouldShowSetupArchiveFolderDialog("shouldShowSetupArchiveFolderDialog"), - ; - - companion object { - - fun isValid(value: String): Boolean { - return entries.any { it.value == value } - } - } } interface DisplayMiscSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DisplayVisualSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DisplayVisualSettingsPreferenceManager.kt index 9854eb9994c..7940863a1a7 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DisplayVisualSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/DisplayVisualSettingsPreferenceManager.kt @@ -14,14 +14,6 @@ enum class DisplayVisualSettingKey(val value: String) { MessageViewMoveActionVisible("messageViewMoveActionVisible"), MessageViewCopyActionVisible("messageViewCopyActionVisible"), MessageViewSpamActionVisible("messageViewSpamActionVisible"), - ; - - companion object { - - fun isValid(value: String): Boolean { - return entries.any { it.value == value } - } - } } interface DisplayVisualSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/MessageListPreferencesManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/MessageListPreferencesManager.kt index c31cf0c143a..eadae66c9a5 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/MessageListPreferencesManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/display/visualSettings/message/list/MessageListPreferencesManager.kt @@ -14,14 +14,6 @@ enum class DisplayMessageListSettingKey(val value: String) { MessageListDensity("messageListDensity"), RegisteredNameColor("registeredNameColor"), MessageListDateTimeFormat("messageListDateTimeFormat"), - ; - - companion object { - - fun isValid(value: String): Boolean { - return entries.any { it.value == value } - } - } } interface MessageListPreferencesManager : PreferenceManager diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/InteractionSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/InteractionSettingsPreferenceManager.kt index fa9fb37d97e..01ff41669d0 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/InteractionSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/InteractionSettingsPreferenceManager.kt @@ -14,14 +14,7 @@ enum class InteractionSettingKey(val value: String) { ConfirmSpam("confirmSpam"), ConfirmDeleteFromNotification("confirmDeleteFromNotification"), ConfirmMarkAllRead("confirmMarkAllRead"), - ; - - companion object { - - fun isValid(value: String): Boolean { - return entries.any { it.value == value } - } - } + MessageViewPostMarkAsRead("messageViewPostMarkAsReadAction"), } interface InteractionSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/network/NetworkSettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/network/NetworkSettingsPreferenceManager.kt index b9eec8e8dfb..50c90d0594d 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/network/NetworkSettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/network/NetworkSettingsPreferenceManager.kt @@ -3,9 +3,7 @@ package net.thunderbird.core.preference.network import net.thunderbird.core.preference.PreferenceManager enum class NetworkSettingKey(val value: String) { - BackgroundOperations("backgroundOperations"), - ; } interface NetworkSettingsPreferenceManager : PreferenceManager diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/notification/NotificationPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/notification/NotificationPreferenceManager.kt index 0ff4e99f37f..ca6fff5ba3e 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/notification/NotificationPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/notification/NotificationPreferenceManager.kt @@ -13,13 +13,5 @@ enum class NotificationSettingKey(val value: String) { IsSummaryDeleteActionEnabled("isSummaryDeleteActionEnabled"), NotificationQuickDeleteBehaviour("notificationQuickDelete"), LockScreenNotificationVisibility("lockScreenNotificationVisibility"), - ; - - companion object { - - fun isValid(value: String): Boolean { - return entries.any { it.value == value } - } - } } interface NotificationPreferenceManager : PreferenceManager diff --git a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/PrivacySettingsPreferenceManager.kt b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/PrivacySettingsPreferenceManager.kt index ec9791f460a..0d1c58816a6 100644 --- a/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/PrivacySettingsPreferenceManager.kt +++ b/core/preference/api/src/commonMain/kotlin/net/thunderbird/core/preference/privacy/PrivacySettingsPreferenceManager.kt @@ -6,14 +6,6 @@ enum class PrivacySettingKey(val value: String) { HideTimeZone("hideTimeZone"), HideUserAgent("hideUserAgent"), - ; - - companion object { - - fun isValid(value: String): Boolean { - return entries.any { it.value == value } - } - } } interface PrivacySettingsPreferenceManager : PreferenceManager diff --git a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/DefaultInteractionSettingsPreferenceManager.kt b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/DefaultInteractionSettingsPreferenceManager.kt index 16114e911e2..2c4c60510e4 100644 --- a/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/DefaultInteractionSettingsPreferenceManager.kt +++ b/core/preference/impl/src/commonMain/kotlin/net/thunderbird/core/preference/interaction/DefaultInteractionSettingsPreferenceManager.kt @@ -60,7 +60,7 @@ class DefaultInteractionSettingsPreferenceManager( INTERACTION_SETTINGS_DEFAULT_MESSAGE_VIEW_POST_REMOVE_NAVIGATION, ), messageViewPostMarkAsUnreadNavigation = storage.getEnumOrDefault( - KEY_MESSAGE_VIEW_POST_MARK_AS_UNREAD_ACTION, + InteractionSettingKey.MessageViewPostMarkAsRead.value, INTERACTION_SETTINGS_DEFAULT_MESSAGE_VIEW_POST_MARK_AS_UNREAD_NAVIGATION, ), swipeActions = SwipeActions( @@ -112,7 +112,7 @@ class DefaultInteractionSettingsPreferenceManager( config.messageViewPostRemoveNavigation, ) storageEditor.putEnum( - KEY_MESSAGE_VIEW_POST_MARK_AS_UNREAD_ACTION, + InteractionSettingKey.MessageViewPostMarkAsRead.value, config.messageViewPostMarkAsUnreadNavigation, ) storageEditor.putEnum(InteractionSettingKey.SwipeActionLeft.value, config.swipeActions.leftAction) From b2f05fc86e7a3c0454c0c2cb0b345fcda9208707 Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Fri, 1 May 2026 14:06:54 +0600 Subject: [PATCH 14/15] test: adjust BuildSwipeActionsTest to comply with InteractionSettingsPreferenceManager --- .../domain/usecase/BuildSwipeActionsTest.kt | 34 +++++++++++-------- 1 file changed, 19 insertions(+), 15 deletions(-) diff --git a/feature/mail/message/list/internal/src/test/kotlin/net/thunderbird/feature/mail/message/list/internal/domain/usecase/BuildSwipeActionsTest.kt b/feature/mail/message/list/internal/src/test/kotlin/net/thunderbird/feature/mail/message/list/internal/domain/usecase/BuildSwipeActionsTest.kt index f490dd0c09d..e3024a88a8e 100644 --- a/feature/mail/message/list/internal/src/test/kotlin/net/thunderbird/feature/mail/message/list/internal/domain/usecase/BuildSwipeActionsTest.kt +++ b/feature/mail/message/list/internal/src/test/kotlin/net/thunderbird/feature/mail/message/list/internal/domain/usecase/BuildSwipeActionsTest.kt @@ -21,8 +21,7 @@ import net.thunderbird.core.common.mail.Protocols import net.thunderbird.core.preference.GeneralSettings import net.thunderbird.core.preference.GeneralSettingsManager import net.thunderbird.core.preference.display.DisplaySettings -import net.thunderbird.core.preference.interaction.KEY_SWIPE_ACTION_LEFT -import net.thunderbird.core.preference.interaction.KEY_SWIPE_ACTION_RIGHT +import net.thunderbird.core.preference.interaction.InteractionSettingKey import net.thunderbird.core.preference.network.NetworkSettings import net.thunderbird.core.preference.notification.NotificationPreference import net.thunderbird.core.preference.privacy.PrivacySettings @@ -120,7 +119,7 @@ class BuildSwipeActionsTest { val testSubject = createTestSubject( accountsIds = ids, storageValues = mapOf( - KEY_SWIPE_ACTION_LEFT to SwipeAction.None, + InteractionSettingKey.SwipeActionLeft.value to SwipeAction.None, ), ) @@ -150,7 +149,7 @@ class BuildSwipeActionsTest { val testSubject = createTestSubject( accountsIds = ids, storageValues = mapOf( - KEY_SWIPE_ACTION_RIGHT to SwipeAction.Delete, + InteractionSettingKey.SwipeActionRight.value to SwipeAction.Delete, ), ) @@ -179,8 +178,8 @@ class BuildSwipeActionsTest { val testSubject = createTestSubject( accounts = listOf(FakeLegacyAccount(id = id, archiveFolderId = 123)), storageValues = mapOf( - KEY_SWIPE_ACTION_LEFT to SwipeAction.Archive, - KEY_SWIPE_ACTION_RIGHT to SwipeAction.Archive, + InteractionSettingKey.SwipeActionLeft.value to SwipeAction.Archive, + InteractionSettingKey.SwipeActionRight.value to SwipeAction.Archive, ), ) @@ -209,8 +208,8 @@ class BuildSwipeActionsTest { val testSubject = createTestSubject( accounts = listOf(FakeLegacyAccount(id = id, incomingServerType = Protocols.POP3)), storageValues = mapOf( - KEY_SWIPE_ACTION_LEFT to SwipeAction.Archive, - KEY_SWIPE_ACTION_RIGHT to SwipeAction.Archive, + InteractionSettingKey.SwipeActionLeft.value to SwipeAction.Archive, + InteractionSettingKey.SwipeActionRight.value to SwipeAction.Archive, ), ) @@ -247,8 +246,8 @@ class BuildSwipeActionsTest { ), accountsIds = ids, storageValues = mapOf( - KEY_SWIPE_ACTION_LEFT to SwipeAction.Archive, - KEY_SWIPE_ACTION_RIGHT to SwipeAction.Archive, + InteractionSettingKey.SwipeActionLeft.value to SwipeAction.Archive, + InteractionSettingKey.SwipeActionRight.value to SwipeAction.Archive, ), ) @@ -290,8 +289,8 @@ class BuildSwipeActionsTest { ), accounts = accounts, storageValues = mapOf( - KEY_SWIPE_ACTION_LEFT to SwipeAction.Archive, - KEY_SWIPE_ACTION_RIGHT to SwipeAction.Archive, + InteractionSettingKey.SwipeActionLeft.value to SwipeAction.Archive, + InteractionSettingKey.SwipeActionRight.value to SwipeAction.Archive, ), ) @@ -342,14 +341,19 @@ class BuildSwipeActionsTest { generalSettingsManager = FakeGeneralSettingsManager( initialGeneralSettings.let { settings -> if (storageValues.isNotEmpty() && - (KEY_SWIPE_ACTION_LEFT in storageValues || KEY_SWIPE_ACTION_RIGHT in storageValues) + ( + InteractionSettingKey.SwipeActionLeft.value in storageValues || + InteractionSettingKey.SwipeActionRight.value in storageValues + ) ) { val swipeActions = settings.interaction.swipeActions settings.copy( interaction = settings.interaction.copy( swipeActions = swipeActions.copy( - leftAction = storageValues[KEY_SWIPE_ACTION_LEFT] ?: swipeActions.leftAction, - rightAction = storageValues[KEY_SWIPE_ACTION_RIGHT] ?: swipeActions.rightAction, + leftAction = storageValues[InteractionSettingKey.SwipeActionLeft.value] + ?: swipeActions.leftAction, + rightAction = storageValues[InteractionSettingKey.SwipeActionRight.value] + ?: swipeActions.rightAction, ), ), ) From 0f1401d503f9ea2f07c145cbdc67650dd5b5af99 Mon Sep 17 00:00:00 2001 From: shamim-emon Date: Fri, 1 May 2026 14:19:09 +0600 Subject: [PATCH 15/15] test: introduce additional tests in DefaultPreferenceChangeBrokerTest to ensure correct behavior of the updated PreferenceChangeSubscriber --- .../DefaultPreferenceChangeBrokerTest.kt | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/core/preference/impl/src/commonTest/kotlin/net/thunderbird/core/preference/DefaultPreferenceChangeBrokerTest.kt b/core/preference/impl/src/commonTest/kotlin/net/thunderbird/core/preference/DefaultPreferenceChangeBrokerTest.kt index e75a1568e15..6884141005d 100644 --- a/core/preference/impl/src/commonTest/kotlin/net/thunderbird/core/preference/DefaultPreferenceChangeBrokerTest.kt +++ b/core/preference/impl/src/commonTest/kotlin/net/thunderbird/core/preference/DefaultPreferenceChangeBrokerTest.kt @@ -46,4 +46,59 @@ class DefaultPreferenceChangeBrokerTest { assertThat(received).isEqualTo(true) assertThat(receivedOther).isEqualTo(true) } + + @Test + fun `publish should notify subscribers with correct scope`() { + var receivedScope: PreferenceScope? = null + + val subscriber = PreferenceChangeSubscriber { scope -> + receivedScope = scope + } + + val broker = DefaultPreferenceChangeBroker(mutableSetOf(subscriber)) + + broker.publish(PreferenceScope.NOTIFICATION) + + assertThat(receivedScope).isEqualTo(PreferenceScope.NOTIFICATION) + } + + @Test + fun `subscribe should not duplicate subscriber`() { + val subscriber = PreferenceChangeSubscriber { } + val subscribers = mutableSetOf() + val broker = DefaultPreferenceChangeBroker(subscribers) + + broker.subscribe(subscriber) + broker.subscribe(subscriber) + + assertThat(subscribers.size).isEqualTo(1) + } + + @Test + fun `unsubscribe should not fail if subscriber not present`() { + val subscriber = PreferenceChangeSubscriber { } + val broker = DefaultPreferenceChangeBroker(mutableSetOf()) + + broker.unsubscribe(subscriber) + + assertThat(true).isEqualTo(true) + } + + @Test + fun `publish should handle subscriber removal during iteration`() { + val subscribers = mutableSetOf() + + lateinit var subscriber: PreferenceChangeSubscriber + subscriber = PreferenceChangeSubscriber { + subscribers.remove(subscriber) + } + + subscribers.add(subscriber) + + val broker = DefaultPreferenceChangeBroker(subscribers) + + broker.publish() + + assertThat(true).isEqualTo(true) + } }