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

Commit ceb61251 authored by Alejandro Nijamkin's avatar Alejandro Nijamkin
Browse files

[flexiglass] Container config - data layer. 

The container configuration portion of the Flexiglass framework allows
OEMs to configure one or more Flexiglass containers with scenes.
Each scene is a distinct bit of UI content that the user can navigate to (for example by swiping in a direction) or that can
be navigated to automatically through the SceneInteractor methods.

Bug: 279501596
Test: Included unit tests. Manually tested through a testbed app that
uses Jetpack Compose to implement a simple UI to traverse all scenes.

Change-Id: I71bc7ea373d23312e3b4e861fa061a3cd825e938
parent d373da3c

packages/SystemUI/src/com/android/systemui/scene/data/model/SceneContainerConfig.kt

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

 * Copyright (C) 2023 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.scene.data.model



import com.android.systemui.scene.shared.model.SceneKey



/** Models the configuration of a single scene container. */

data class SceneContainerConfig(

    /** Container name. Must be unique across all containers in System UI. */

    val name: String,



    /**

     * The keys to all scenes in the container, sorted by z-order such that the last one renders on

     * top of all previous ones. Scene keys within the same container must not repeat but it's okay

     * to have the same scene keys in different containers.

     */

    val sceneKeys: List<SceneKey>,



    /**

     * The key of the scene that is the initial current scene when the container is first set up,

     * before taking any application state in to account.

     */

    val initialSceneKey: SceneKey,

) {

    init {

        check(sceneKeys.isNotEmpty()) { "A container must have at least one scene key." }



        check(sceneKeys.contains(initialSceneKey)) {

            "The initial key \"$initialSceneKey\" is not present in this container."

        }

    }

}

packages/SystemUI/src/com/android/systemui/scene/data/repository/SceneContainerRepository.kt

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

 * Copyright (C) 2023 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.scene.data.repository



import com.android.systemui.scene.data.model.SceneContainerConfig

import com.android.systemui.scene.shared.model.SceneKey

import com.android.systemui.scene.shared.model.SceneModel

import javax.inject.Inject

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow



/** Source of truth for scene framework application state. */

class SceneContainerRepository

@Inject

constructor(

    containerConfigurations: Set<SceneContainerConfig>,

) {



    private val containerConfigByName: Map<String, SceneContainerConfig> =

        containerConfigurations.associateBy { config -> config.name }

    private val containerVisibilityByName: Map<String, MutableStateFlow<Boolean>> =

        containerConfigByName

            .map { (containerName, _) -> containerName to MutableStateFlow(true) }

            .toMap()

    private val currentSceneByContainerName: Map<String, MutableStateFlow<SceneModel>> =

        containerConfigByName

            .map { (containerName, config) ->

                containerName to MutableStateFlow(SceneModel(config.initialSceneKey))

            }

            .toMap()

    private val sceneTransitionProgressByContainerName: Map<String, MutableStateFlow<Float>> =

        containerConfigByName

            .map { (containerName, _) -> containerName to MutableStateFlow(1f) }

            .toMap()



    init {

        val repeatedContainerNames =

            containerConfigurations

                .groupingBy { config -> config.name }

                .eachCount()

                .filter { (_, count) -> count > 1 }

        check(repeatedContainerNames.isEmpty()) {

            "Container names must be unique. The following container names appear more than once: ${

                repeatedContainerNames

                        .map { (name, count) -> "\"$name\" appears $count times" }

                        .joinToString(", ")

            }"

        }

    }



    /**

     * Returns the keys to all scenes in the container with the given name.

     *

     * The scenes will be sorted in z-order such that the last one is the one that should be

     * rendered on top of all previous ones.

     */

    fun allSceneKeys(containerName: String): List<SceneKey> {

        return containerConfigByName[containerName]?.sceneKeys

            ?: error(noSuchContainerErrorMessage(containerName))

    }



    /** Sets the current scene in the container with the given name. */

    fun setCurrentScene(containerName: String, scene: SceneModel) {

        check(allSceneKeys(containerName).contains(scene.key)) {

            """

                Cannot set current scene key to "${scene.key}". The container "$containerName" does

                not contain a scene with that key.

            """

                .trimIndent()

        }



        currentSceneByContainerName.setValue(containerName, scene)

    }



    /** The current scene in the container with the given name. */

    fun currentScene(containerName: String): StateFlow<SceneModel> {

        return currentSceneByContainerName.mutableOrError(containerName).asStateFlow()

    }



    /** Sets whether the container with the given name is visible. */

    fun setVisible(containerName: String, isVisible: Boolean) {

        containerVisibilityByName.setValue(containerName, isVisible)

    }



    /** Whether the container with the given name should be visible. */

    fun isVisible(containerName: String): StateFlow<Boolean> {

        return containerVisibilityByName.mutableOrError(containerName).asStateFlow()

    }



    /** Sets scene transition progress to the current scene in the container with the given name. */

    fun setSceneTransitionProgress(containerName: String, progress: Float) {

        sceneTransitionProgressByContainerName.setValue(containerName, progress)

    }



    /** Progress of the transition into the current scene in the container with the given name. */

    fun sceneTransitionProgress(containerName: String): StateFlow<Float> {

        return sceneTransitionProgressByContainerName.mutableOrError(containerName).asStateFlow()

    }



    private fun <T> Map<String, MutableStateFlow<T>>.mutableOrError(

        containerName: String,

    ): MutableStateFlow<T> {

        return this[containerName] ?: error(noSuchContainerErrorMessage(containerName))

    }



    private fun <T> Map<String, MutableStateFlow<T>>.setValue(

        containerName: String,

        value: T,

    ) {

        val mutable = mutableOrError(containerName)

        mutable.value = value

    }



    private fun noSuchContainerErrorMessage(containerName: String): String {

        return """

            No container named "$containerName". Existing containers:

            ${containerConfigByName.values.joinToString(", ") { it.name }}

        """

            .trimIndent()

    }

}

