react-native-unistyles 2.8.0-beta.4 → 2.8.0-rc.1

package/android/src/main/cxx/cpp-adapter.cpp

@@ -45,7 +45,7 @@ extern "C"
 JNIEXPORT void JNICALL
 Java_com_unistyles_UnistylesModule_nativeOnOrientationChange(JNIEnv *env, jobject thiz, jobject screen, jobject insets, jobject statusBar, jobject navigationBar) {
     if (unistylesRuntime != nullptr) {
-        Dimensions screenDimensions = jobjectToDimensions(env, screen);
+        Screen screenDimensions = jobjectToScreen(env, screen);
         Dimensions statusBarDimensions = jobjectToDimensions(env, statusBar);
         Insets screenInsets = jobjectToInsets(env, insets);
         Dimensions navigationBarDimensions = jobjectToDimensions(env, navigationBar);

package/android/src/main/cxx/helpers.cpp

@@ -14,6 +14,23 @@ Dimensions jobjectToDimensions(JNIEnv *env, jobject dimensionObj) {
     return Dimensions{width, height};
 }
 
+Screen jobjectToScreen(JNIEnv *env, jobject screenObj) {
+    jclass screenClass = env->FindClass("com/unistyles/Screen");
+    jfieldID widthFieldID = env->GetFieldID(screenClass, "width", "I");
+    jfieldID heightFieldID = env->GetFieldID(screenClass, "height", "I");
+    jfieldID pixelRatioFieldID = env->GetFieldID(screenClass, "pixelRatio", "F");
+    jfieldID scaleFieldID = env->GetFieldID(screenClass, "fontScale", "F");
+
+    int width = env->GetIntField(screenObj, widthFieldID);
+    int height = env->GetIntField(screenObj, heightFieldID);
+    float pixelRatio = env->GetFloatField(screenObj, pixelRatioFieldID);
+    float fontScale = env->GetFloatField(screenObj, scaleFieldID);
+
+    env->DeleteLocalRef(screenClass);
+
+    return Screen{width, height, pixelRatio, fontScale};
+}
+
 Insets jobjectToInsets(JNIEnv *env, jobject insetsObj) {
     jclass insetsClass = env->FindClass("com/unistyles/Insets");
     jfieldID leftFieldID = env->GetFieldID(insetsClass, "left", "I");
@@ -31,6 +48,50 @@ Insets jobjectToInsets(JNIEnv *env, jobject insetsObj) {
     return Insets{top, bottom, left, right};
 }
 
+void JNI_callPlatformWithColor(JNIEnv *env, jobject unistylesModule, std::string name, std::string sig, std::string param, float alpha) {
+    jclass cls = env->GetObjectClass(unistylesModule);
+    jfieldID platformFieldId = env->GetFieldID(cls, "platform", "Lcom/unistyles/Platform;");
+    jobject platformInstance = env->GetObjectField(unistylesModule, platformFieldId);
+    jclass platformClass = env->GetObjectClass(platformInstance);
+    jstring strParam = env->NewStringUTF(param.c_str());
+    jmethodID methodId = env->GetMethodID(platformClass, name.c_str(), sig.c_str());
+
+    env->CallVoidMethod(platformInstance, methodId, strParam, static_cast<jfloat>(alpha));
+
+    env->DeleteLocalRef(cls);
+    env->DeleteLocalRef(platformInstance);
+    env->DeleteLocalRef(platformClass);
+    env->DeleteLocalRef(strParam);
+}
+
+void JNI_callPlatformWithBool(JNIEnv *env, jobject unistylesModule, std::string name, std::string sig, bool param) {
+    jclass cls = env->GetObjectClass(unistylesModule);
+    jfieldID platformFieldId = env->GetFieldID(cls, "platform", "Lcom/unistyles/Platform;");
+    jobject platformInstance = env->GetObjectField(unistylesModule, platformFieldId);
+    jclass platformClass = env->GetObjectClass(platformInstance);
+    jmethodID methodId = env->GetMethodID(platformClass, name.c_str(), sig.c_str());
+
+    env->CallVoidMethod(platformInstance, methodId, param);
+    env->DeleteLocalRef(cls);
+    env->DeleteLocalRef(platformInstance);
+    env->DeleteLocalRef(platformClass);
+}
+
+jobject JNI_callPlatform(JNIEnv *env, jobject unistylesModule, std::string name, std::string sig) {
+    jclass cls = env->GetObjectClass(unistylesModule);
+    jfieldID platformFieldId = env->GetFieldID(cls, "platform", "Lcom/unistyles/Platform;");
+    jobject platformInstance = env->GetObjectField(unistylesModule, platformFieldId);
+    jclass platformClass = env->GetObjectClass(platformInstance);
+    jmethodID methodId = env->GetMethodID(platformClass, name.c_str(), sig.c_str());
+    jobject result = env->CallObjectMethod(platformInstance, methodId);
+
+    env->DeleteLocalRef(cls);
+    env->DeleteLocalRef(platformInstance);
+    env->DeleteLocalRef(platformClass);
+
+    return result;
+}
+
 void throwKotlinException(
     JNIEnv *env,
     const char *message

package/android/src/main/cxx/helpers.h

@@ -6,6 +6,11 @@
 #include <UnistylesRuntime.h>
 
 Dimensions jobjectToDimensions(JNIEnv *env, jobject dimensionObj);
+Screen jobjectToScreen(JNIEnv *env, jobject screenObj);
 Insets jobjectToInsets(JNIEnv *env, jobject insetsObj);
 
+void JNI_callPlatformWithColor(JNIEnv *env, jobject unistylesModule, std::string name, std::string sig, std::string param, float alpha);
+jobject JNI_callPlatform(JNIEnv *env, jobject unistylesModule, std::string name, std::string sig);
+void JNI_callPlatformWithBool(JNIEnv *env, jobject unistylesModule, std::string name, std::string sig, bool param);
+
 void throwKotlinException(JNIEnv *env, const char *message);

package/android/src/main/cxx/platform.cpp

@@ -25,102 +25,112 @@ void makeShared(JNIEnv *env, jobject unistylesModule, std::shared_ptr<UnistylesR
         return getContentSizeCategory(env, unistylesModule);
     });
 
-    unistylesRuntime->setNavigationBarColorCallback([=](const std::string &color) {
-        setNavigationBarColor(env, unistylesModule, color);
+    unistylesRuntime->setNavigationBarColorCallback([=](const std::string &color, float alpha) {
+        setNavigationBarColor(env, unistylesModule, color, alpha);
     });
 
-    unistylesRuntime->setStatusBarColorCallback([=](const std::string &color) {
-        setStatusBarColor(env, unistylesModule, color);
+    unistylesRuntime->setStatusBarColorCallback([=](const std::string &color, float alpha) {
+        setStatusBarColor(env, unistylesModule, color, alpha);
     });
 
-    unistylesRuntime->screen = getScreenDimensions(env, unistylesModule);
+    unistylesRuntime->setNavigationBarHiddenCallback([=](bool hidden) {
+        setNavigationBarHidden(env, unistylesModule, hidden);
+    });
+
+    unistylesRuntime->setStatusBarHiddenCallback([=](bool hidden) {
+        setStatusBarHidden(env, unistylesModule, hidden);
+    });
+
+    unistylesRuntime->setImmersiveModeCallback([=](bool enabled) {
+        setImmersiveMode(env, unistylesModule, enabled);
+    });
+
+    unistylesRuntime->setRootViewBackgroundColorCallback([=](const std::string &color, float alpha) {
+        setRootViewBackgroundColor(env, unistylesModule, color, alpha);
+    });
+
+    Screen screen = getScreenDimensions(env, unistylesModule);
+
+    unistylesRuntime->screen = Dimensions{screen.width, screen.height};
     unistylesRuntime->contentSizeCategory = getContentSizeCategory(env, unistylesModule);
     unistylesRuntime->colorScheme = getColorScheme(env, unistylesModule);
     unistylesRuntime->statusBar = getStatusBarDimensions(env, unistylesModule);
     unistylesRuntime->insets = getInsets(env, unistylesModule);
     unistylesRuntime->navigationBar = getNavigationBarDimensions(env, unistylesModule);
+    unistylesRuntime->fontScale = screen.fontScale;
+    unistylesRuntime->pixelRatio = screen.pixelRatio;
 }
 
-Dimensions getScreenDimensions(JNIEnv *env, jobject unistylesModule) {
-    jclass cls = env->GetObjectClass(unistylesModule);
-    jmethodID methodId = env->GetMethodID(cls, "getScreenDimensions", "()Lcom/unistyles/Dimensions;");
-    jobject dimensionsObj = env->CallObjectMethod(unistylesModule, methodId);
-    Dimensions screenDimensions = jobjectToDimensions(env, dimensionsObj);
+Screen getScreenDimensions(JNIEnv *env, jobject unistylesModule) {
+    jobject result = JNI_callPlatform(env, unistylesModule, "getScreenDimensions", "()Lcom/unistyles/Screen;");
+    Screen screenDimensions = jobjectToScreen(env, result);
 
     return screenDimensions;
 }
 
 std::string getColorScheme(JNIEnv *env, jobject unistylesModule) {
-    jclass cls = env->GetObjectClass(unistylesModule);
-    jmethodID methodId = env->GetMethodID(cls, "getColorScheme", "()Ljava/lang/String;");
-    jstring colorScheme = (jstring) env->CallObjectMethod(unistylesModule, methodId);
+    jstring colorScheme = (jstring) JNI_callPlatform(env, unistylesModule, "getColorScheme", "()Ljava/lang/String;");
     const char *colorSchemeChars = env->GetStringUTFChars(colorScheme, nullptr);
     std::string colorSchemeStr = std::string(colorSchemeChars);
 
     env->ReleaseStringUTFChars(colorScheme, colorSchemeChars);
     env->DeleteLocalRef(colorScheme);
-    env->DeleteLocalRef(cls);
 
     return colorSchemeStr;
 }
 
 Dimensions getStatusBarDimensions(JNIEnv *env, jobject unistylesModule) {
-    jclass cls = env->GetObjectClass(unistylesModule);
-    jmethodID methodId = env->GetMethodID(cls, "getStatusBarDimensions", "()Lcom/unistyles/Dimensions;");
-    jobject dimensionsObj = env->CallObjectMethod(unistylesModule, methodId);
+    jobject dimensionsObj = JNI_callPlatform(env, unistylesModule, "getStatusBarDimensions", "()Lcom/unistyles/Dimensions;");
     Dimensions statusBarDimensions = jobjectToDimensions(env, dimensionsObj);
 
     return statusBarDimensions;
 }
 
 Dimensions getNavigationBarDimensions(JNIEnv *env, jobject unistylesModule) {
-    jclass cls = env->GetObjectClass(unistylesModule);
-    jmethodID methodId = env->GetMethodID(cls, "getNavigationBarDimensions", "()Lcom/unistyles/Dimensions;");
-    jobject dimensionsObj = env->CallObjectMethod(unistylesModule, methodId);
+    jobject dimensionsObj = JNI_callPlatform(env, unistylesModule, "getNavigationBarDimensions", "()Lcom/unistyles/Dimensions;");
     Dimensions navigationBarDimensions = jobjectToDimensions(env, dimensionsObj);
 
     return navigationBarDimensions;
 }
 
 Insets getInsets(JNIEnv *env, jobject unistylesModule) {
-    jclass cls = env->GetObjectClass(unistylesModule);
-    jmethodID methodId = env->GetMethodID(cls, "getInsets", "()Lcom/unistyles/Insets;");
-    jobject insetsObj = env->CallObjectMethod(unistylesModule, methodId);
+    jobject insetsObj = JNI_callPlatform(env, unistylesModule, "getInsets", "()Lcom/unistyles/Insets;");
     Insets insets = jobjectToInsets(env, insetsObj);
 
     return insets;
 }
 
 std::string getContentSizeCategory(JNIEnv *env, jobject unistylesModule) {
-    jclass cls = env->GetObjectClass(unistylesModule);
-    jmethodID methodId = env->GetMethodID(cls, "getContentSizeCategory", "()Ljava/lang/String;");
-    jstring contentSizeCategory = (jstring) env->CallObjectMethod(unistylesModule, methodId);
+    jstring contentSizeCategory = (jstring) JNI_callPlatform(env, unistylesModule, "getContentSizeCategory", "()Ljava/lang/String;");
     const char *contentSizeCategoryChars = env->GetStringUTFChars(contentSizeCategory, nullptr);
     std::string contentSizeCategoryStr = std::string(contentSizeCategoryChars);
 
     env->ReleaseStringUTFChars(contentSizeCategory, contentSizeCategoryChars);
     env->DeleteLocalRef(contentSizeCategory);
-    env->DeleteLocalRef(cls);
 
     return contentSizeCategoryStr;
 }
 
-void setStatusBarColor(JNIEnv *env, jobject unistylesModule, std::string color) {
-    jstring colorStr = env->NewStringUTF(color.c_str());
-    jclass cls = env->GetObjectClass(unistylesModule);
-    jmethodID methodId = env->GetMethodID(cls, "onSetStatusBarColor", "(Ljava/lang/String;)V");
+void setStatusBarColor(JNIEnv *env, jobject unistylesModule, std::string color, float alpha) {
+    JNI_callPlatformWithColor(env, unistylesModule, "onSetStatusBarColor", "(Ljava/lang/String;F)V", color, alpha);
+}
+
+void setNavigationBarColor(JNIEnv *env, jobject unistylesModule, std::string color, float alpha) {
+    JNI_callPlatformWithColor(env, unistylesModule, "onSetNavigationBarColor", "(Ljava/lang/String;F)V", color, alpha);
+}
 
-    env->CallVoidMethod(unistylesModule, methodId, colorStr);
-    env->DeleteLocalRef(colorStr);
-    env->DeleteLocalRef(cls);
+void setNavigationBarHidden(JNIEnv *env, jobject unistylesModule, bool hidden) {
+    JNI_callPlatformWithBool(env, unistylesModule, "onSetNavigationBarHidden", "(Z)V", hidden);
 }
 
-void setNavigationBarColor(JNIEnv *env, jobject unistylesModule, std::string color) {
-    jstring colorStr = env->NewStringUTF(color.c_str());
-    jclass cls = env->GetObjectClass(unistylesModule);
-    jmethodID methodId = env->GetMethodID(cls, "onSetNavigationBarColor", "(Ljava/lang/String;)V");
+void setStatusBarHidden(JNIEnv *env, jobject unistylesModule, bool hidden) {
+    JNI_callPlatformWithBool(env, unistylesModule, "onSetStatusBarHidden", "(Z)V", hidden);
+}
+
+void setImmersiveMode(JNIEnv *env, jobject unistylesModule, bool enabled) {
+    JNI_callPlatformWithBool(env, unistylesModule, "onSetImmersiveMode", "(Z)V", enabled);
+}
 
-    env->CallVoidMethod(unistylesModule, methodId, colorStr);
-    env->DeleteLocalRef(colorStr);
-    env->DeleteLocalRef(cls);
+void setRootViewBackgroundColor(JNIEnv *env, jobject unistylesModule, std::string color, float alpha) {
+    JNI_callPlatformWithColor(env, unistylesModule, "onSetRootViewBackgroundColor", "(Ljava/lang/String;F)V", color, alpha);
 }

package/android/src/main/cxx/platform.h

@@ -4,12 +4,15 @@
 #include "helpers.h"
 
 void makeShared(JNIEnv *env, jobject unistylesModule, std::shared_ptr<UnistylesRuntime> unistylesRuntime);
-Dimensions getScreenDimensions(JNIEnv *env, jobject unistylesModule);
+Screen getScreenDimensions(JNIEnv *env, jobject unistylesModule);
 std::string getColorScheme(JNIEnv *env, jobject unistylesModule);
 Dimensions getStatusBarDimensions(JNIEnv *env, jobject unistylesModule);
 Dimensions getNavigationBarDimensions(JNIEnv *env, jobject unistylesModule);
+void setNavigationBarHidden(JNIEnv *env, jobject unistylesModule, bool hidden);
+void setStatusBarHidden(JNIEnv *env, jobject unistylesModule, bool hidden);
+void setImmersiveMode(JNIEnv *env, jobject unistylesModule, bool hidden);
+void setRootViewBackgroundColor(JNIEnv *env, jobject unistylesModule, std::string color, float alpha);
 Insets getInsets(JNIEnv *env, jobject unistylesModule);
 std::string getContentSizeCategory(JNIEnv *env, jobject unistylesModule);
-
-void setNavigationBarColor(JNIEnv *env, jobject unistylesModule, std::string color);
-void setStatusBarColor(JNIEnv *env, jobject unistylesModule, std::string color);
+void setNavigationBarColor(JNIEnv *env, jobject unistylesModule, std::string color, float alpha);
+void setStatusBarColor(JNIEnv *env, jobject unistylesModule, std::string color, float alpha);

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

@@ -1,64 +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
-    }
-
+class Screen(
+    var width: Int,
+    var height: Int,
+    var pixelRatio: Float,
+    var fontScale: Float
+) {
     override fun toString(): String {
-        return "T:${top}B:${bottom}L:${left}R:${right}"
+        return "${width}x${height} ${pixelRatio} ${fontScale}"
     }
 }
 
-class InsetsCompat(
-    val statusBar: Insets,
-    val navigationBar: Insets,
-    val cutout: Insets
-) {
+class Insets(var top: Int, var bottom: Int, var left: Int, var right: Int) {
     override fun toString(): String {
-        return buildString {
-            append(" statusBar=")
-            append(statusBar)
-            append(" navigationBar=")
-            append(navigationBar)
-            append(" cutout=")
-            append(cutout)
-        }
-    }
-
-    companion object {
-        fun getDefaults(): InsetsCompat {
-            return InsetsCompat(
-                Insets(0, 0, 0, 0),
-                Insets(0, 0, 0, 0),
-                Insets(0, 0, 0, 0)
-            )
-        }
+        return "T:${top}B:${bottom}L:${left}R:${right}"
     }
 }

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

@@ -1,26 +1,34 @@
 package com.unistyles
 
 import android.content.res.Configuration
+import android.graphics.Color
 import android.graphics.Rect
-import android.util.DisplayMetrics
+import android.os.Build
+import android.util.Log
 import android.view.View
+import android.view.Window
+import android.view.WindowManager
+import androidx.core.graphics.ColorUtils
+import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
 import com.facebook.react.bridge.ReactApplicationContext
-import kotlin.math.max
+import kotlin.math.roundToInt
 
 class Platform(private val reactApplicationContext: ReactApplicationContext) {
-    private val displayMetrics: DisplayMetrics = reactApplicationContext.resources.displayMetrics
-    private var insetsCompat: InsetsCompat = InsetsCompat.getDefaults()
+    private var insets: Insets = Insets(0, 0, 0, 0)
+    private var defaultNavigationBarColor: Int = -1
+    private var defaultStatusBarColor: Int = -1
 
-    var defaultNavigationBarColor: Int? = null
-    var defaultStatusBarColor: Int? = null
+    var orientation: Int = reactApplicationContext.resources.configuration.orientation
 
-    fun getScreenDimensions(): Dimensions {
-        val density = reactApplicationContext.resources.displayMetrics.density
-        val screenWidth = (displayMetrics.widthPixels / density).toInt()
-        val screenHeight = (displayMetrics.heightPixels / density).toInt()
+    fun getScreenDimensions(): Screen {
+        val displayMetrics = reactApplicationContext.resources.displayMetrics
+        val fontScale = reactApplicationContext.resources.configuration.fontScale
+        val screenWidth = (displayMetrics.widthPixels / displayMetrics.density).roundToInt()
+        val screenHeight = (displayMetrics.heightPixels / displayMetrics.density).roundToInt()
 
-        return Dimensions(screenWidth, screenHeight)
+        return Screen(screenWidth, screenHeight, displayMetrics.density, fontScale)
     }
 
     fun getColorScheme(): String {
@@ -36,15 +44,15 @@ class Platform(private val reactApplicationContext: ReactApplicationContext) {
     }
 
     fun getStatusBarDimensions(): Dimensions {
-        val density = reactApplicationContext.resources.displayMetrics.density
-        val screenWidth = (displayMetrics.widthPixels / density).toInt()
+        val displayMetrics = reactApplicationContext.resources.displayMetrics
+        val screenWidth = (displayMetrics.widthPixels / displayMetrics.density).roundToInt()
 
         return Dimensions(screenWidth, getStatusBarHeight())
     }
 
     fun getNavigationBarDimensions(): Dimensions {
-        val density = reactApplicationContext.resources.displayMetrics.density
-        val screenWidth = (displayMetrics.widthPixels / density).toInt()
+        val displayMetrics = reactApplicationContext.resources.displayMetrics
+        val screenWidth = (displayMetrics.widthPixels / displayMetrics.density).roundToInt()
 
         return Dimensions(screenWidth, getNavigationBarHeight())
     }
@@ -65,50 +73,177 @@ class Platform(private val reactApplicationContext: ReactApplicationContext) {
         return contentSizeCategory
     }
 
-    fun setInsetsCompat(insetsCompat: WindowInsetsCompat, decorView: View) {
-        val statusBar = insetsCompat.getInsets(WindowInsetsCompat.Type.statusBars())
-        val navigationBar = insetsCompat.getInsets(WindowInsetsCompat.Type.navigationBars())
-        val cutout = insetsCompat.getInsets(WindowInsetsCompat.Type.displayCutout())
+    fun setInsetsCompat(insetsCompat: WindowInsetsCompat, window: Window) {
+        // 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()
 
-        // get the visible frame of the window to detect translucent status bar
-        // react native (and expo) are setting top inset to 0
-        // so there is no other way to detect if status bar is hidden or translucent
-        val visibleFrame = Rect()
-        decorView.getWindowVisibleDisplayFrame(visibleFrame)
+                window.decorView.getWindowVisibleDisplayFrame(visibleRect)
 
-        val visibleTopFrame = max(visibleFrame.top, statusBar.top)
+                visibleRect.top
+            }
+            false -> 0
+        }
 
-        this.insetsCompat = InsetsCompat(
-            Insets(visibleTopFrame, statusBar.bottom, statusBar.left, statusBar.right),
-            Insets(navigationBar.top, navigationBar.bottom, navigationBar.left, navigationBar.right),
-            Insets(cutout.top, cutout.bottom, cutout.left, cutout.right)
-        )
+        val insets = insetsCompat.getInsets(WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout())
+
+        this.insets = Insets(statusBarTopInset, insets.bottom, insets.left, insets.right)
     }
 
     fun getInsets(): Insets {
         val density = reactApplicationContext.resources.displayMetrics.density
-        val top = max(this.insetsCompat.cutout.top, this.insetsCompat.statusBar.top)
-        val bottom = this.insetsCompat.navigationBar.bottom
-        val left = this.insetsCompat.statusBar.left
-        val right = this.insetsCompat.statusBar.right
 
         return Insets(
-            (top / density).toInt(),
-            (bottom / density).toInt(),
-            (left / density).toInt(),
-            (right / density).toInt()
+            (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.insetsCompat.statusBar.top / density).toInt()
+        return (this.insets.top / density).roundToInt()
     }
 
     private fun getNavigationBarHeight(): Int {
         val density = reactApplicationContext.resources.displayMetrics.density
 
-        return (this.insetsCompat.navigationBar.bottom / density).toInt()
+        return (this.insets.bottom / density).roundToInt()
+    }
+
+    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 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 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())
     }
 }