Merge pull request #2873 from element-hq/feature/bma/pushProviderSwitch

Push provider switch
2024-05-21 16:52:01 +02:00 · 2024-05-21 16:52:01 +02:00 · 71763e3fed
commit 71763e3fed
parent ac123bdcd8 4ab0202f8a
50 changed files with 782 additions and 154 deletions
--- a/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/advanced/AdvancedSettingsEvents.kt
+++ b/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/advanced/AdvancedSettingsEvents.kt
@ -24,4 +24,7 @@ sealed interface AdvancedSettingsEvents {
    data object ChangeTheme : AdvancedSettingsEvents
    data object CancelChangeTheme : AdvancedSettingsEvents
    data class SetTheme(val theme: Theme) : AdvancedSettingsEvents
+    data object ChangePushProvider : AdvancedSettingsEvents
+    data object CancelChangePushProvider : AdvancedSettingsEvents
+    data class SetPushProvider(val index: Int) : AdvancedSettingsEvents
 }
--- a/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/advanced/AdvancedSettingsPresenter.kt
+++ b/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/advanced/AdvancedSettingsPresenter.kt
@ -17,8 +17,10 @@
 package io.element.android.features.preferences.impl.advanced

 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
@ -27,13 +29,22 @@ import io.element.android.compound.theme.Theme
 import io.element.android.compound.theme.mapToTheme
 import io.element.android.features.preferences.api.store.AppPreferencesStore
 import io.element.android.features.preferences.api.store.SessionPreferencesStore
