SecurityAndPrivacyEvents -> SecurityAndPrivacyEvent

features/securityandprivacy/impl/src/main/kotlin/io/element/android/features/securityandprivacy/impl/root/SecurityAndPrivacyEvent.kt

@@ -8,16 +8,16 @@
 
 package io.element.android.features.securityandprivacy.impl.root
 
-sealed interface SecurityAndPrivacyEvents {
-    data object EditRoomAddress : SecurityAndPrivacyEvents
-    data object Save : SecurityAndPrivacyEvents
-    data object Exit : SecurityAndPrivacyEvents
-    data object DismissExitConfirmation : SecurityAndPrivacyEvents
-    data class ChangeRoomAccess(val roomAccess: SecurityAndPrivacyRoomAccess) : SecurityAndPrivacyEvents
-    data object ToggleEncryptionState : SecurityAndPrivacyEvents
-    data object CancelEnableEncryption : SecurityAndPrivacyEvents
-    data object ConfirmEnableEncryption : SecurityAndPrivacyEvents
-    data class ChangeHistoryVisibility(val historyVisibility: SecurityAndPrivacyHistoryVisibility) : SecurityAndPrivacyEvents
-    data object ToggleRoomVisibility : SecurityAndPrivacyEvents
-    data object DismissSaveError : SecurityAndPrivacyEvents
+sealed interface SecurityAndPrivacyEvent {
+    data object EditRoomAddress : SecurityAndPrivacyEvent
+    data object Save : SecurityAndPrivacyEvent
+    data object Exit : SecurityAndPrivacyEvent
+    data object DismissExitConfirmation : SecurityAndPrivacyEvent
+    data class ChangeRoomAccess(val roomAccess: SecurityAndPrivacyRoomAccess) : SecurityAndPrivacyEvent
+    data object ToggleEncryptionState : SecurityAndPrivacyEvent
+    data object CancelEnableEncryption : SecurityAndPrivacyEvent
+    data object ConfirmEnableEncryption : SecurityAndPrivacyEvent
+    data class ChangeHistoryVisibility(val historyVisibility: SecurityAndPrivacyHistoryVisibility) : SecurityAndPrivacyEvent
+    data object ToggleRoomVisibility : SecurityAndPrivacyEvent
+    data object DismissSaveError : SecurityAndPrivacyEvent
 }

features/securityandprivacy/impl/src/main/kotlin/io/element/android/features/securityandprivacy/impl/root/SecurityAndPrivacyPresenter.kt

@@ -108,9 +108,9 @@ class SecurityAndPrivacyPresenter(
         var showEnableEncryptionConfirmation by remember(savedSettings.isEncrypted) { mutableStateOf(false) }
         val permissions by room.securityAndPrivacyPermissionsAsState(syncUpdateFlow.value)
 
-        fun handleEvent(event: SecurityAndPrivacyEvents) {
+        fun handleEvent(event: SecurityAndPrivacyEvent) {
             when (event) {
-                SecurityAndPrivacyEvents.Save -> {
+                SecurityAndPrivacyEvent.Save -> {
                     coroutineScope.save(
                         saveAction = saveAction,
                         isVisibleInRoomDirectory = savedIsVisibleInRoomDirectory,
@@ -118,44 +118,44 @@ class SecurityAndPrivacyPresenter(
                         editedSettings = editedSettings
                     )
                 }
-                is SecurityAndPrivacyEvents.ChangeRoomAccess -> {
+                is SecurityAndPrivacyEvent.ChangeRoomAccess -> {
                     editedRoomAccess = event.roomAccess
                 }
-                is SecurityAndPrivacyEvents.ToggleEncryptionState -> {
+                is SecurityAndPrivacyEvent.ToggleEncryptionState -> {
                     if (editedIsEncrypted) {
                         editedIsEncrypted = false
                     } else {
                         showEnableEncryptionConfirmation = true
                     }
                 }
-                is SecurityAndPrivacyEvents.ChangeHistoryVisibility -> {
+                is SecurityAndPrivacyEvent.ChangeHistoryVisibility -> {
                     editedHistoryVisibility = event.historyVisibility
                 }
-                SecurityAndPrivacyEvents.ToggleRoomVisibility -> {
+                SecurityAndPrivacyEvent.ToggleRoomVisibility -> {
                     editedVisibleInRoomDirectory = when (val edited = editedVisibleInRoomDirectory) {
                         is AsyncData.Success -> AsyncData.Success(!edited.data)
                         else -> edited
                     }
                 }
-                SecurityAndPrivacyEvents.EditRoomAddress -> navigator.openEditRoomAddress()
-                SecurityAndPrivacyEvents.CancelEnableEncryption -> {
+                SecurityAndPrivacyEvent.EditRoomAddress -> navigator.openEditRoomAddress()
+                SecurityAndPrivacyEvent.CancelEnableEncryption -> {
                     showEnableEncryptionConfirmation = false
                 }
-                SecurityAndPrivacyEvents.ConfirmEnableEncryption -> {
+                SecurityAndPrivacyEvent.ConfirmEnableEncryption -> {
                     showEnableEncryptionConfirmation = false
                     editedIsEncrypted = true
                 }
-                SecurityAndPrivacyEvents.DismissSaveError -> {
+                SecurityAndPrivacyEvent.DismissSaveError -> {
                     saveAction.value = AsyncAction.Uninitialized
                 }
-                SecurityAndPrivacyEvents.Exit -> {
+                SecurityAndPrivacyEvent.Exit -> {
                     saveAction.value = if (savedSettings == editedSettings || saveAction.value == AsyncAction.ConfirmingCancellation) {
                         AsyncAction.Success(Unit)
                     } else {
                         AsyncAction.ConfirmingCancellation
                     }
                 }
-                SecurityAndPrivacyEvents.DismissExitConfirmation -> {
+                SecurityAndPrivacyEvent.DismissExitConfirmation -> {
                     saveAction.value = AsyncAction.Uninitialized
                 }
             }

features/securityandprivacy/impl/src/main/kotlin/io/element/android/features/securityandprivacy/impl/root/SecurityAndPrivacyState.kt

@@ -24,7 +24,7 @@ data class SecurityAndPrivacyState(
     val saveAction: AsyncAction<Unit>,
     val isSpace: Boolean,
     private val permissions: SecurityAndPrivacyPermissions,
-    val eventSink: (SecurityAndPrivacyEvents) -> Unit
+    val eventSink: (SecurityAndPrivacyEvent) -> Unit
 ) {
     val canBeSaved = savedSettings != editedSettings
 

features/securityandprivacy/impl/src/main/kotlin/io/element/android/features/securityandprivacy/impl/root/SecurityAndPrivacyStateProvider.kt

@@ -117,7 +117,7 @@ fun aSecurityAndPrivacyState(
     ),
     isKnockEnabled: Boolean = true,
     isSpace: Boolean = false,
-    eventSink: (SecurityAndPrivacyEvents) -> Unit = {}
+    eventSink: (SecurityAndPrivacyEvent) -> Unit = {}
 ) = SecurityAndPrivacyState(
     editedSettings = editedSettings,
     savedSettings = savedSettings,

features/securityandprivacy/impl/src/main/kotlin/io/element/android/features/securityandprivacy/impl/root/SecurityAndPrivacyView.kt

@@ -60,7 +60,7 @@ fun SecurityAndPrivacyView(
     modifier: Modifier = Modifier,
 ) {
     BackHandler {
-        state.eventSink(SecurityAndPrivacyEvents.Exit)
+        state.eventSink(SecurityAndPrivacyEvent.Exit)
     }
     Scaffold(
         modifier = modifier,
@@ -68,10 +68,10 @@ fun SecurityAndPrivacyView(
             SecurityAndPrivacyToolbar(
                 isSaveActionEnabled = state.canBeSaved,
                 onBackClick = {
-                    state.eventSink(SecurityAndPrivacyEvents.Exit)
+                    state.eventSink(SecurityAndPrivacyEvent.Exit)
                 },
                 onSaveClick = {
-                    state.eventSink(SecurityAndPrivacyEvents.Save)
+                    state.eventSink(SecurityAndPrivacyEvent.Save)
                 },
             )
         }
@@ -90,7 +90,7 @@ fun SecurityAndPrivacyView(
                     edited = state.editedSettings.roomAccess,
                     saved = state.savedSettings.roomAccess,
                     isKnockEnabled = state.isKnockEnabled,
-                    onSelectOption = { state.eventSink(SecurityAndPrivacyEvents.ChangeRoomAccess(it)) },
+                    onSelectOption = { state.eventSink(SecurityAndPrivacyEvent.ChangeRoomAccess(it)) },
                 )
             }
             if (state.showRoomVisibilitySections) {
@@ -98,10 +98,10 @@ fun SecurityAndPrivacyView(
                 RoomAddressSection(
                     roomAddress = state.editedSettings.address,
                     homeserverName = state.homeserverName,
-                    onRoomAddressClick = { state.eventSink(SecurityAndPrivacyEvents.EditRoomAddress) },
+                    onRoomAddressClick = { state.eventSink(SecurityAndPrivacyEvent.EditRoomAddress) },
                     isVisibleInRoomDirectory = state.editedSettings.isVisibleInRoomDirectory,
                     onVisibilityChange = {
-                        state.eventSink(SecurityAndPrivacyEvents.ToggleRoomVisibility)
+                        state.eventSink(SecurityAndPrivacyEvent.ToggleRoomVisibility)
                     },
                 )
             }
@@ -110,10 +110,10 @@ fun SecurityAndPrivacyView(
                     isRoomEncrypted = state.editedSettings.isEncrypted,
                     // encryption can't be disabled once enabled
                     canToggleEncryption = !state.savedSettings.isEncrypted,
-                    onToggleEncryption = { state.eventSink(SecurityAndPrivacyEvents.ToggleEncryptionState) },
+                    onToggleEncryption = { state.eventSink(SecurityAndPrivacyEvent.ToggleEncryptionState) },
                     showConfirmation = state.showEnableEncryptionConfirmation,
-                    onDismissConfirmation = { state.eventSink(SecurityAndPrivacyEvents.CancelEnableEncryption) },
-                    onConfirmEncryption = { state.eventSink(SecurityAndPrivacyEvents.ConfirmEnableEncryption) },
+                    onDismissConfirmation = { state.eventSink(SecurityAndPrivacyEvent.CancelEnableEncryption) },
+                    onConfirmEncryption = { state.eventSink(SecurityAndPrivacyEvent.ConfirmEnableEncryption) },
                 )
             }
             if (state.showHistoryVisibilitySection) {
@@ -121,7 +121,7 @@ fun SecurityAndPrivacyView(
                     editedOption = state.editedSettings.historyVisibility,
                     savedOptions = state.savedSettings.historyVisibility,
                     availableOptions = state.availableHistoryVisibilities,
-                    onSelectOption = { state.eventSink(SecurityAndPrivacyEvents.ChangeHistoryVisibility(it)) },
+                    onSelectOption = { state.eventSink(SecurityAndPrivacyEvent.ChangeHistoryVisibility(it)) },
                 )
             }
         }
@@ -129,14 +129,14 @@ fun SecurityAndPrivacyView(
     AsyncActionView(
         async = state.saveAction,
         onSuccess = { },
-        onErrorDismiss = { state.eventSink(SecurityAndPrivacyEvents.DismissSaveError) },
+        onErrorDismiss = { state.eventSink(SecurityAndPrivacyEvent.DismissSaveError) },
         confirmationDialog = { confirming ->
             when (confirming) {
                 is AsyncAction.ConfirmingCancellation ->
                     SaveChangesDialog(
-                        onSaveClick = { state.eventSink(SecurityAndPrivacyEvents.Save) },
-                        onDiscardClick = { state.eventSink(SecurityAndPrivacyEvents.Exit) },
-                        onDismiss = { state.eventSink(SecurityAndPrivacyEvents.DismissExitConfirmation) }
+                        onSaveClick = { state.eventSink(SecurityAndPrivacyEvent.Save) },
+                        onDiscardClick = { state.eventSink(SecurityAndPrivacyEvent.Exit) },
+                        onDismiss = { state.eventSink(SecurityAndPrivacyEvent.DismissExitConfirmation) }
                     )
             }
         },
@@ -146,7 +146,7 @@ fun SecurityAndPrivacyView(
                 progressText = stringResource(CommonStrings.common_saving),
             )
         },
-        onRetry = { state.eventSink(SecurityAndPrivacyEvents.Save) },
+        onRetry = { state.eventSink(SecurityAndPrivacyEvent.Save) },
     )
 }