react-native-unistyles 2.4.0 → 2.4.1

package/android/src/main/java/com/unistyles/Models.kt

@@ -1,85 +1,27 @@
 package com.unistyles
 
-class Dimensions(var width: Int, var height: Int) {
-    fun isEqual(dimensions: Dimensions): Boolean {
-        if (this.width != dimensions.width) {
-            return false
-        }
-
-        return this.height == dimensions.height
-    }
-
+class Dimensions(
+    var width: Int,
+    var height: Int
+) {
     override fun toString(): String {
         return "${width}x${height}"
     }
 }
 
-class Insets(var top: Int, var bottom: Int, var left: Int, var right: Int) {
-    fun isEqual(insets: Insets): Boolean {
-        if (this.top != insets.top) {
-            return false
-        }
-
-        if (this.bottom != insets.bottom) {
-            return false
-        }
-
-        if (this.left != insets.left) {
-            return false
-        }
-
-        return this.right == insets.right
-    }
-
-    override fun toString(): String {
-        return "T:${top}B:${bottom}L:${left}R:${right}"
-    }
-}
-
-class LayoutConfig(
-    val screen: Dimensions,
-    val insets: Insets,
-    val statusBar: Dimensions,
-    val navigationBar: Dimensions
+class Screen(
+    var width: Int,
+    var height: Int,
+    var pixelRatio: Float,
+    var fontScale: Float
 ) {
-    fun isEqual(config: LayoutConfig): Boolean {
-        if (!this.screen.isEqual(config.screen)) {
-            return false
-        }
-
-        if (!this.insets.isEqual(config.insets)) {
-            return false
-        }
-
-        if (!this.statusBar.isEqual(config.statusBar)) {
-            return false
-        }
-
-        return this.navigationBar.isEqual(config.navigationBar)
-    }
-
     override fun toString(): String {
-        return buildString {
-            append("screen=")
-            append(screen)
-            append(" insets=")
-            append(insets)
-            append(" statusBar=")
-            append(statusBar)
-            append(" navigationBar=")
-            append(navigationBar)
-        }
+        return "${width}x${height} ${pixelRatio} ${fontScale}"
     }
 }
 
-class Config(
-    val colorScheme: String,
-    val contentSizeCategory: String,
-) {
-    var hasNewColorScheme: Boolean = false
-    var hasNewContentSizeCategory: Boolean = false
-
+class Insets(var top: Int, var bottom: Int, var left: Int, var right: Int) {
     override fun toString(): String {
-        return "colorScheme=${colorScheme} contentSizeCategory:${contentSizeCategory}"
+        return "T:${top}B:${bottom}L:${left}R:${right}"
     }
 }

package/android/src/main/java/com/unistyles/Platform.kt

@@ -1,23 +1,324 @@
 package com.unistyles
 
+import android.content.Context
+import android.content.res.Configuration
+import android.graphics.Color
+import android.graphics.Rect
+import android.os.Build
+import android.util.DisplayMetrics
+import android.util.Log
+import android.view.View
+import android.view.Window
+import android.view.WindowManager
+import androidx.core.graphics.ColorUtils
+import androidx.core.text.TextUtilsCompat
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
 import com.facebook.react.bridge.ReactApplicationContext
+import java.util.Locale
+import kotlin.math.roundToInt
 
-class Platform(reactApplicationContext: ReactApplicationContext) {
-    private val config: UnistylesConfig = UnistylesConfig(reactApplicationContext)
+class Platform(private val reactApplicationContext: ReactApplicationContext) {
+    var hasAnimatedInsets = true
+    private var insets: Insets = Insets(0, 0, 0, 0)
+    private var defaultNavigationBarColor: Int = -1
+    private var defaultStatusBarColor: Int = -1
 
-    fun hasNewLayoutConfig(): Boolean {
-        return this.config.hasNewLayoutConfig()
+    var orientation: Int = reactApplicationContext.resources.configuration.orientation
+
+    fun disableAnimatedInsets() {
+        this.hasAnimatedInsets = false
+    }
+
+    @Suppress("DEPRECATION")
+    fun getScreenDimensions(): Screen {
+        // function takes in count edge-to-edge layout
+        val displayMetrics = reactApplicationContext.resources.displayMetrics
+        val fontScale = reactApplicationContext.resources.configuration.fontScale
+
+        when {
+            Build.VERSION.SDK_INT < Build.VERSION_CODES.R -> {
+                val windowManager = reactApplicationContext.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+                val metrics = DisplayMetrics()
+
+                windowManager.defaultDisplay.getRealMetrics(metrics)
+
+                val screenWidth = (metrics.widthPixels / metrics.density).roundToInt()
+                val screenHeight = (metrics.heightPixels / metrics.density).roundToInt()
+
+                return Screen(screenWidth, screenHeight, metrics.density, fontScale)
+            }
+            else -> {
+                reactApplicationContext.currentActivity?.windowManager?.currentWindowMetrics?.bounds?.let {
+                    val boundsWidth = (it.width() / displayMetrics.density).roundToInt()
+                    val boundsHeight = (it.height() / displayMetrics.density).roundToInt()
+
+                    return Screen(boundsWidth, boundsHeight, displayMetrics.density, fontScale)
+                } ?: run {
+                    val screenWidth = (displayMetrics.widthPixels / displayMetrics.density).roundToInt()
+                    val screenHeight = (displayMetrics.heightPixels / displayMetrics.density).roundToInt()
+
+                    return Screen(screenWidth, screenHeight, displayMetrics.density, fontScale)
+                }
+            }
+        }
+    }
+
+    fun getColorScheme(): String {
+        val uiMode = this.reactApplicationContext.resources.configuration.uiMode
+
+        val colorScheme = when (uiMode.and(Configuration.UI_MODE_NIGHT_MASK)) {
+            Configuration.UI_MODE_NIGHT_YES -> "dark"
+            Configuration.UI_MODE_NIGHT_NO -> "light"
+            else -> "unspecified"
+        }
+
+        return colorScheme
+    }
+
+    fun getStatusBarDimensions(): Dimensions {
+        val displayMetrics = reactApplicationContext.resources.displayMetrics
+        val screenWidth = (displayMetrics.widthPixels / displayMetrics.density).roundToInt()
+
+        return Dimensions(screenWidth, getStatusBarHeight())
+    }
+
+    fun getIsRTL(): Boolean {
+        // forced by React Native
+        val sharedPrefs = reactApplicationContext.getSharedPreferences(
+            "com.facebook.react.modules.i18nmanager.I18nUtil",
+            Context.MODE_PRIVATE
+        )
+        val hasForcedRtl = sharedPrefs.getBoolean("RCTI18nUtil_forceRTL", false)
+        // user preferences
+        val isRtl = TextUtilsCompat.getLayoutDirectionFromLocale(Locale.getDefault()) == ViewCompat.LAYOUT_DIRECTION_RTL
+
+        return hasForcedRtl || isRtl
+    }
+
+    fun getNavigationBarDimensions(): Dimensions {
+        val displayMetrics = reactApplicationContext.resources.displayMetrics
+        val screenWidth = (displayMetrics.widthPixels / displayMetrics.density).roundToInt()
+
+        return Dimensions(screenWidth, getNavigationBarHeight())
+    }
+
+    fun getContentSizeCategory(): String {
+        val fontScale = reactApplicationContext.resources.configuration.fontScale
+
+        val contentSizeCategory = when {
+            fontScale <= 0.85f -> "Small"
+            fontScale <= 1.0f -> "Default"
+            fontScale <= 1.15f -> "Large"
+            fontScale <= 1.3f -> "ExtraLarge"
+            fontScale <= 1.5f -> "Huge"
+            fontScale <= 1.8 -> "ExtraHuge"
+            else -> "ExtraExtraHuge"
+        }
+
+        return contentSizeCategory
+    }
+
+    fun setInsetsCompat(insetsCompat: WindowInsetsCompat, window: Window, animatedBottomInsets: Int?) {
+        // below Android 11, we need to use window flags to detect status bar visibility
+        val isStatusBarVisible = when(Build.VERSION.SDK_INT) {
+            in 30..Int.MAX_VALUE -> {
+                insetsCompat.isVisible(WindowInsetsCompat.Type.statusBars())
+            }
+            else -> {
+                @Suppress("DEPRECATION")
+                window.attributes.flags and WindowManager.LayoutParams.FLAG_FULLSCREEN != WindowManager.LayoutParams.FLAG_FULLSCREEN
+            }
+        }
+        // React Native is forcing insets to make status bar translucent
+        // so we need to calculate top inset manually, as WindowInsetCompat will always return 0
+        val statusBarTopInset = when(isStatusBarVisible) {
+            true -> {
+                val visibleRect = Rect()
+
+                window.decorView.getWindowVisibleDisplayFrame(visibleRect)
+
+                visibleRect.top
+            }
+            false -> 0
+        }
+
+        val insets = insetsCompat.getInsets(WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout())
+        val bottomIME = insetsCompat.getInsets(WindowInsetsCompat.Type.ime()).bottom
+
+        // fix for keyboard controller, that triggers WindowInsetsListener
+        if(!hasAnimatedInsets && bottomIME != 0) {
+            return
+        }
+
+        if (!hasAnimatedInsets) {
+            this.insets = Insets(statusBarTopInset, insets.bottom, insets.left, insets.right)
+
+            return
+        }
+
+        // Android 10 and below - set bottom insets to 0 while keyboard is visible and use default bottom insets otherwise
+        // Android 11 and above - animate bottom insets while keyboard is appearing and disappearing
+        val imeInsets = insetsCompat.getInsets(WindowInsetsCompat.Type.ime())
+        val insetBottom = when(imeInsets.bottom > 0) {
+            true -> {
+                if (Build.VERSION.SDK_INT >= 30 && animatedBottomInsets != null) {
+                    animatedBottomInsets
+                } else {
+                    0
+                }
+            }
+            else -> {
+                insets.bottom
+            }
+        }
+
+        this.insets = Insets(statusBarTopInset, insetBottom, insets.left, insets.right)
+    }
+
+    fun getInsets(): Insets {
+        val density = reactApplicationContext.resources.displayMetrics.density
+
+        return Insets(
+            (this.insets.top / density).roundToInt(),
+            (this.insets.bottom / density).roundToInt(),
+            (this.insets.left / density).roundToInt(),
+            (this.insets.right / density).roundToInt()
+        )
+    }
+
+    private fun getStatusBarHeight(): Int {
+        val density = reactApplicationContext.resources.displayMetrics.density
+
+        return (this.insets.top / density).roundToInt()
+    }
+
+    private fun getNavigationBarHeight(): Int {
+        val density = reactApplicationContext.resources.displayMetrics.density
+
+        return (this.insets.bottom / density).roundToInt()
     }
 
-    fun hasNewConfig(): Boolean {
-        return this.config.hasNewConfig()
+    fun onSetNavigationBarColor(color: String, alpha: Float) {
+        this.reactApplicationContext.currentActivity?.let { activity ->
+            if (this.defaultNavigationBarColor == -1) {
+                this.defaultNavigationBarColor = activity.window.navigationBarColor
+            }
+
+            try {
+                activity.runOnUiThread {
+                    activity.window.navigationBarColor = parseColor(color, alpha, this.defaultNavigationBarColor)
+                }
+            } catch (_: Exception) {
+                Log.d("Unistyles", "Failed to set navigation bar color: $color")
+            }
+        }
+    }
+
+    fun onSetNavigationBarHidden(isHidden: Boolean) {
+        this.reactApplicationContext.currentActivity?.let { activity ->
+            WindowInsetsControllerCompat(activity.window, activity.window.decorView).apply {
+                activity.window?.decorView?.let { decorView ->
+                    @Suppress("DEPRECATION")
+                    activity.runOnUiThread {
+                        if (isHidden) {
+                            // below Android 11, we need to use window flags to hide the navigation bar
+                            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.Q) {
+                                decorView.systemUiVisibility = (View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                                    or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY)
+                            } else {
+                                hide(WindowInsetsCompat.Type.navigationBars())
+                                systemBarsBehavior =
+                                    WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+                            }
+
+                            // dispatch new insets to invoke the insets listener
+                            val newInsets = WindowInsetsCompat.Builder()
+                                .setInsets(WindowInsetsCompat.Type.navigationBars(), androidx.core.graphics.Insets.of(0, 0, 0, 0))
+                                .build()
+
+                            ViewCompat.dispatchApplyWindowInsets(activity.findViewById(android.R.id.content), newInsets)
+                        } else {
+                            show(WindowInsetsCompat.Type.navigationBars())
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fun onSetStatusBarHidden(isHidden: Boolean) {
+        this.reactApplicationContext.currentActivity?.let { activity ->
+            WindowInsetsControllerCompat(activity.window, activity.window.decorView).apply {
+                activity.window?.let { window ->
+                    @Suppress("DEPRECATION")
+                    activity.runOnUiThread {
+                        if (isHidden) {
+                            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.Q) {
+                                window.addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN)
+                                window.clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN)
+                            } else {
+                                hide(WindowInsetsCompat.Type.statusBars())
+                            }
+                        } else {
+                            show(WindowInsetsCompat.Type.statusBars())
+                        }
+                    }
+                }
+            }
+        }
     }
 
-    fun getConfig(): Config {
-        return this.config.getConfig()
+    fun onSetStatusBarColor(color: String, alpha: Float) {
+        this.reactApplicationContext.currentActivity?.let { activity ->
+            if (this.defaultStatusBarColor == -1) {
+                this.defaultStatusBarColor = activity.window.statusBarColor
+            }
+
+            try {
+                activity.runOnUiThread {
+                    activity.window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS)
+                    activity.window.statusBarColor = parseColor(color, alpha, this.defaultStatusBarColor)
+                }
+            } catch (_: Exception) {
+                Log.d("Unistyles", "Failed to set status bar color: $color")
+            }
+        }
     }
 
-    fun getLayoutConfig(): LayoutConfig {
-        return this.config.getLayoutConfig()
+    fun onSetImmersiveMode(isEnabled: Boolean) {
+        this.onSetStatusBarHidden(isEnabled)
+        this.onSetNavigationBarHidden(isEnabled)
+    }
+
+    fun onSetRootViewBackgroundColor(color: String, alpha: Float) {
+        this.reactApplicationContext.currentActivity?.let { activity ->
+            activity.window?.decorView?.let { decorView ->
+                try {
+                    activity.runOnUiThread {
+                        decorView.rootView.setBackgroundColor(parseColor(color, alpha, Color.WHITE))
+                    }
+                } catch (_: Exception) {
+                    Log.d("Unistyles", "Failed to set root view background color: $color")
+                }
+            }
+        }
+    }
+
+    private fun parseColor(color: String, alpha: Float, defaultColor: Int): Int {
+        if (color == "") {
+            return defaultColor
+        }
+
+        if (color == "transparent") {
+            return Color.TRANSPARENT
+        }
+
+        if (alpha == 1.toFloat()) {
+            return Color.parseColor(color)
+        }
+
+        return ColorUtils.setAlphaComponent(Color.parseColor(color), (255 * alpha).toInt())
     }
 }