+import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.push.api.PushService
+import io.element.android.libraries.pushproviders.api.Distributor
+import io.element.android.libraries.pushproviders.api.PushProvider
+import kotlinx.collections.immutable.toImmutableList
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import javax.inject.Inject

 class AdvancedSettingsPresenter @Inject constructor(
    private val appPreferencesStore: AppPreferencesStore,
    private val sessionPreferencesStore: SessionPreferencesStore,
+    private val matrixClient: MatrixClient,
+    private val pushService: PushService,
 ) : Presenter<AdvancedSettingsState> {
    @Composable
    override fun present(): AdvancedSettingsState {
@ -49,6 +60,62 @@ class AdvancedSettingsPresenter @Inject constructor(
        }
            .collectAsState(initial = Theme.System)
        var showChangeThemeDialog by remember { mutableStateOf(false) }
+
+        // List of PushProvider -> Distributor
+        val distributors = remember {
+            pushService.getAvailablePushProviders()
+                .flatMap { pushProvider ->
+                    pushProvider.getDistributors().map { distributor ->
+                        pushProvider to distributor
+                    }
+                }
+        }
+        // List of Distributor names
+        val distributorNames = remember {
+            distributors.map { it.second.name }
+        }
+
+        var currentDistributorName by remember { mutableStateOf<AsyncAction<String>>(AsyncAction.Uninitialized) }
+        var refreshPushProvider by remember { mutableIntStateOf(0) }
+
+        LaunchedEffect(refreshPushProvider) {
+            val p = pushService.getCurrentPushProvider()
+            val name = p?.getCurrentDistributor(matrixClient)?.name
+            currentDistributorName = if (name != null) {
+                AsyncAction.Success(name)
+            } else {
+                AsyncAction.Failure(Exception("Failed to get current push provider"))
+            }
+        }
+
+        var showChangePushProviderDialog by remember { mutableStateOf(false) }
+
+        fun CoroutineScope.changePushProvider(
+            data: Pair<PushProvider, Distributor>?
+        ) = launch {
+            showChangePushProviderDialog = false
+            data ?: return@launch
+            // No op if the value is the same.
+            if (data.second.name == currentDistributorName.dataOrNull()) return@launch
+            currentDistributorName = AsyncAction.Loading
+            data.let { (pushProvider, distributor) ->
+                pushService.registerWith(
+                    matrixClient = matrixClient,
+                    pushProvider = pushProvider,
+                    distributor = distributor
+                )
+                    .fold(
+                        {
+                            currentDistributorName = AsyncAction.Success(distributor.name)
+                            refreshPushProvider++
+                        },
+                        {
+                            currentDistributorName = AsyncAction.Failure(it)
+                        }
+                    )
+            }
+        }
+
        fun handleEvents(event: AdvancedSettingsEvents) {
            when (event) {
                is AdvancedSettingsEvents.SetDeveloperModeEnabled -> localCoroutineScope.launch {
@ -63,6 +130,9 @@ class AdvancedSettingsPresenter @Inject constructor(
                    appPreferencesStore.setTheme(event.theme.name)
                    showChangeThemeDialog = false
                }
+                AdvancedSettingsEvents.ChangePushProvider -> showChangePushProviderDialog = true
+                AdvancedSettingsEvents.CancelChangePushProvider -> showChangePushProviderDialog = false
+                is AdvancedSettingsEvents.SetPushProvider -> localCoroutineScope.changePushProvider(distributors.getOrNull(event.index))
            }
        }

@ -71,6 +141,9 @@ class AdvancedSettingsPresenter @Inject constructor(
            isSharePresenceEnabled = isSharePresenceEnabled,
            theme = theme,
            showChangeThemeDialog = showChangeThemeDialog,
+            currentPushDistributor = currentDistributorName,
+            availablePushDistributors = distributorNames.toImmutableList(),
+            showChangePushProviderDialog = showChangePushProviderDialog,
            eventSink = { handleEvents(it) }
        )
    }
--- a/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/advanced/AdvancedSettingsState.kt
+++ b/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/advanced/AdvancedSettingsState.kt
@ -17,11 +17,16 @@
 package io.element.android.features.preferences.impl.advanced

 import io.element.android.compound.theme.Theme
+import io.element.android.libraries.architecture.AsyncAction
+import kotlinx.collections.immutable.ImmutableList

 data class AdvancedSettingsState(
    val isDeveloperModeEnabled: Boolean,
    val isSharePresenceEnabled: Boolean,
    val theme: Theme,
    val showChangeThemeDialog: Boolean,
+    val currentPushDistributor: AsyncAction<String>,
+    val availablePushDistributors: ImmutableList<String>,
+    val showChangePushProviderDialog: Boolean,
    val eventSink: (AdvancedSettingsEvents) -> Unit
 )
--- a/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/advanced/AdvancedSettingsStateProvider.kt
+++ b/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/advanced/AdvancedSettingsStateProvider.kt
@ -18,6 +18,8 @@ package io.element.android.features.preferences.impl.advanced

 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
 import io.element.android.compound.theme.Theme
+import io.element.android.libraries.architecture.AsyncAction
+import kotlinx.collections.immutable.toImmutableList

 open class AdvancedSettingsStateProvider : PreviewParameterProvider<AdvancedSettingsState> {
    override val values: Sequence<AdvancedSettingsState>
@ -26,6 +28,9 @@ open class AdvancedSettingsStateProvider : PreviewParameterProvider<AdvancedSett
            aAdvancedSettingsState(isDeveloperModeEnabled = true),
            aAdvancedSettingsState(showChangeThemeDialog = true),
            aAdvancedSettingsState(isSendPublicReadReceiptsEnabled = true),
+            aAdvancedSettingsState(showChangePushProviderDialog = true),
+            aAdvancedSettingsState(currentPushDistributor = AsyncAction.Loading),
+            aAdvancedSettingsState(currentPushDistributor = AsyncAction.Failure(Exception("Failed to change distributor"))),
        )
 }

@ -33,10 +38,17 @@ fun aAdvancedSettingsState(
    isDeveloperModeEnabled: Boolean = false,
    isSendPublicReadReceiptsEnabled: Boolean = false,
    showChangeThemeDialog: Boolean = false,
+    currentPushDistributor: AsyncAction<String> = AsyncAction.Success("Firebase"),
+    availablePushDistributors: List<String> = listOf("Firebase", "ntfy"),
+    showChangePushProviderDialog: Boolean = false,
+    eventSink: (AdvancedSettingsEvents) -> Unit = {},
 ) = AdvancedSettingsState(
    isDeveloperModeEnabled = isDeveloperModeEnabled,
    isSharePresenceEnabled = isSendPublicReadReceiptsEnabled,
    theme = Theme.System,
    showChangeThemeDialog = showChangeThemeDialog,
-    eventSink = {}
+    currentPushDistributor = currentPushDistributor,
+    availablePushDistributors = availablePushDistributors.toImmutableList(),
+    showChangePushProviderDialog = showChangePushProviderDialog,
+    eventSink = eventSink
 )
--- a/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/advanced/AdvancedSettingsView.kt
+++ b/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/advanced/AdvancedSettingsView.kt
@ -16,19 +16,24 @@

 package io.element.android.features.preferences.impl.advanced

+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.progressSemantics
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
 import io.element.android.compound.theme.Theme
 import io.element.android.compound.theme.themes
 import io.element.android.features.preferences.impl.R
+import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.designsystem.components.dialogs.ListOption
 import io.element.android.libraries.designsystem.components.dialogs.SingleSelectionDialog
 import io.element.android.libraries.designsystem.components.list.ListItemContent
 import io.element.android.libraries.designsystem.components.preferences.PreferencePage
 import io.element.android.libraries.designsystem.preview.ElementPreview
 import io.element.android.libraries.designsystem.preview.PreviewsDayNight
+import io.element.android.libraries.designsystem.theme.components.CircularProgressIndicator
 import io.element.android.libraries.designsystem.theme.components.ListItem
 import io.element.android.libraries.designsystem.theme.components.Text
 import io.element.android.libraries.ui.strings.CommonStrings
@ -81,6 +86,34 @@ fun AdvancedSettingsView(
            ),
            onClick = { state.eventSink(AdvancedSettingsEvents.SetSharePresenceEnabled(!state.isSharePresenceEnabled)) }
        )
