Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6ac2cc9d authored by Andreas Miko's avatar Andreas Miko
Browse files

Introduce HydratedActivatable 

Setting up an ExclusiveActivatable requires quite a bit of boilerplate
and knowledge about the Hydrator and its activation. This improves the
process by setting it all up in the background and providing convenience
methods that are more in line with Compose methods
`collectAsStateWithLifecycle()`.

Bug: b/416131251
Test: Refactor only verified manually
Flag: com.android.systemui.notification_bundle_ui
Change-Id: I4e9ae510114b7d269dd788fbf26d6b2c106dcf84
parent c495745f

packages/SystemUI/multivalentTests/src/com/android/systemui/lifecycle/HydratedActivatableTest.kt

0 → 100644
+165 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2024 The Android Open Source Project

 *

 * 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 com.android.systemui.lifecycle



import androidx.compose.foundation.layout.Column

import androidx.compose.material3.Text

import androidx.compose.runtime.getValue

import androidx.compose.runtime.mutableStateOf

import androidx.compose.ui.Modifier

import androidx.compose.ui.platform.testTag

import androidx.compose.ui.test.assertTextEquals

import androidx.compose.ui.test.hasTestTag

import androidx.compose.ui.test.junit4.createComposeRule

import androidx.test.ext.junit.runners.AndroidJUnit4

import androidx.test.filters.SmallTest

import com.android.systemui.SysuiTestCase

import com.android.systemui.kosmos.testScope

import com.android.systemui.testKosmos

import com.android.systemui.ui.viewmodel.FakeHydratedViewModel

import com.google.common.truth.Truth.assertThat

import kotlinx.coroutines.Job

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.map

import kotlinx.coroutines.test.runCurrent

import kotlinx.coroutines.test.runTest

import org.junit.Rule

import org.junit.Test

import org.junit.runner.RunWith



@SmallTest

@RunWith(AndroidJUnit4::class)

class HydratedActivatableTest : SysuiTestCase() {



    @get:Rule val composeRule = createComposeRule()



    private val kosmos = testKosmos()

    private val testScope = kosmos.testScope



    private val underTest = FakeHydratedViewModel()



    @Test

    fun activate() =

        testScope.runTest {

            assertThat(underTest.activationCount).isEqualTo(0)

            assertThat(underTest.cancellationCount).isEqualTo(0)



            underTest.activateIn(testScope)

            runCurrent()

            assertThat(underTest.activationCount).isEqualTo(1)

            assertThat(underTest.cancellationCount).isEqualTo(0)

        }



    @Test

    fun activate_andCancel() =

        testScope.runTest {

            assertThat(underTest.activationCount).isEqualTo(0)

            assertThat(underTest.cancellationCount).isEqualTo(0)



            val job = Job()

            underTest.activateIn(testScope, context = job)

            runCurrent()

            assertThat(underTest.activationCount).isEqualTo(1)

            assertThat(underTest.cancellationCount).isEqualTo(0)



            job.cancel()

            runCurrent()

            assertThat(underTest.activationCount).isEqualTo(1)

            assertThat(underTest.cancellationCount).isEqualTo(1)

        }



    @Test

    fun activate_afterCancellation() =

        testScope.runTest {

            assertThat(underTest.activationCount).isEqualTo(0)

            assertThat(underTest.cancellationCount).isEqualTo(0)



            val job = Job()

            underTest.activateIn(testScope, context = job)

            runCurrent()

            assertThat(underTest.activationCount).isEqualTo(1)

            assertThat(underTest.cancellationCount).isEqualTo(0)



            job.cancel()

            runCurrent()

            assertThat(underTest.activationCount).isEqualTo(1)

            assertThat(underTest.cancellationCount).isEqualTo(1)



            underTest.activateIn(testScope)

            runCurrent()

            assertThat(underTest.activationCount).isEqualTo(2)

            assertThat(underTest.cancellationCount).isEqualTo(1)

        }



    @Test(expected = IllegalStateException::class)

    fun activate_whileActive_throws() =

        testScope.runTest {

            assertThat(underTest.activationCount).isEqualTo(0)

            assertThat(underTest.cancellationCount).isEqualTo(0)



            underTest.activateIn(testScope)

            runCurrent()

            assertThat(underTest.activationCount).isEqualTo(1)

            assertThat(underTest.cancellationCount).isEqualTo(0)



            underTest.activateIn(testScope)

            runCurrent()

        }



    @Test

    fun hydratedStateOf() {

        val keepAliveMutable = mutableStateOf(true)

        val upstreamStateFlow = MutableStateFlow(true)

        val upstreamFlow = upstreamStateFlow.map { !it }

        composeRule.setContent {

            val keepAlive by keepAliveMutable

            if (keepAlive) {

                val viewModel =

                    rememberViewModel("test") {

                        FakeHydratedViewModel(

                            upstreamFlow = upstreamFlow,

                            upstreamStateFlow = upstreamStateFlow,

                        )

                    }



                Column {

                    Text(

                        "upstreamStateFlow=${viewModel.stateBackedByStateFlow}",

                        Modifier.testTag("upstreamStateFlow"),

                    )

                    Text(

                        "upstreamFlow=${viewModel.stateBackedByFlow}",

                        Modifier.testTag("upstreamFlow"),

                    )

                }

            }

        }



        composeRule.waitForIdle()

        composeRule

            .onNode(hasTestTag("upstreamStateFlow"))

            .assertTextEquals("upstreamStateFlow=true")

        composeRule.onNode(hasTestTag("upstreamFlow")).assertTextEquals("upstreamFlow=false")



        composeRule.runOnUiThread { upstreamStateFlow.value = false }

        composeRule.waitForIdle()

        composeRule

            .onNode(hasTestTag("upstreamStateFlow"))

            .assertTextEquals("upstreamStateFlow=false")

        composeRule.onNode(hasTestTag("upstreamFlow")).assertTextEquals("upstreamFlow=true")

    }

}