packages/SystemUI/src/com/android/systemui/scene/shared/model/Scene.kt

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

 * Copyright (C) 2023 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.scene.shared.model



import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow



/**

 * Defines interface for classes that can describe a "scene".

 *

 * In the scene framework, there can be multiple scenes in a single scene "container". The container

 * takes care of rendering the current scene and allowing scenes to be switched from one to another

 * based on either user action (for example, swiping down while on the lock screen scene may switch

 * to the shade scene).

 *

 * The framework also supports multiple containers, each one with its own configuration.

 */

interface Scene {



    /** Uniquely-identifying key for this scene. The key must be unique within its container. */

    val key: SceneKey



    /**

     * Returns a mapping between [UserAction] and flows that emit a [SceneModel].

     *

     * When the scene framework detects the user action, it starts a transition to the scene

     * described by the latest value in the flow that's mapped from that user action.

     *

     * Once the [Scene] becomes the current one, the scene framework will invoke this method and set

     * up collectors to watch for new values emitted to each of the flows. If a value is added to

     * the map at a given [UserAction], the framework will set up user input handling for that

     * [UserAction] and, if such a user action is detected, the framework will initiate a transition

     * to that [SceneModel].

     *

     * Note that calling this method does _not_ mean that the given user action has occurred.

     * Instead, the method is called before any user action/gesture is detected so that the

     * framework can decide whether to set up gesture/input detectors/listeners for that type of

     * user action.

     *

     * Note that a missing value for a specific [UserAction] means that the user action of the given

     * type is not currently active in the scene and should be ignored by the framework, while the

     * current scene is this one.

     *

     * The API is designed such that it's possible to emit ever-changing values for each

     * [UserAction] to enable, disable, or change the destination scene of a given user action.

     */

    fun destinationScenes(): StateFlow<Map<UserAction, SceneModel>> =

        MutableStateFlow(emptyMap<UserAction, SceneModel>()).asStateFlow()

}



/** Enumerates all scene framework supported user actions. */

sealed interface UserAction {



    /** The user is scrolling, dragging, swiping, or flinging. */

    data class Swipe(

        /** The direction of the swipe. */

        val direction: Direction,

        /** The number of pointers that were used (for example, one or two fingers). */

        val pointerCount: Int = 1,

    ) : UserAction



    /** The user has hit the back button or performed the back navigation gesture. */

    object Back : UserAction

}



/** Enumerates all known "cardinal" directions for user actions. */

enum class Direction {

    LEFT,

    UP,

    RIGHT,

    DOWN,

}

packages/SystemUI/src/com/android/systemui/scene/shared/model/SceneKey.kt

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

 * Copyright (C) 2023 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.scene.shared.model



/** Keys of all known scenes. */

sealed class SceneKey(

    private val loggingName: String,

) {

    /**

     * The bouncer is the scene that displays authentication challenges like PIN, password, or

     * pattern.

     */

    object Bouncer : SceneKey("bouncer")



    /**

     * "Gone" is not a real scene but rather the absence of scenes when we want to skip showing any

     * content from the scene framework.

     */

    object Gone : SceneKey("gone")



    /** The lock screen is the scene that shows when the device is locked. */

    object LockScreen : SceneKey("lockscreen")



    /**

     * The shade is the scene whose primary purpose is to show a scrollable list of notifications.

     */

    object Shade : SceneKey("shade")



    /** The quick settings scene shows the quick setting tiles. */

    object QuickSettings : SceneKey("quick_settings")



    override fun toString(): String {

        return loggingName

    }

}

packages/SystemUI/src/com/android/systemui/scene/shared/model/SceneModel.kt

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

 * Copyright (C) 2023 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.scene.shared.model



/** Models a scene. */

data class SceneModel(



    /** The key of the scene. */

    val key: SceneKey,



    /** An optional name for the transition that led to this scene being the current scene. */

    val transitionName: String? = null,

)