+        ListItem(
+            headlineContent = {
+                Text(text = stringResource(id = R.string.screen_advanced_settings_push_provider_android))
+            },
+            trailingContent = when (state.currentPushDistributor) {
+                AsyncAction.Uninitialized,
+                AsyncAction.Confirming,
+                AsyncAction.Loading -> ListItemContent.Custom {
+                    CircularProgressIndicator(
+                        modifier = Modifier
+                            .progressSemantics()
+                            .size(20.dp),
+                        strokeWidth = 2.dp
+                    )
+                }
+                is AsyncAction.Failure -> ListItemContent.Text(
+                    stringResource(id = CommonStrings.common_error)
+                )
+                is AsyncAction.Success -> ListItemContent.Text(
+                    state.currentPushDistributor.dataOrNull() ?: ""
+                )
+            },
+            onClick = {
+                if (state.currentPushDistributor.isReady()) {
+                    state.eventSink(AdvancedSettingsEvents.ChangePushProvider)
+                }
+            }
+        )
    }

    if (state.showChangeThemeDialog) {
@ -97,6 +130,22 @@ fun AdvancedSettingsView(
            onDismissRequest = { state.eventSink(AdvancedSettingsEvents.CancelChangeTheme) },
        )
    }
+
+    if (state.showChangePushProviderDialog) {
+        SingleSelectionDialog(
+            title = stringResource(id = R.string.screen_advanced_settings_choose_distributor_dialog_title_android),
+            options = state.availablePushDistributors.map {
+                ListOption(title = it)
+            }.toImmutableList(),
+            initialSelection = state.availablePushDistributors.indexOf(state.currentPushDistributor.dataOrNull()),
+            onOptionSelected = { index ->
+                state.eventSink(
+                    AdvancedSettingsEvents.SetPushProvider(index)
+                )
+            },
+            onDismissRequest = { state.eventSink(AdvancedSettingsEvents.CancelChangePushProvider) },
+        )
+    }
 }

@Composable
--- a/features/preferences/impl/src/test/kotlin/io/element/android/features/preferences/impl/advanced/AdvancedSettingsPresenterTest.kt
+++ b/features/preferences/impl/src/test/kotlin/io/element/android/features/preferences/impl/advanced/AdvancedSettingsPresenterTest.kt
@ -21,8 +21,16 @@ import app.cash.molecule.moleculeFlow
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
 import io.element.android.compound.theme.Theme
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.test.FakeMatrixClient
 import io.element.android.libraries.preferences.test.InMemoryAppPreferencesStore
 import io.element.android.libraries.preferences.test.InMemorySessionPreferencesStore
+import io.element.android.libraries.push.api.PushService
+import io.element.android.libraries.push.test.FakePushService
+import io.element.android.libraries.pushproviders.api.Distributor
+import io.element.android.libraries.pushproviders.api.PushProvider
+import io.element.android.libraries.pushproviders.test.FakePushProvider
 import io.element.android.tests.testutils.WarmUpRule
 import io.element.android.tests.testutils.awaitLastSequentialItem
 import kotlinx.coroutines.test.runTest
@ -100,11 +108,93 @@ class AdvancedSettingsPresenterTest {
        }
    }