packages/SystemUI/src/com/android/systemui/lifecycle/HydratedActivatable.kt

0 → 100644
+82 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2025 The Android Open Source Project

 *

 * 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 com.android.systemui.lifecycle



import androidx.compose.runtime.State

import kotlinx.coroutines.awaitCancellation

import kotlinx.coroutines.coroutineScope

import kotlinx.coroutines.flow.Flow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.launch



/**

 * An [Activatable] which manages an internal [Hydrator] which is activated accordingly. Adds

 * convenience methods to easily transform upstream [Flow]s into downstream snapshot-backed [State]s

 * based on the [Hydrator].

 *

 * The activation of this is also guaranteed to be exclusive since the [Hydrator] is an

 * [ExclusiveActivatable] itself.

 *

 * @see [ExclusiveActivatable]

 */

abstract class HydratedActivatable : Activatable {



    private val hydrator = Hydrator("${this::class.simpleName}.hydrator")



    final override suspend fun activate(): Nothing {

        coroutineScope {

            launch { hydrator.activate() }

            onActivated()

        }

    }



    /**

     * Notifies that the [Activatable] has been activated.

     *

     * Serves as an entrypoint to kick off coroutine work that the object requires in order to keep

     * its state fresh and/or perform side-effects.

     *

     * The method suspends and doesn't return until all work required by the object is finished. In

     * most cases, it's expected for the work to remain ongoing forever so this method will forever

     * suspend its caller until the coroutine that called it is canceled.

     *

     * Implementations could follow this pattern:

     * ```kotlin

     * override suspend fun onActivated(): Nothing {

     *     coroutineScope {

     *         launch { ... }

     *         launch { ... }

     *         launch { ... }

     *         awaitCancellation()

     *     }

     * }

     * ```

     *

     * @see activate

     */

    protected open suspend fun onActivated(): Nothing {

        awaitCancellation()

    }



    /** @see [Hydrator.hydratedStateOf] */

    protected fun <T> StateFlow<T>.hydratedStateOf(traceName: String): State<T> =

        hydrator.hydratedStateOf(traceName, this)



    /** @see [Hydrator.hydratedStateOf] */

    protected fun <T> Flow<T>.hydratedStateOf(traceName: String, initialValue: T): State<T> =

        hydrator.hydratedStateOf(traceName, initialValue, this)

}

packages/SystemUI/src/com/android/systemui/statusbar/notification/row/ui/viewmodel/BundleHeaderViewModel.kt

+3 −11
Original line number Diff line number Diff line
@@ -23,8 +23,7 @@ import androidx.compose.runtime.getValue 
import androidx.compose.runtime.mutableStateOf

import androidx.compose.runtime.setValue

import com.android.compose.animation.scene.MutableSceneTransitionLayoutState

import com.android.systemui.lifecycle.ExclusiveActivatable

import com.android.systemui.lifecycle.Hydrator

import com.android.systemui.lifecycle.HydratedActivatable

import com.android.systemui.notifications.ui.composable.row.BundleHeader

import com.android.systemui.statusbar.notification.row.dagger.BundleRowScope

import com.android.systemui.statusbar.notification.row.domain.interactor.BundleInteractor
@@ -33,9 +32,7 @@ import dagger.assisted.AssistedInject 
import kotlinx.coroutines.CoroutineScope



class BundleHeaderViewModel @AssistedInject constructor(private val interactor: BundleInteractor) :

    ExclusiveActivatable() {



    private val hydrator = Hydrator("BundleHeaderViewModel.hydrator")

    HydratedActivatable() {



    val titleText: Int

        get() = interactor.titleText
@@ -47,10 +44,9 @@ class BundleHeaderViewModel @AssistedInject constructor(private val interactor: 
        get() = interactor.bundleIcon



    val previewIcons: List<Drawable> by

        hydrator.hydratedStateOf(

        interactor.previewIcons.hydratedStateOf(

            traceName = "previewIcons",

            initialValue = emptyList(),

            source = interactor.previewIcons,

        )



    var state: MutableSceneTransitionLayoutState? by interactor::state
@@ -79,10 +75,6 @@ class BundleHeaderViewModel @AssistedInject constructor(private val interactor: 


    fun setExpansionState(isExpanded: Boolean) = interactor.setExpansionState(isExpanded)



    override suspend fun onActivated(): Nothing {

        hydrator.activate()

    }



    @AssistedFactory

    @BundleRowScope

    interface Factory {

packages/SystemUI/tests/src/com/android/systemui/lifecycle/HydratorTest.kt

+1 −0
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ import androidx.compose.ui.test.junit4.createComposeRule 
import androidx.test.ext.junit.runners.AndroidJUnit4

import androidx.test.filters.SmallTest

import com.android.systemui.SysuiTestCase

import com.android.systemui.ui.viewmodel.FakeSysUiViewModel

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.map

import org.junit.Rule

packages/SystemUI/tests/src/com/android/systemui/lifecycle/SysUiViewModelTest.kt

+1 −0
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ import androidx.compose.ui.test.junit4.createComposeRule 
import androidx.test.ext.junit.runners.AndroidJUnit4

import androidx.test.filters.SmallTest

import com.android.systemui.SysuiTestCase

import com.android.systemui.ui.viewmodel.FakeSysUiViewModel

import com.android.systemui.util.Assert

import com.google.common.truth.Truth.assertThat

import kotlinx.coroutines.awaitCancellation