@iternio/react-native-auto-play 0.0.1

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/hybrid/HybridAutoPlay.kt

@@ -0,0 +1,279 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.car.app.Screen
+import com.facebook.react.bridge.UiThreadUtil
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.MessageTemplate
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.utils.ThreadUtil
+
+class HybridAutoPlay : HybridAutoPlaySpec() {
+    override fun addListener(
+        eventType: EventName, callback: () -> Unit
+    ): () -> Unit {
+        val callbacks = listeners.getOrPut(eventType) { mutableListOf() }
+        callbacks.add(callback)
+
+        if (eventType == EventName.DIDCONNECT && AndroidAutoSession.Companion.getIsConnected()) {
+            callback()
+        }
+
+        return {
+            listeners[eventType]?.removeAll { it === callback }
+        }
+    }
+
+    override fun isConnected(): Boolean {
+        return AndroidAutoSession.getIsConnected()
+    }
+
+    override fun addListenerRenderState(
+        moduleName: String, callback: (VisibilityState) -> Unit
+    ): () -> Unit {
+        val callbacks = renderStateListeners.getOrPut(moduleName) {
+            mutableListOf()
+        }
+        callbacks.add(callback)
+
+        if (moduleName == "main") {
+            callback(ActivityRenderStateProvider.currentState)
+        } else {
+            AndroidAutoSession.Companion.getState(moduleName)?.let {
+                callback(it)
+            }
+        }
+
+        return {
+            renderStateListeners[moduleName]?.let {
+                it.remove(callback)
+                if (it.isEmpty()) {
+                    renderStateListeners.remove(moduleName)
+                }
+            }
+        }
+    }
+
+    override fun addSafeAreaInsetsListener(
+        moduleName: String, callback: (SafeAreaInsets) -> Unit
+    ): () -> Unit {
+        val callbacks = safeAreaInsetsListeners.getOrPut(moduleName) {
+            mutableListOf()
+        }
+        callbacks.add(callback)
+
+        return {
+            safeAreaInsetsListeners[moduleName]?.let {
+                it.remove(callback)
+                if (it.isEmpty()) {
+                    safeAreaInsetsListeners.remove(moduleName)
+                }
+            }
+        }
+    }
+
+    override fun setTemplateHeaderActions(
+        templateId: String, headerActions: Array<NitroAction>?
+    ) {
+        val template =
+            AndroidAutoTemplate.Companion.getTemplate(templateId) ?: throw IllegalArgumentException(
+                "setTemplateHeaderActions failed, template $templateId not found"
+            )
+        template.setTemplateHeaderActions(headerActions)
+    }
+
+    override fun setRootTemplate(templateId: String): Promise<Unit> {
+        return Promise.Companion.async {
+            val template = AndroidAutoTemplate.Companion.getTemplate(templateId)
+                ?: throw IllegalArgumentException("setRootTemplate failed, $templateId template not found")
+
+            if (template.isRenderTemplate) {
+                val screen = AndroidAutoScreen.Companion.getScreen(templateId)
+                    ?: throw IllegalArgumentException("setRootTemplate failed, $templateId screen not found")
+                val carContext = AndroidAutoSession.Companion.getCarContext(templateId)
+                    ?: throw IllegalArgumentException("setRootTemplate failed, carContext for $templateId template not found")
+
+                screen.applyConfigUpdate(invalidate = true)
+
+                if (!VirtualRenderer.Companion.hasRenderer(templateId)) {
+                    val result = ThreadUtil.postOnUiAndAwait {
+                        VirtualRenderer(carContext, templateId)
+                    }
+                    if (result.isFailure) {
+                        throw result.exceptionOrNull()
+                            ?: UnknownError("unknown error initializing the virtual screen")
+                    }
+                }
+            } else {
+                val screenManager = AndroidAutoScreen.Companion.getScreenManager()
+                    ?: throw IllegalArgumentException("setRootTemplate failed, screenManager not found")
+                val carContext =
+                    AndroidAutoSession.Companion.getCarContext(AndroidAutoSession.Companion.ROOT_SESSION)
+                        ?: throw IllegalArgumentException("setRootTemplate failed, carContext for $templateId template not found")
+
+                val result = ThreadUtil.postOnUiAndAwait {
+                    screenManager.popToRoot()
+                    val previousRootScreen = screenManager.top
+
+                    val screen = AndroidAutoScreen(carContext, templateId, template.parse())
+                    screenManager.push(screen)
+
+                    screenManager.remove(previousRootScreen)
+                }
+
+                if (result.isFailure) {
+                    throw result.exceptionOrNull()
+                        ?: UnknownError("unknown error setting root template")
+                }
+            }
+        }
+    }
+
+    override fun pushTemplate(templateId: String): Promise<Unit> {
+        return Promise.Companion.async {
+            val context = AndroidAutoSession.Companion.getRootContext()
+                ?: throw IllegalArgumentException("pushTemplate failed, carContext not found")
+            val template = AndroidAutoTemplate.Companion.getTemplate(templateId)
+                ?: throw IllegalArgumentException("pushTemplate failed, template $templateId not found")
+            val screenManager = AndroidAutoScreen.Companion.getScreenManager()
+                ?: throw IllegalArgumentException("pushTemplate failed, screenManager not found")
+
+            val result = ThreadUtil.postOnUiAndAwait {
+                var topMessageScreen: Screen? = null
+
+                if (screenManager.screenStack.isNotEmpty()) {
+                    screenManager.top.marker?.let {
+                        if (AndroidAutoTemplate.hasTemplate<MessageTemplate>(it)) {
+                            topMessageScreen = screenManager.top
+                        }
+                    }
+                }
+                val screen = AndroidAutoScreen(context, templateId, template.parse())
+                screenManager.push(screen)
+
+                template.autoDismissMs?.let {
+                    UiThreadUtil.runOnUiThread({
+                        val screen =
+                            if (screenManager.screenStack.isNotEmpty()) screenManager.top else null
+                        if (screen?.marker == templateId) {
+                            screenManager.remove(screen)
+                        }
+                    }, it.toLong())
+                }
+
+                topMessageScreen?.let {
+                    if (AndroidAutoTemplate.hasTemplate<MessageTemplate>(templateId)) {
+                        screenManager.remove(topMessageScreen)
+                    } else {
+                        screenManager.push(topMessageScreen)
+                    }
+                }
+            }
+
+            if (result.isFailure) {
+                throw result.exceptionOrNull() ?: UnknownError("unknown error pushing template")
+            }
+        }
+    }
+
+    override fun popTemplate(animate: Boolean?): Promise<Unit> {
+        return Promise.Companion.async {
+            val screenManager = AndroidAutoScreen.Companion.getScreenManager()
+                ?: throw IllegalArgumentException("popTemplate failed, screenManager not found")
+            if (screenManager.stackSize == 0) {
+                return@async
+            }
+
+            val result = ThreadUtil.postOnUiAndAwait {
+                screenManager.pop()
+            }
+
+            if (result.isFailure) {
+                throw result.exceptionOrNull() ?: UnknownError("unknown error popping template")
+            }
+        }
+    }
+
+    override fun popToRootTemplate(animate: Boolean?): Promise<Unit> {
+        return Promise.Companion.async {
+            val screenManager = AndroidAutoScreen.Companion.getScreenManager()
+                ?: throw IllegalArgumentException("popToRootTemplate failed, screenManager not found")
+            if (screenManager.stackSize == 0) {
+                return@async
+            }
+
+            val result = ThreadUtil.postOnUiAndAwait {
+                screenManager.popToRoot()
+            }
+
+            if (result.isFailure) {
+                throw result.exceptionOrNull() ?: UnknownError("unknown error popping template")
+            }
+        }
+    }
+
+    override fun popToTemplate(templateId: String, animate: Boolean?): Promise<Unit> {
+        return Promise.Companion.async {
+            val screenManager = AndroidAutoScreen.Companion.getScreenManager()
+                ?: throw IllegalArgumentException("popToTemplate failed, screenManager not found")
+            if (screenManager.stackSize == 0) {
+                return@async
+            }
+
+            val result = ThreadUtil.postOnUiAndAwait {
+                screenManager.popTo(templateId)
+            }
+
+            if (result.isFailure) {
+                throw result.exceptionOrNull()
+                    ?: UnknownError("unknown error popping template $templateId")
+            }
+        }
+    }
+
+    companion object {
+        const val TAG = "HybridAutoPlay"
+
+        private val listeners = mutableMapOf<EventName, MutableList<() -> Unit>>()
+
+        private val renderStateListeners =
+            mutableMapOf<String, MutableList<(VisibilityState) -> Unit>>()
+        private val safeAreaInsetsListeners =
+            mutableMapOf<String, MutableList<(SafeAreaInsets) -> Unit>>()
+
+
+        fun removeListeners(templateId: String) {
+            renderStateListeners.remove(templateId)
+            safeAreaInsetsListeners.remove(templateId)
+        }
+
+        fun emit(event: EventName) {
+            listeners[event]?.forEach { it() }
+        }
+
+        fun emitRenderState(moduleName: String, state: VisibilityState) {
+            renderStateListeners[moduleName]?.forEach {
+                it(state)
+            }
+        }
+
+        fun emitSafeAreaInsets(
+            moduleName: String,
+            top: Double,
+            bottom: Double,
+            left: Double,
+            right: Double,
+            isLegacyLayout: Boolean
+        ) {
+            val insets = SafeAreaInsets(
+                top = top,
+                bottom = bottom,
+                left = left,
+                right = right,
+                isLegacyLayout = isLegacyLayout
+            )
+            safeAreaInsetsListeners[moduleName]?.forEach {
+                it(insets)
+            }
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/hybrid/HybridCluster.kt

@@ -0,0 +1,92 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.utils.ThreadUtil
+
+class HybridCluster : HybridClusterSpec() {
+    override fun addListener(
+        eventType: ClusterEventName, callback: (String) -> Unit
+    ): () -> Unit {
+        val callbacks = listeners.getOrPut(eventType) { mutableListOf() }
+        callbacks.add(callback)
+
+        eventQueue[eventType]?.forEach {
+            callback(it)
+        }
+        eventQueue[eventType] = emptyArray<String>()
+
+        return {
+            listeners[eventType]?.removeAll { it === callback }
+        }
+    }
+
+    override fun initRootView(clusterId: String): Promise<Unit> {
+        return Promise.async {
+            if (VirtualRenderer.hasRenderer(clusterId)) {
+                return@async
+            }
+            val carContext = AndroidAutoSession.getCarContext(clusterId)
+                ?: throw IllegalArgumentException("initRootView failed, carContext for $clusterId cluster not found")
+            val result = ThreadUtil.postOnUiAndAwait {
+                VirtualRenderer(carContext, clusterId)
+            }
+            if (result.isFailure) {
+                throw result.exceptionOrNull()
+                    ?: UnknownError("unknown error initializing the virtual screen")
+            }
+        }
+    }
+
+    override fun setAttributedInactiveDescriptionVariants(
+        clusterId: String, attributedInactiveDescriptionVariants: Array<NitroAttributedString>
+    ) {
+        throw IllegalAccessException("setAttributedInactiveDescriptionVariants is supported on iOS only")
+    }
+
+    override fun addListenerColorScheme(callback: (String, ColorScheme) -> Unit): () -> Unit {
+        colorSchemeListeners.add(callback)
+
+        return {
+            colorSchemeListeners.remove(callback)
+        }
+    }
+
+    override fun addListenerZoom(callback: (String, ZoomEvent) -> Unit): () -> Unit {
+        throw IllegalAccessException("addListenerZoom is supported on iOS only")
+    }
+
+    override fun addListenerCompass(callback: (String, Boolean) -> Unit): () -> Unit {
+        throw IllegalAccessException("addListenerCompass is supported on iOS only")
+    }
+
+    override fun addListenerSpeedLimit(callback: (String, Boolean) -> Unit): () -> Unit {
+        throw IllegalAccessException("addListenerSpeedLimit is supported on iOS only")
+    }
+
+    companion object {
+        const val TAG = "HybridCluster"
+
+        private val listeners =
+            mutableMapOf<ClusterEventName, MutableList<(clusterId: String) -> Unit>>()
+        private val eventQueue = mutableMapOf<ClusterEventName, Array<String>>()
+
+        private val colorSchemeListeners =
+            mutableListOf<(clusterId: String, colorScheme: ColorScheme) -> Unit>()
+
+        fun emit(event: ClusterEventName, clusterId: String) {
+            if (listeners[event].isNullOrEmpty()) {
+                val clusterIds = eventQueue.getOrPut(event) { emptyArray<String>() }
+                eventQueue[event] = clusterIds.plus(clusterId)
+                return
+            }
+
+            listeners[event]?.forEach { it(clusterId) }
+        }
+
+        fun emitColorScheme(clusterId: String, colorScheme: ColorScheme) {
+            colorSchemeListeners.forEach {
+                it(clusterId, colorScheme)
+            }
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/hybrid/HybridGridTemplate.kt

@@ -0,0 +1,21 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.GridTemplate
+
+class HybridGridTemplate : HybridGridTemplateSpec() {
+    override fun createGridTemplate(config: GridTemplateConfig) {
+        val context = AndroidAutoSession.getRootContext()
+            ?: throw IllegalArgumentException("createGridTemplate failed, carContext found")
+
+        val template = GridTemplate(context, config)
+        AndroidAutoTemplate.setTemplate(config.id, template)
+    }
+
+    override fun updateGridTemplateButtons(
+        templateId: String, buttons: Array<NitroGridButton>
+    ) {
+        val template = AndroidAutoTemplate.getTemplate<GridTemplate>(templateId)
+        template.updateButtons(buttons)
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/hybrid/HybridInformationTemplate.kt

@@ -0,0 +1,22 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.InformationTemplate
+
+class HybridInformationTemplate : HybridInformationTemplateSpec() {
+    override fun createInformationTemplate(config: InformationTemplateConfig) {
+        val context = AndroidAutoSession.getRootContext()
+            ?: throw IllegalArgumentException("createInformationTemplate failed, carContext not found")
+
+        val template = InformationTemplate(context, config)
+        AndroidAutoTemplate.setTemplate(config.id, template)
+    }
+
+    override fun updateInformationTemplateSections(
+        templateId: String,
+        section: NitroSection
+    ) {
+        val template = AndroidAutoTemplate.getTemplate<InformationTemplate>(templateId)
+        template.updateSection(section)
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/hybrid/HybridListTemplate.kt

@@ -0,0 +1,22 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.ListTemplate
+
+class HybridListTemplate : HybridListTemplateSpec() {
+
+    override fun createListTemplate(config: ListTemplateConfig) {
+        val context = AndroidAutoSession.getRootContext()
+            ?: throw IllegalArgumentException("createListTemplate failed, carContext not found")
+
+        val template = ListTemplate(context, config)
+        AndroidAutoTemplate.setTemplate(config.id, template)
+    }
+
+    override fun updateListTemplateSections(
+        templateId: String, sections: Array<NitroSection>?
+    ) {
+        val template = AndroidAutoTemplate.getTemplate<ListTemplate>(templateId)
+        template.updateSections(sections)
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/hybrid/HybridMapTemplate.kt

@@ -0,0 +1,134 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.car.app.AppManager
+import com.facebook.react.bridge.UiThreadUtil
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.MapTemplate
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.RoutePreviewTemplate
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.TripPreviewTemplate
+
+class HybridMapTemplate : HybridMapTemplateSpec() {
+    override fun createMapTemplate(config: MapTemplateConfig) {
+        val context =
+            AndroidAutoSession.getCarContext(config.id) ?: throw IllegalArgumentException(
+                "createMapTemplate failed, carContext found"
+            )
+
+        val template = MapTemplate(context, config, initNavigationManager = true)
+        AndroidAutoTemplate.setTemplate(config.id, template)
+    }
+
+    override fun showNavigationAlert(
+        templateId: String,
+        alert: NitroNavigationAlert
+    ): NavigationAlertCallbacks {
+        val template = AndroidAutoTemplate.getTemplate<MapTemplate>(templateId)
+        template.showAlert(alert)
+
+        return NavigationAlertCallbacks(
+            dismiss = {
+                val carContext =
+                    AndroidAutoSession.getCarContext(AndroidAutoSession.ROOT_SESSION)
+                        ?: throw IllegalArgumentException("navigation alert dismiss failed, carContext for ${AndroidAutoSession.ROOT_SESSION} not found")
+
+                carContext.getCarService(AppManager::class.java).dismissAlert(alert.id.toInt())
+            },
+            update = { title, subtitle ->
+                val config = alert.copy(title = title, subtitle = subtitle)
+                template.showAlert(config)
+            }
+        )
+    }
+
+    override fun showTripSelector(
+        templateId: String,
+        trips: Array<TripsConfig>,
+        selectedTripId: String?,
+        textConfig: TripPreviewTextConfiguration,
+        onTripSelected: (tripId: String, routeId: String) -> Unit,
+        onTripStarted: (tripId: String, routeId: String) -> Unit,
+        onBackPressed: () -> Unit,
+        mapButtons: Array<NitroMapButton>
+    ): TripSelectorCallback {
+        val context = AndroidAutoSession.getRootContext()
+            ?: throw IllegalArgumentException("showTripSelector failed, carContext not found")
+        val screenManager = AndroidAutoScreen.getScreenManager()
+            ?: throw IllegalArgumentException("showTripSelector failed, screenManager not found")
+
+        val screen = TripPreviewTemplate(
+            context,
+            trips,
+            selectedTripId,
+            textConfig,
+            onTripSelected,
+            onTripStarted,
+            onBackPressed,
+            mapButtons
+        )
+
+        UiThreadUtil.runOnUiThread {
+            screenManager.popToRoot()
+            screenManager.push(screen)
+        }
+
+        return TripSelectorCallback { id: String ->
+            UiThreadUtil.runOnUiThread {
+                if (screenManager.top.marker == RoutePreviewTemplate.TAG) {
+                    screenManager.popTo(TripPreviewTemplate.TAG)
+                }
+            }
+
+            val selectedTripIndex = trips.indexOfFirst { trip -> trip.id == id }
+            screen.selectedTripIndex = selectedTripIndex
+            screen.invalidate()
+        }
+    }
+
+    override fun hideTripSelector(templateId: String) {
+        val screenManager = AndroidAutoScreen.getScreenManager()
+            ?: throw IllegalArgumentException("hideTripSelector failed, screenManager not found")
+        val screens = screenManager.screenStack.filter {
+            it.marker == TripPreviewTemplate.TAG || it.marker == RoutePreviewTemplate.TAG
+        }
+
+        UiThreadUtil.runOnUiThread {
+            screens.forEach {
+                it.finish()
+            }
+        }
+    }
+
+    override fun setTemplateMapButtons(
+        templateId: String, buttons: Array<NitroMapButton>?
+    ) {
+        val template = AndroidAutoTemplate.getTemplate<MapTemplate>(templateId)
+        template.setMapActions(buttons)
+    }
+
+    override fun updateVisibleTravelEstimate(
+        templateId: String, visibleTravelEstimate: VisibleTravelEstimate
+    ) {
+        val template = AndroidAutoTemplate.getTemplate<MapTemplate>(templateId)
+        template.updateVisibleTravelEstimate(visibleTravelEstimate)
+    }
+
+    override fun updateTravelEstimates(templateId: String, steps: Array<TripPoint>) {
+        MapTemplate.updateTravelEstimates(steps)
+    }
+
+    override fun updateManeuvers(
+        templateId: String, maneuvers: NitroManeuver
+    ) {
+        MapTemplate.updateManeuvers(maneuvers)
+    }
+
+    override fun startNavigation(
+        templateId: String, trip: TripConfig
+    ) {
+        MapTemplate.startNavigation(trip)
+    }
+
+    override fun stopNavigation(templateId: String) {
+        MapTemplate.stopNavigation()
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/hybrid/HybridMessageTemplate.kt

@@ -0,0 +1,15 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.MessageTemplate
+
+class HybridMessageTemplate : HybridMessageTemplateSpec() {
+
+    override fun createMessageTemplate(config: MessageTemplateConfig) {
+        val context = AndroidAutoSession.getRootContext()
+            ?: throw IllegalArgumentException("createMessageTemplate failed, carContext not found")
+
+        val template = MessageTemplate(context, config)
+        AndroidAutoTemplate.setTemplate(config.id, template)
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/hybrid/HybridSearchTemplate.kt

@@ -0,0 +1,20 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.SearchTemplate
+
+class HybridSearchTemplate : HybridSearchTemplateSpec() {
+
+    override fun createSearchTemplate(config: SearchTemplateConfig) {
+        val context = AndroidAutoSession.Companion.getRootContext()
+            ?: throw IllegalArgumentException("createSearchTemplate failed, carContext not found")
+
+        val template = SearchTemplate(context, config)
+        AndroidAutoTemplate.Companion.setTemplate(config.id, template)
+    }
+
+    override fun updateSearchResults(templateId: String, results: NitroSection) {
+        val template = AndroidAutoTemplate.Companion.getTemplate<SearchTemplate>(templateId)
+        template.updateSearchResults(results)
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/template/AndroidAutoTemplate.kt

@@ -0,0 +1,60 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay.template
+
+import androidx.car.app.CarContext
+import androidx.car.app.model.Template
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.AndroidAutoScreen
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroAction
+
+abstract class AndroidAutoTemplate<T>(val context: CarContext, var config: T) {
+    abstract fun parse(): Template
+    abstract fun setTemplateHeaderActions(headerActions: Array<NitroAction>?)
+
+    abstract fun onWillAppear()
+    abstract fun onWillDisappear()
+    abstract fun onDidAppear()
+    abstract fun onDidDisappear()
+    abstract fun onPopped()
+
+    abstract val isRenderTemplate: Boolean
+    abstract val templateId: String
+    abstract val autoDismissMs: Double?
+
+    fun applyConfigUpdate() {
+        val screen = AndroidAutoScreen.getScreen(templateId)
+        screen?.applyConfigUpdate(invalidate = true)
+    }
+
+    companion object {
+        const val TAG = "AndroidAutoTemplate"
+        val templates = mutableMapOf<String, AndroidAutoTemplate<*>>()
+
+        fun <T> setTemplate(id: String, template: AndroidAutoTemplate<T>) {
+            templates.put(id, template)
+        }
+
+        fun getTemplate(id: String): AndroidAutoTemplate<*>? {
+            return templates[id]
+        }
+
+        inline fun <reified T> getTemplate(id: String): T {
+            val template = templates[id] as? T
+            return template ?: throw IllegalArgumentException()
+        }
+
+        inline fun <reified T> hasTemplate(id: String): Boolean {
+            return templates[id] is T
+        }
+
+        fun getConfig(id: String): Any? {
+            return templates[id]?.config
+        }
+
+        inline fun <reified T> getTypedConfig(id: String): T? {
+            val config = templates[id]?.config
+            if (config is T) {
+                return config
+            }
+            return null
+        }
+    }
+}