+    @Test
+    fun `present - change push provider`() = runTest {
+        val presenter = createAdvancedSettingsPresenter(
+            pushService = createFakePushService(),
+        )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitLastSequentialItem()
+            assertThat(initialState.currentPushDistributor).isEqualTo(AsyncAction.Success("aDistributorName0"))
+            assertThat(initialState.availablePushDistributors).containsExactly("aDistributorName0", "aDistributorName1")
+            initialState.eventSink.invoke(AdvancedSettingsEvents.ChangePushProvider)
+            val withDialog = awaitItem()
+            assertThat(withDialog.showChangePushProviderDialog).isTrue()
+            // Cancel
+            withDialog.eventSink(AdvancedSettingsEvents.CancelChangePushProvider)
+            val withoutDialog = awaitItem()
+            assertThat(withoutDialog.showChangePushProviderDialog).isFalse()
+            withDialog.eventSink.invoke(AdvancedSettingsEvents.ChangePushProvider)
+            assertThat(awaitItem().showChangePushProviderDialog).isTrue()
+            withDialog.eventSink(AdvancedSettingsEvents.SetPushProvider(1))
+            val withNewProvider = awaitItem()
+            assertThat(withNewProvider.showChangePushProviderDialog).isFalse()
+            assertThat(withNewProvider.currentPushDistributor).isEqualTo(AsyncAction.Loading)
+            val lastItem = awaitItem()
+            assertThat(lastItem.currentPushDistributor).isEqualTo(AsyncAction.Success("aDistributorName1"))
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+
+    @Test
+    fun `present - change push provider error`() = runTest {
+        val presenter = createAdvancedSettingsPresenter(
+            pushService = createFakePushService(
+                registerWithLambda = { _, _, _ ->
+                    Result.failure(Exception("An error"))
+                },
+            ),
+        )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitLastSequentialItem()
+            initialState.eventSink.invoke(AdvancedSettingsEvents.ChangePushProvider)
+            val withDialog = awaitItem()
+            assertThat(withDialog.showChangePushProviderDialog).isTrue()
+            withDialog.eventSink(AdvancedSettingsEvents.SetPushProvider(1))
+            val withNewProvider = awaitItem()
+            assertThat(withNewProvider.showChangePushProviderDialog).isFalse()
+            assertThat(withNewProvider.currentPushDistributor).isEqualTo(AsyncAction.Loading)
+            val lastItem = awaitItem()
+            assertThat(lastItem.currentPushDistributor).isInstanceOf(AsyncAction.Failure::class.java)
+        }
+    }
+
+    private fun createFakePushService(
+        registerWithLambda: suspend (MatrixClient, PushProvider, Distributor) -> Result<Unit> = { _, _, _ ->
+            Result.success(Unit)
+        }
+    ): PushService {
+        val pushProvider1 = FakePushProvider(
+            index = 0,
+            name = "aFakePushProvider0",
+            isAvailable = true,
+            distributors = listOf(Distributor("aDistributorValue0", "aDistributorName0")),
+        )
+        val pushProvider2 = FakePushProvider(
+            index = 1,
+            name = "aFakePushProvider1",
+            isAvailable = true,
+            distributors = listOf(Distributor("aDistributorValue1", "aDistributorName1")),
+        )
+        return FakePushService(
+            availablePushProviders = listOf(pushProvider1, pushProvider2),
+            registerWithLambda = registerWithLambda,
+        )
+    }
+
    private fun createAdvancedSettingsPresenter(
        appPreferencesStore: InMemoryAppPreferencesStore = InMemoryAppPreferencesStore(),
        sessionPreferencesStore: InMemorySessionPreferencesStore = InMemorySessionPreferencesStore(),
+        matrixClient: MatrixClient = FakeMatrixClient(),
+        pushService: PushService = FakePushService(),
    ) = AdvancedSettingsPresenter(
        appPreferencesStore = appPreferencesStore,
        sessionPreferencesStore = sessionPreferencesStore,
+        matrixClient = matrixClient,
+        pushService = pushService,
    )
 }
