@amazon-devices/react-native-screens 2.0.1758683737

package/android/build.gradle

@@ -0,0 +1,133 @@
+import com.android.Version
+
+buildscript {
+    ext {
+        rnsDefaultTargetSdkVersion = 34
+        rnsDefaultCompileSdkVersion = 34
+        rnsDefaultMinSdkVersion = 21
+        rnsDefaultKotlinVersion = '1.8.0'
+    }
+    ext.safeExtGet = {prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath('com.android.tools.build:gradle:4.2.2')
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet('kotlinVersion', rnsDefaultKotlinVersion)}"
+        classpath "com.diffplug.spotless:spotless-plugin-gradle:6.11.0"
+    }
+}
+
+def isNewArchitectureEnabled() {
+    // To opt-in for the New Architecture, you can either:
+    // - Set `newArchEnabled` to true inside the `gradle.properties` file
+    // - Invoke gradle with `-newArchEnabled=true`
+    // - Set an environment variable `ORG_GRADLE_PROJECT_newArchEnabled=true`
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+// spotless is only accessible within react-native-screens repo
+if (project == rootProject) {
+    apply from: 'spotless.gradle'
+}
+
+if (isNewArchitectureEnabled()) {
+    apply plugin: "com.facebook.react"
+}
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+def reactNativeArchitectures() {
+    def value = project.getProperties().get("reactNativeArchitectures")
+    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+android {
+    compileSdkVersion safeExtGet('compileSdkVersion', rnsDefaultCompileSdkVersion)
+    def agpVersion = Version.ANDROID_GRADLE_PLUGIN_VERSION
+    if (agpVersion.tokenize('.')[0].toInteger() >= 7) {
+        namespace "com.swmansion.rnscreens"
+    }
+
+    // Used to override the NDK path/version on internal CI or by allowing
+    // users to customize the NDK path/version from their root project (e.g. for M1 support)
+    if (rootProject.hasProperty("ndkPath")) {
+        ndkPath rootProject.ext.ndkPath
+    }
+    if (rootProject.hasProperty("ndkVersion")) {
+        ndkVersion rootProject.ext.ndkVersion
+    }
+
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', rnsDefaultMinSdkVersion)
+        targetSdkVersion safeExtGet('targetSdkVersion', rnsDefaultTargetSdkVersion)
+        versionCode 1
+        versionName "1.0"
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+        ndk {
+            abiFilters (*reactNativeArchitectures())
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    packagingOptions {
+        // For some reason gradle only complains about the duplicated version of libreact_render libraries
+        // while there are more libraries copied in intermediates folder of the lib build directory, we exclude
+        // only the ones that make the build fail (ideally we should only include librnscreens_modules but we
+        // are only allowed to specify exclude patterns)
+        exclude "**/libreact_render*.so"
+    }
+    sourceSets.main {
+        ext.androidResDir = "src/main/res"
+        java {
+            if (isNewArchitectureEnabled()) {
+                srcDirs += [
+                    "src/fabric/java",
+                ]
+            } else {
+                srcDirs += [
+                    "src/paper/java",
+                    "build/generated/source/codegen/java"
+                ]
+            }
+
+        }
+        res {
+            if (safeExtGet('compileSdkVersion', rnsDefaultCompileSdkVersion) >= 33) {
+                srcDirs = ["${androidResDir}/base", "${androidResDir}/v33"]
+            } else {
+                srcDirs = ["${androidResDir}/base"]
+            }
+        }
+    }
+}
+
+repositories {
+    maven {
+        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+        // Matches the RN Hello World template
+        // https://github.com/facebook/react-native/blob/1e8f3b11027fe0a7514b4fc97d0798d3c64bc895/local-cli/templates/HelloWorld/android/build.gradle#L21
+        url "$projectDir/../node_modules/react-native/android"
+    }
+    mavenCentral()
+    mavenLocal()
+    google()
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-native:+'
+    implementation 'androidx.appcompat:appcompat:1.6.1'
+    implementation 'androidx.fragment:fragment-ktx:1.6.1'
+    implementation 'androidx.coordinatorlayout:coordinatorlayout:1.2.0'
+    implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.1.0'
+    implementation 'com.google.android.material:material:1.9.0'
+    implementation "androidx.core:core-ktx:1.10.1"
+}

package/android/src/fabric/java/com/swmansion/rnscreens/FabricEnabledViewGroup.kt

@@ -0,0 +1,49 @@
+package com.swmansion.rnscreens
+
+import android.view.ViewGroup
+import androidx.annotation.UiThread
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.uimanager.FabricViewStateManager
+import com.facebook.react.uimanager.PixelUtil
+import kotlin.math.abs
+
+abstract class FabricEnabledViewGroup constructor(context: ReactContext?) : ViewGroup(context), FabricViewStateManager.HasFabricViewStateManager {
+    private val mFabricViewStateManager: FabricViewStateManager = FabricViewStateManager()
+
+    override fun getFabricViewStateManager(): FabricViewStateManager {
+        return mFabricViewStateManager
+    }
+
+    protected fun updateScreenSizeFabric(width: Int, height: Int) {
+        updateState(width, height)
+    }
+
+    @UiThread
+    fun updateState(width: Int, height: Int) {
+        val realWidth: Float = PixelUtil.toDIPFromPixel(width.toFloat())
+        val realHeight: Float = PixelUtil.toDIPFromPixel(height.toFloat())
+
+        // Check incoming state values. If they're already the correct value, return early to prevent
+        // infinite UpdateState/SetState loop.
+        val currentState: ReadableMap? = mFabricViewStateManager.getStateData()
+        if (currentState != null) {
+            val delta = 0.9f
+            val stateFrameHeight: Float = if (currentState.hasKey("frameHeight")) currentState.getDouble("frameHeight").toFloat() else 0f
+            val stateFrameWidth: Float = if (currentState.hasKey("frameWidth")) currentState.getDouble("frameWidth").toFloat() else 0f
+            if (abs(stateFrameWidth - realWidth) < delta &&
+                abs(stateFrameHeight - realHeight) < delta
+            ) {
+                return
+            }
+        }
+        mFabricViewStateManager.setState {
+            val map: WritableMap = WritableNativeMap()
+            map.putDouble("frameWidth", realWidth.toDouble())
+            map.putDouble("frameHeight", realHeight.toDouble())
+            map
+        }
+    }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,5 @@
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.swmansion.rnscreens">
+
+</manifest>

package/android/src/main/java/com/swmansion/rnscreens/CustomSearchView.kt

@@ -0,0 +1,77 @@
+package com.swmansion.rnscreens
+
+import android.content.Context
+import androidx.activity.OnBackPressedCallback
+import androidx.appcompat.widget.SearchView
+import androidx.fragment.app.Fragment
+
+class CustomSearchView(context: Context, fragment: Fragment) : SearchView(context) {
+    /*
+        CustomSearchView uses some variables from SearchView. They are listed below with links to documentation
+        isIconified - https://developer.android.com/reference/android/widget/SearchView#setIconified(boolean)
+        maxWidth - https://developer.android.com/reference/android/widget/SearchView#setMaxWidth(int)
+        setOnSearchClickListener - https://developer.android.com/reference/android/widget/SearchView#setOnSearchClickListener(android.view.View.OnClickListener)
+        setOnCloseListener - https://developer.android.com/reference/android/widget/SearchView#setOnCloseListener(android.widget.SearchView.OnCloseListener)
+    */
+    private var mCustomOnCloseListener: OnCloseListener? = null
+    private var mCustomOnSearchClickedListener: OnClickListener? = null
+
+    private var mOnBackPressedCallback: OnBackPressedCallback =
+        object : OnBackPressedCallback(true) {
+            override fun handleOnBackPressed() {
+                isIconified = true
+            }
+        }
+
+    private val backPressOverrider = FragmentBackPressOverrider(fragment, mOnBackPressedCallback)
+
+    var overrideBackAction: Boolean
+        set(value) {
+            backPressOverrider.overrideBackAction = value
+        }
+        get() = backPressOverrider.overrideBackAction
+
+    fun focus() {
+        isIconified = false
+        requestFocusFromTouch()
+    }
+
+    fun clearText() = setQuery("", false)
+
+    fun setText(text: String) = setQuery(text, false)
+
+    override fun setOnCloseListener(listener: OnCloseListener?) {
+        mCustomOnCloseListener = listener
+    }
+
+    override fun setOnSearchClickListener(listener: OnClickListener?) {
+        mCustomOnSearchClickedListener = listener
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        if (!isIconified) {
+            backPressOverrider.maybeAddBackCallback()
+        }
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        backPressOverrider.removeBackCallbackIfAdded()
+    }
+
+    init {
+        super.setOnSearchClickListener { v ->
+            mCustomOnSearchClickedListener?.onClick(v)
+            backPressOverrider.maybeAddBackCallback()
+        }
+
+        super.setOnCloseListener {
+            val result = mCustomOnCloseListener?.onClose() ?: false
+            backPressOverrider.removeBackCallbackIfAdded()
+            result
+        }
+
+        maxWidth = Integer.MAX_VALUE
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/CustomToolbar.kt

@@ -0,0 +1,7 @@
+package com.swmansion.rnscreens
+
+import android.content.Context
+import androidx.appcompat.widget.Toolbar
+
+// This class is used to store config closer to search bar
+open class CustomToolbar(context: Context, val config: ScreenStackHeaderConfig) : Toolbar(context)

package/android/src/main/java/com/swmansion/rnscreens/FragmentBackPressOverrider.kt

@@ -0,0 +1,29 @@
+package com.swmansion.rnscreens
+
+import androidx.activity.OnBackPressedCallback
+import androidx.fragment.app.Fragment
+
+class FragmentBackPressOverrider(
+    private val fragment: Fragment,
+    private val mOnBackPressedCallback: OnBackPressedCallback
+) {
+    private var mIsBackCallbackAdded: Boolean = false
+    var overrideBackAction: Boolean = true
+
+    fun maybeAddBackCallback() {
+        if (!mIsBackCallbackAdded && overrideBackAction) {
+            fragment.activity?.onBackPressedDispatcher?.addCallback(
+                fragment,
+                mOnBackPressedCallback
+            )
+            mIsBackCallbackAdded = true
+        }
+    }
+
+    fun removeBackCallbackIfAdded() {
+        if (mIsBackCallbackAdded) {
+            mOnBackPressedCallback.remove()
+            mIsBackCallbackAdded = false
+        }
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/FragmentHolder.kt

@@ -0,0 +1,7 @@
+package com.swmansion.rnscreens
+
+import androidx.fragment.app.Fragment
+
+interface FragmentHolder {
+    val fragment: Fragment
+}

package/android/src/main/java/com/swmansion/rnscreens/RNScreensPackage.kt

@@ -0,0 +1,21 @@
+package com.swmansion.rnscreens
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class RNScreensPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+        emptyList()
+
+    override fun createViewManagers(reactContext: ReactApplicationContext) =
+        listOf<ViewManager<*, *>>(
+            ScreenContainerViewManager(),
+            ScreenViewManager(),
+            ScreenStackViewManager(),
+            ScreenStackHeaderConfigViewManager(),
+            ScreenStackHeaderSubviewManager(),
+            SearchBarManager()
+        )
+}

package/android/src/main/java/com/swmansion/rnscreens/Screen.kt

@@ -0,0 +1,289 @@
+package com.swmansion.rnscreens
+
+import android.annotation.SuppressLint
+import android.content.pm.ActivityInfo
+import android.graphics.Paint
+import android.os.Parcelable
+import android.util.SparseArray
+import android.util.TypedValue
+import android.view.ViewGroup
+import android.view.WindowManager
+import android.webkit.WebView
+import androidx.core.view.children
+import androidx.fragment.app.Fragment
+import com.facebook.react.bridge.GuardedRunnable
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.UIManagerModule
+import com.swmansion.rnscreens.events.HeaderHeightChangeEvent
+
+@SuppressLint("ViewConstructor")
+class Screen constructor(context: ReactContext?) : FabricEnabledViewGroup(context) {
+    val fragment: Fragment?
+        get() = fragmentWrapper?.fragment
+
+    var fragmentWrapper: ScreenFragmentWrapper? = null
+    var container: ScreenContainer? = null
+    var activityState: ActivityState? = null
+        private set
+    private var mTransitioning = false
+    var stackPresentation = StackPresentation.PUSH
+    var replaceAnimation = ReplaceAnimation.POP
+    var stackAnimation = StackAnimation.DEFAULT
+    var isGestureEnabled = true
+    var screenOrientation: Int? = null
+        private set
+    private var mStatusBarStyle: String? = null
+    private var mStatusBarHidden: Boolean? = null
+    private var mStatusBarTranslucent: Boolean? = null
+    private var mStatusBarColor: Int? = null
+    private var mNavigationBarColor: Int? = null
+    private var mNavigationBarHidden: Boolean? = null
+    var isStatusBarAnimated: Boolean? = null
+    private var mNativeBackButtonDismissalEnabled = true
+
+    init {
+        // we set layout params as WindowManager.LayoutParams to workaround the issue with TextInputs
+        // not displaying modal menus (e.g., copy/paste or selection). The missing menus are due to the
+        // fact that TextView implementation is expected to be attached to window when layout happens.
+        // Then, at the moment of layout it checks whether window type is in a reasonable range to tell
+        // whether it should enable selection controls (see Editor.java#prepareCursorControllers).
+        // With screens, however, the text input component can be laid out before it is attached, in
+        // that case TextView tries to get window type property from the oldest existing parent, which
+        // in this case is a Screen class, as it is the root of the screen that is about to be attached.
+        // Setting params this way is not the most elegant way to solve this problem but workarounds it
+        // for the time being
+        layoutParams = WindowManager.LayoutParams(WindowManager.LayoutParams.TYPE_APPLICATION)
+    }
+
+    override fun dispatchSaveInstanceState(container: SparseArray<Parcelable>) {
+        // do nothing, react native will keep the view hierarchy so no need to serialize/deserialize
+        // view's states. The side effect of restoring is that TextInput components would trigger
+        // set-text events which may confuse text input handling.
+    }
+
+    override fun dispatchRestoreInstanceState(container: SparseArray<Parcelable>) {
+        // ignore restoring instance state too as we are not saving anything anyways.
+    }
+
+    override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+        if (changed) {
+            val width = r - l
+            val height = b - t
+
+            calculateHeaderHeight()
+            if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+                updateScreenSizeFabric(width, height)
+            } else {
+                updateScreenSizePaper(width, height)
+            }
+        }
+    }
+
+    private fun updateScreenSizePaper(width: Int, height: Int) {
+        val reactContext = context as ReactContext
+        reactContext.runOnNativeModulesQueueThread(
+            object : GuardedRunnable(reactContext) {
+                override fun runGuarded() {
+                    reactContext
+                        .getNativeModule(UIManagerModule::class.java)
+                        ?.updateNodeSize(id, width, height)
+                }
+            })
+    }
+
+    val headerConfig: ScreenStackHeaderConfig?
+        get() = children.find { it is ScreenStackHeaderConfig } as? ScreenStackHeaderConfig
+
+    /**
+     * While transitioning this property allows to optimize rendering behavior on Android and provide
+     * a correct blending options for the animated screen. It is turned on automatically by the
+     * container when transitioning is detected and turned off immediately after
+     */
+    fun setTransitioning(transitioning: Boolean) {
+        if (mTransitioning == transitioning) {
+            return
+        }
+        mTransitioning = transitioning
+        val isWebViewInScreen = hasWebView(this)
+        if (isWebViewInScreen && layerType != LAYER_TYPE_HARDWARE) {
+            return
+        }
+        super.setLayerType(
+            if (transitioning && !isWebViewInScreen) LAYER_TYPE_HARDWARE else LAYER_TYPE_NONE,
+            null
+        )
+    }
+
+    private fun hasWebView(viewGroup: ViewGroup): Boolean {
+        for (i in 0 until viewGroup.childCount) {
+            val child = viewGroup.getChildAt(i)
+            if (child is WebView) {
+                return true
+            } else if (child is ViewGroup) {
+                if (hasWebView(child)) {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+
+    override fun setLayerType(layerType: Int, paint: Paint?) {
+        // ignore - layer type is controlled by `transitioning` prop
+    }
+
+    fun setActivityState(activityState: ActivityState) {
+        if (activityState == this.activityState) {
+            return
+        }
+        this.activityState = activityState
+        container?.notifyChildUpdate()
+    }
+
+    fun setScreenOrientation(screenOrientation: String?) {
+        if (screenOrientation == null) {
+            this.screenOrientation = null
+            return
+        }
+        ScreenWindowTraits.applyDidSetOrientation()
+        this.screenOrientation = when (screenOrientation) {
+            "all" -> ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
+            "portrait" -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
+            "portrait_up" -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+            "portrait_down" -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
+            "landscape" -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
+            "landscape_left" -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
+            "landscape_right" -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
+            else -> ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+        }
+
+        fragmentWrapper?.let { ScreenWindowTraits.setOrientation(this, it.tryGetActivity()) }
+    }
+
+    // Accepts one of 4 accessibility flags
+    // developer.android.com/reference/android/view/View#attr_android:importantForAccessibility
+    fun changeAccessibilityMode(mode: Int) {
+        this.importantForAccessibility = mode
+        this.headerConfig?.toolbar?.importantForAccessibility = mode
+    }
+
+    var statusBarStyle: String?
+        get() = mStatusBarStyle
+        set(statusBarStyle) {
+            if (statusBarStyle != null) {
+                ScreenWindowTraits.applyDidSetStatusBarAppearance()
+            }
+            mStatusBarStyle = statusBarStyle
+            fragmentWrapper?.let { ScreenWindowTraits.setStyle(this, it.tryGetActivity(), it.tryGetContext()) }
+        }
+
+    var isStatusBarHidden: Boolean?
+        get() = mStatusBarHidden
+        set(statusBarHidden) {
+            if (statusBarHidden != null) {
+                ScreenWindowTraits.applyDidSetStatusBarAppearance()
+            }
+            mStatusBarHidden = statusBarHidden
+            fragmentWrapper?.let { ScreenWindowTraits.setHidden(this, it.tryGetActivity()) }
+        }
+
+    var isStatusBarTranslucent: Boolean?
+        get() = mStatusBarTranslucent
+        set(statusBarTranslucent) {
+            if (statusBarTranslucent != null) {
+                ScreenWindowTraits.applyDidSetStatusBarAppearance()
+            }
+            mStatusBarTranslucent = statusBarTranslucent
+            fragmentWrapper?.let {
+                ScreenWindowTraits.setTranslucent(
+                    this,
+                    it.tryGetActivity(),
+                    it.tryGetContext()
+                )
+            }
+        }
+
+    var statusBarColor: Int?
+        get() = mStatusBarColor
+        set(statusBarColor) {
+            if (statusBarColor != null) {
+                ScreenWindowTraits.applyDidSetStatusBarAppearance()
+            }
+            mStatusBarColor = statusBarColor
+            fragmentWrapper?.let { ScreenWindowTraits.setColor(this, it.tryGetActivity(), it.tryGetContext()) }
+        }
+
+    var navigationBarColor: Int?
+        get() = mNavigationBarColor
+        set(navigationBarColor) {
+            if (navigationBarColor != null) {
+                ScreenWindowTraits.applyDidSetNavigationBarAppearance()
+            }
+            mNavigationBarColor = navigationBarColor
+            fragmentWrapper?.let { ScreenWindowTraits.setNavigationBarColor(this, it.tryGetActivity()) }
+        }
+
+    var isNavigationBarHidden: Boolean?
+        get() = mNavigationBarHidden
+        set(navigationBarHidden) {
+            if (navigationBarHidden != null) {
+                ScreenWindowTraits.applyDidSetNavigationBarAppearance()
+            }
+            mNavigationBarHidden = navigationBarHidden
+            fragmentWrapper?.let {
+                ScreenWindowTraits.setNavigationBarHidden(
+                    this,
+                    it.tryGetActivity(),
+                )
+            }
+        }
+
+    var nativeBackButtonDismissalEnabled: Boolean
+        get() = mNativeBackButtonDismissalEnabled
+        set(enableNativeBackButtonDismissal) {
+            mNativeBackButtonDismissalEnabled = enableNativeBackButtonDismissal
+        }
+
+    fun calculateHeaderHeight() {
+        val actionBarTv = TypedValue()
+        val resolvedActionBarSize = context.theme.resolveAttribute(android.R.attr.actionBarSize, actionBarTv, true)
+
+        // Check if it's possible to get an attribute from theme context and assign a value from it.
+        // Otherwise, the default value will be returned.
+        val actionBarHeight = TypedValue.complexToDimensionPixelSize(actionBarTv.data, resources.displayMetrics)
+            .takeIf { resolvedActionBarSize }
+            ?.let { PixelUtil.toDIPFromPixel(it.toFloat()).toDouble() } ?: 56.0
+
+        val statusBarHeight = context.resources.getIdentifier("status_bar_height", "dimen", "android")
+            .takeIf { it > 0 }
+            ?.let { (context.resources::getDimensionPixelSize)(it) }
+            ?.let { PixelUtil.toDIPFromPixel(it.toFloat()).toDouble() }
+            ?: 24.0
+
+        val totalHeight = actionBarHeight + statusBarHeight
+        UIManagerHelper.getEventDispatcherForReactTag(context as ReactContext, id)
+            ?.dispatchEvent(HeaderHeightChangeEvent(id, totalHeight))
+    }
+
+    enum class StackPresentation {
+        PUSH, MODAL, TRANSPARENT_MODAL
+    }
+
+    enum class StackAnimation {
+        DEFAULT, NONE, FADE, SLIDE_FROM_BOTTOM, SLIDE_FROM_RIGHT, SLIDE_FROM_LEFT, FADE_FROM_BOTTOM
+    }
+
+    enum class ReplaceAnimation {
+        PUSH, POP
+    }
+
+    enum class ActivityState {
+        INACTIVE, TRANSITIONING_OR_BELOW_TOP, ON_TOP
+    }
+
+    enum class WindowTraits {
+        ORIENTATION, COLOR, STYLE, TRANSLUCENT, HIDDEN, ANIMATED, NAVIGATION_BAR_COLOR, NAVIGATION_BAR_HIDDEN
+    }
+}