--- a/features/preferences/impl/src/test/kotlin/io/element/android/features/preferences/impl/advanced/AdvancedSettingsViewTest.kt
+++ b/features/preferences/impl/src/test/kotlin/io/element/android/features/preferences/impl/advanced/AdvancedSettingsViewTest.kt
@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2024 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.preferences.impl.advanced
+
+import androidx.activity.ComponentActivity
+import androidx.compose.ui.test.junit4.AndroidComposeTestRule
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.element.android.compound.theme.Theme
+import io.element.android.features.preferences.impl.R
+import io.element.android.libraries.ui.strings.CommonStrings
+import io.element.android.tests.testutils.EnsureNeverCalled
+import io.element.android.tests.testutils.EventsRecorder
+import io.element.android.tests.testutils.clickOn
+import io.element.android.tests.testutils.ensureCalledOnce
+import io.element.android.tests.testutils.pressBack
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TestRule
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+class AdvancedSettingsViewTest {
+    @get:Rule
+    val rule = createAndroidComposeRule<ComponentActivity>()
+
+    @Test
+    fun `clicking on back invokes the expected callback`() {
+        val eventsRecorder = EventsRecorder<AdvancedSettingsEvents>(expectEvents = false)
+        ensureCalledOnce {
+            rule.setAdvancedSettingsView(
+                state = aAdvancedSettingsState(
+                    eventSink = eventsRecorder
+                ),
+                onBackPressed = it
+            )
+            rule.pressBack()
+        }
+    }
+
+    @Test
+    fun `clicking on Appearance emits the expected event`() {
+        val eventsRecorder = EventsRecorder<AdvancedSettingsEvents>()
+        rule.setAdvancedSettingsView(
+            state = aAdvancedSettingsState(
+                eventSink = eventsRecorder
+            ),
+        )
+        rule.clickOn(CommonStrings.common_appearance)
+        eventsRecorder.assertSingle(AdvancedSettingsEvents.ChangeTheme)
+    }
+
+    @Test
+    fun `clicking on other theme emits the expected event`() {
+        val eventsRecorder = EventsRecorder<AdvancedSettingsEvents>()
+        rule.setAdvancedSettingsView(
+            state = aAdvancedSettingsState(
+                eventSink = eventsRecorder,
+                showChangeThemeDialog = true
+            ),
+        )
+        rule.clickOn(CommonStrings.common_dark)
+        eventsRecorder.assertSingle(AdvancedSettingsEvents.SetTheme(Theme.Dark))
+    }
+
+    @Test
+    fun `clicking on View source emits the expected event`() {
+        val eventsRecorder = EventsRecorder<AdvancedSettingsEvents>()
+        rule.setAdvancedSettingsView(
+            state = aAdvancedSettingsState(
+                eventSink = eventsRecorder,
+            ),
+        )
+        rule.clickOn(CommonStrings.action_view_source)
+        eventsRecorder.assertSingle(AdvancedSettingsEvents.SetDeveloperModeEnabled(true))
+    }
+
+    @Test
+    fun `clicking on Share presence emits the expected event`() {
+        val eventsRecorder = EventsRecorder<AdvancedSettingsEvents>()
+        rule.setAdvancedSettingsView(
+            state = aAdvancedSettingsState(
+                eventSink = eventsRecorder,
+            ),
+        )
+        rule.clickOn(R.string.screen_advanced_settings_share_presence)
+        eventsRecorder.assertSingle(AdvancedSettingsEvents.SetSharePresenceEnabled(true))
+    }
+
+    @Config(qualifiers = "h1024dp")
+    @Test
+    fun `clicking on Push notification provider emits the expected event`() {
+        val eventsRecorder = EventsRecorder<AdvancedSettingsEvents>()
+        rule.setAdvancedSettingsView(
+            state = aAdvancedSettingsState(
+                eventSink = eventsRecorder
+            ),
+        )
+        rule.clickOn(R.string.screen_advanced_settings_push_provider_android)
+        eventsRecorder.assertSingle(AdvancedSettingsEvents.ChangePushProvider)
+    }
+
+    @Test
+    fun `clicking on a push provider emits the expected event`() {
+        val eventsRecorder = EventsRecorder<AdvancedSettingsEvents>()
+        rule.setAdvancedSettingsView(
+            state = aAdvancedSettingsState(
+                eventSink = eventsRecorder,
+                showChangePushProviderDialog = true,
+                availablePushDistributors = listOf("P1", "P2")
+            ),
+        )
+        rule.onNodeWithText("P2").performClick()
+        eventsRecorder.assertSingle(AdvancedSettingsEvents.SetPushProvider(1))
+    }
+}
+
+private fun <R : TestRule> AndroidComposeTestRule<R, ComponentActivity>.setAdvancedSettingsView(
+    state: AdvancedSettingsState,
+    onBackPressed: () -> Unit = EnsureNeverCalled(),
+) {
+    setContent {
+        AdvancedSettingsView(
+            state = state,
+            onBackPressed = onBackPressed,
+        )
+    }
+}