react-native-unistyles 2.4.0-rc.1 → 2.4.0-rc.2

package/README.md

@@ -48,10 +48,13 @@
 [How to become a sponsor?](https://reactnativeunistyles.vercel.app/other/for-sponsors/)
 
 <a href="https://codemask.com">
-     <img src="https://avatars.githubusercontent.com/u/51229884?s=200&v=4" height="70px" width="70px" />
+    <img src="https://avatars.githubusercontent.com/u/51229884?s=200&v=4" height="70px" width="70px" alt="codemask" />
 </a>
 <a href="https://galaxies.dev">
-     <img src="https://avatars.githubusercontent.com/u/118431096?s=200&v=4" height="70px" width="70px" />
+     <img src="https://avatars.githubusercontent.com/u/118431096?s=200&v=4" height="70px" width="70px" alt="galaxies-dev" />
+</a>
+<a href="https://github.com/kmartinezmedia">
+     <img src="https://avatars.githubusercontent.com/u/6308123?s=200&v=4" height="70px" width="70px" alt="kmartinezmedia" />
 </a>
 
 

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

@@ -15,12 +15,12 @@ Java_com_unistyles_UnistylesModule_nativeInstall(
         JNIEnv *env,
         jobject thiz,
         jlong jsi,
-        jint screenWidth,
-        jint screenHeight,
+        jobject screen,
         jstring colorScheme,
         jstring contentSizeCategory,
         jobject insets,
-        jobject statusBar
+        jobject statusBar,
+        jobject navigationBar
 ) {
     auto runtime = reinterpret_cast<facebook::jsi::Runtime *>(jsi);
 
@@ -41,12 +41,12 @@ Java_com_unistyles_UnistylesModule_nativeInstall(
     env->ReleaseStringUTFChars(contentSizeCategory, contentSizeCategoryChars);
 
     unistylesRuntime = std::make_shared<UnistylesRuntime>(
-        screenWidth,
-        screenHeight,
+        jobjectToDimensions(env, screen),
         colorSchemeStr,
         contentSizeCategoryStr,
-        jobjectToStdMap(env, insets),
-        jobjectToStdMap(env, statusBar)
+        jobjectToInsets(env, insets),
+        jobjectToDimensions(env, statusBar),
+        jobjectToDimensions(env, navigationBar)
     );
 
     unistylesRuntime->onThemeChange([=](const std::string &theme) {
@@ -59,13 +59,23 @@ Java_com_unistyles_UnistylesModule_nativeInstall(
         env->DeleteLocalRef(cls);
     });
 
-    unistylesRuntime->onLayoutChange([=](const std::string &breakpoint, const std::string &orientation, int width, int height) {
+    unistylesRuntime->onLayoutChange([=](const std::string &breakpoint, const std::string &orientation, Dimensions& screen, Dimensions& statusBar, Insets& insets, Dimensions& navigationBar) {
         jstring breakpointStr = env->NewStringUTF(breakpoint.c_str());
         jstring orientationStr = env->NewStringUTF(orientation.c_str());
         jclass cls = env->GetObjectClass(unistylesModule);
-        jmethodID methodId = env->GetMethodID(cls, "onLayoutChange", "(Ljava/lang/String;Ljava/lang/String;II)V");
-
-        env->CallVoidMethod(unistylesModule, methodId, breakpointStr, orientationStr, width, height);
+        jclass dimensionsClass = env->FindClass("com/unistyles/Dimensions");
+        jmethodID dimensionsConstructor = env->GetMethodID(dimensionsClass, "<init>", "(II)V");
+        jobject screenObj = env->NewObject(dimensionsClass, dimensionsConstructor, screen.width, screen.height);
+        jobject statusBarObj = env->NewObject(dimensionsClass, dimensionsConstructor, statusBar.width, statusBar.height);
+        jobject navigationBarObj = env->NewObject(dimensionsClass, dimensionsConstructor, navigationBar.width, navigationBar.height);
+
+        jclass insetsClass = env->FindClass("com/unistyles/Insets");
+        jmethodID insetsConstructor = env->GetMethodID(insetsClass, "<init>", "(IIII)V");
+        jobject insetsObj = env->NewObject(insetsClass, insetsConstructor, insets.left, insets.top, insets.right, insets.bottom);
+        jmethodID methodId = env->GetMethodID(cls, "onLayoutChange",
+                                              "(Ljava/lang/String;Ljava/lang/String;Lcom/unistyles/Dimensions;Lcom/unistyles/Dimensions;Lcom/unistyles/Insets;Lcom/unistyles/Dimensions;)V");
+
+        env->CallVoidMethod(unistylesModule, methodId, breakpointStr, orientationStr, screenObj, statusBarObj, insetsObj, navigationBarObj);
         env->DeleteLocalRef(breakpointStr);
         env->DeleteLocalRef(orientationStr);
         env->DeleteLocalRef(cls);
@@ -103,9 +113,14 @@ Java_com_unistyles_UnistylesModule_nativeDestroy(JNIEnv *env, jobject thiz) {
 
 extern "C"
 JNIEXPORT void JNICALL
-Java_com_unistyles_UnistylesModule_nativeOnOrientationChange(JNIEnv *env, jobject thiz, jint width, jint height, jobject insets, jobject statusBar) {
+Java_com_unistyles_UnistylesModule_nativeOnOrientationChange(JNIEnv *env, jobject thiz, jobject screen, jobject insets, jobject statusBar, jobject navigationBar) {
     if (unistylesRuntime != nullptr) {
-        unistylesRuntime->handleScreenSizeChange(width, height, jobjectToStdMap(env, insets), jobjectToStdMap(env, statusBar));
+        Dimensions screenDimensions = jobjectToDimensions(env, screen);
+        Dimensions statusBarDimensions = jobjectToDimensions(env, statusBar);
+        Insets screenInsets = jobjectToInsets(env, insets);
+        Dimensions navigationBarDimensions = jobjectToDimensions(env, navigationBar);
+
+        unistylesRuntime->handleScreenSizeChange(screenDimensions, screenInsets, statusBarDimensions, navigationBarDimensions);
     }
 }
 

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

@@ -1,69 +1,34 @@
 #include "helpers.h"
+#include "UnistylesRuntime.h"
 
-int jobjectToInt(JNIEnv *env, jobject integer) {
-    jclass integerClass = env->FindClass("java/lang/Integer");
-    jmethodID intValueMethod = env->GetMethodID(integerClass, "intValue", "()I");
-    int value = env->CallIntMethod(integer, intValueMethod);
+Dimensions jobjectToDimensions(JNIEnv *env, jobject dimensionObj) {
+    jclass dimensionClass = env->FindClass("com/unistyles/Dimensions");
+    jfieldID widthFieldID = env->GetFieldID(dimensionClass, "width", "I");
+    jfieldID heightFieldID = env->GetFieldID(dimensionClass, "height", "I");
 
-    env->DeleteLocalRef(integerClass);
+    int width = env->GetIntField(dimensionObj, widthFieldID);
+    int height = env->GetIntField(dimensionObj, heightFieldID);
 
-    return value;
-}
-
-std::string jstringToStdString(JNIEnv *env, jstring jStr) {
-    if (!jStr) {
-        return "";
-    }
-
-    const jclass stringClass = env->GetObjectClass(jStr);
-    const jmethodID getBytes = env->GetMethodID(stringClass, "getBytes", "(Ljava/lang/String;)[B");
-    const jbyteArray stringJbytes = (jbyteArray) env->CallObjectMethod(jStr, getBytes, env->NewStringUTF("UTF-8"));
-
-    size_t length = (size_t) env->GetArrayLength(stringJbytes);
-    jbyte* pBytes = env->GetByteArrayElements(stringJbytes, NULL);
-
-    std::string ret = std::string((char *)pBytes, length);
-    env->ReleaseByteArrayElements(stringJbytes, pBytes, JNI_ABORT);
+    env->DeleteLocalRef(dimensionClass);
 
-    env->DeleteLocalRef(stringJbytes);
-    env->DeleteLocalRef(stringClass);
-
-    return ret;
+    return Dimensions{width, height};
 }
 
-std::map<std::string, int> jobjectToStdMap(JNIEnv *env, jobject map) {
-    std::map<std::string, int> result;
-
-    jclass setClass = env->FindClass("java/util/Set");
-    jclass iteratorClass = env->FindClass("java/util/Iterator");
-    jmethodID entrySetMethod = env->GetMethodID(env->GetObjectClass(map), "entrySet", "()Ljava/util/Set;");
-    jmethodID iteratorMethod = env->GetMethodID(setClass, "iterator", "()Ljava/util/Iterator;");
-    jobject set = env->CallObjectMethod(map, entrySetMethod);
-    jobject iterator = env->CallObjectMethod(set, iteratorMethod);
-    jmethodID hasNextMethod = env->GetMethodID(iteratorClass, "hasNext", "()Z");
-    jmethodID nextMethod = env->GetMethodID(iteratorClass, "next", "()Ljava/lang/Object;");
-
-    while (env->CallBooleanMethod(iterator, hasNextMethod)) {
-        jobject entry = env->CallObjectMethod(iterator, nextMethod);
+Insets jobjectToInsets(JNIEnv *env, jobject insetsObj) {
+    jclass insetsClass = env->FindClass("com/unistyles/Insets");
+    jfieldID leftFieldID = env->GetFieldID(insetsClass, "left", "I");
+    jfieldID topFieldID = env->GetFieldID(insetsClass, "top", "I");
+    jfieldID rightFieldID = env->GetFieldID(insetsClass, "right", "I");
+    jfieldID bottomFieldID = env->GetFieldID(insetsClass, "bottom", "I");
 
-        jmethodID getKeyMethod = env->GetMethodID(env->GetObjectClass(entry), "getKey", "()Ljava/lang/Object;");
-        jmethodID getValueMethod = env->GetMethodID(env->GetObjectClass(entry), "getValue", "()Ljava/lang/Object;");
-        jstring key = (jstring) env->CallObjectMethod(entry, getKeyMethod);
-        jobject value = env->CallObjectMethod(entry, getValueMethod);
-
-        result[jstringToStdString(env, key)] = jobjectToInt(env, value);
-
-        env->DeleteLocalRef(entry);
-        env->DeleteLocalRef(key);
-        env->DeleteLocalRef(value);
-    }
+    int left = env->GetIntField(insetsObj, leftFieldID);
+    int top = env->GetIntField(insetsObj, topFieldID);
+    int right = env->GetIntField(insetsObj, rightFieldID);
+    int bottom = env->GetIntField(insetsObj, bottomFieldID);
 
-    env->DeleteLocalRef(set);
-    env->DeleteLocalRef(iterator);
-    env->DeleteLocalRef(setClass);
-    env->DeleteLocalRef(iteratorClass);
+    env->DeleteLocalRef(insetsClass);
 
-    return result;
+    return Insets{top, bottom, left, right};
 }
 
 void throwKotlinException(

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

@@ -1,9 +1,9 @@
 #include <jni.h>
 #include <string>
 #include <map>
+#include <UnistylesRuntime.h>
 
-int jobjectToInt(JNIEnv *env, jobject integer);
-std::string jstringToStdString(JNIEnv *env, jstring jStr);
-std::map<std::string, int> jobjectToStdMap(JNIEnv *env, jobject map);
+Dimensions jobjectToDimensions(JNIEnv *env, jobject dimensionObj);
+Insets jobjectToInsets(JNIEnv *env, jobject insetsObj);
 
 void throwKotlinException(JNIEnv *env, const char *message);

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

@@ -0,0 +1,116 @@
+package com.unistyles
+
+import android.annotation.SuppressLint
+import android.content.res.Configuration
+import com.facebook.react.bridge.ReactApplicationContext
+
+class UnistylesConfig(private val reactApplicationContext: ReactApplicationContext) {
+    private val insets: UnistylesInsets = UnistylesInsets(reactApplicationContext)
+    private val density: Float = reactApplicationContext.resources.displayMetrics.density
+    private var lastConfig: Config = this.getAppConfig()
+    private var lastLayoutConfig: LayoutConfig = this.getAppLayoutConfig()
+
+    fun hasNewConfig(): Boolean {
+        val newConfig = this.getAppConfig()
+        val newContentSizeCategory = newConfig.contentSizeCategory != lastConfig.contentSizeCategory
+        val newColorScheme = newConfig.colorScheme != lastConfig.colorScheme
+
+        if (!newContentSizeCategory && !newColorScheme) {
+            return false
+        }
+
+        lastConfig = newConfig
+        lastConfig.hasNewContentSizeCategory = newContentSizeCategory
+        lastConfig.hasNewColorScheme = newColorScheme
+
+        return true
+    }
+
+    fun hasNewLayoutConfig(): Boolean {
+        val newConfig = this.getAppLayoutConfig()
+
+        if (newConfig.isEqual(lastLayoutConfig)) {
+            return false
+        }
+
+        lastLayoutConfig = newConfig
+
+        return true
+    }
+
+    fun getConfig(): Config {
+        return this.lastConfig
+    }
+
+    fun getLayoutConfig(): LayoutConfig {
+        return this.lastLayoutConfig
+    }
+
+    private fun getAppConfig(): Config {
+        val fontScale = reactApplicationContext.resources.configuration.fontScale
+
+        return Config(
+            this.getColorScheme(),
+            this.getContentSizeCategory(fontScale),
+        )
+    }
+
+    private fun getAppLayoutConfig(): LayoutConfig {
+        val displayMetrics = reactApplicationContext.resources.displayMetrics
+        val screenWidth = (displayMetrics.widthPixels / density).toInt()
+        val screenHeight = (displayMetrics.heightPixels / density).toInt()
+
+        return LayoutConfig(
+            Dimensions(screenWidth, screenHeight),
+            this.insets.get(),
+            Dimensions(screenWidth, getStatusBarHeight()),
+            Dimensions(screenWidth, getNavigationBarHeight())
+        )
+    }
+
+    private fun getContentSizeCategory(fontScale: Float): String {
+        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
+    }
+
+    private fun getColorScheme(): String {
+        val colorScheme = when (reactApplicationContext.resources.configuration.uiMode.and(Configuration.UI_MODE_NIGHT_MASK)) {
+            Configuration.UI_MODE_NIGHT_YES -> "dark"
+            Configuration.UI_MODE_NIGHT_NO -> "light"
+            else -> "unspecified"
+        }
+
+        return colorScheme
+    }
+
+    @SuppressLint("InternalInsetResource", "DiscouragedApi")
+    private fun getStatusBarHeight(): Int {
+        val heightResId = reactApplicationContext.resources.getIdentifier("status_bar_height", "dimen", "android")
+
+        if (heightResId > 0) {
+            return (reactApplicationContext.resources.getDimensionPixelSize(heightResId) / density).toInt()
+        }
+
+        return 0
+    }
+
+    @SuppressLint("InternalInsetResource", "DiscouragedApi")
+    private fun getNavigationBarHeight(): Int {
+        val heightResId = reactApplicationContext.resources.getIdentifier("navigation_bar_height", "dimen", "android")
+
+        if (heightResId > 0) {
+            return (reactApplicationContext.resources.getDimensionPixelSize(heightResId) / density).toInt()
+        }
+
+        return 0
+    }
+}

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

@@ -0,0 +1,138 @@
+package com.unistyles
+
+import android.content.Context
+import android.graphics.Rect
+import android.os.Build
+import android.view.View
+import android.view.Window
+import android.view.WindowInsets
+import android.view.WindowManager
+import com.facebook.react.bridge.ReactApplicationContext
+import kotlin.math.roundToInt
+
+class UnistylesInsets(private val reactApplicationContext: ReactApplicationContext) {
+    private val density: Float = reactApplicationContext.resources.displayMetrics.density
+
+    fun get(): Insets {
+        return this.getCurrentInsets()
+    }
+
+    private fun getCurrentInsets(): Insets {
+        val baseInsets = this.getBaseInsets()
+        val statusBarTranslucent = this.hasTranslucentStatusBar(baseInsets) ?: return baseInsets
+        val window = reactApplicationContext.currentActivity?.window ?: return baseInsets
+        val shouldModifyLandscapeInsets = this.forceLandscapeInsets(baseInsets, window)
+
+        val topInset = this.getTopInset(baseInsets, statusBarTranslucent, window)
+        val bottomInset = this.getBottomInset(baseInsets, window)
+        val leftInset = if (shouldModifyLandscapeInsets) 0 else baseInsets.left
+        val rightInset = if (shouldModifyLandscapeInsets) 0 else baseInsets.right
+
+        return Insets(topInset, bottomInset, leftInset, rightInset)
+    }
+
+    @Suppress("DEPRECATION")
+    private fun getBaseInsets(): Insets {
+        // this is the best API, but it's available from Android 11
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            val windowManager = reactApplicationContext.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+            val systemBarsInsets = windowManager.currentWindowMetrics.windowInsets.getInsets(WindowInsets.Type.systemBars())
+
+            val top = (systemBarsInsets.top / density).roundToInt()
+            val bottom = (systemBarsInsets.bottom / density).roundToInt()
+            val left = (systemBarsInsets.left / density).roundToInt()
+            val right = (systemBarsInsets.right / density).roundToInt()
+
+            return Insets(top, bottom, left, right)
+        }
+
+        // available from Android 6.0
+        val window = reactApplicationContext.currentActivity?.window ?: return Insets(0, 0, 0, 0)
+        val systemInsets = window.decorView.rootWindowInsets
+
+        val top = (systemInsets.systemWindowInsetTop / density).roundToInt()
+        val bottom = (systemInsets.systemWindowInsetBottom / density).roundToInt()
+        val left = (systemInsets.systemWindowInsetLeft / density).roundToInt()
+        val right = (systemInsets.systemWindowInsetRight / density).roundToInt()
+
+        return Insets(top, bottom, left, right)
+    }
+
+    // this function helps to detect statusBar translucent, as React Native is using weird API instead of windows flags
+    private fun hasTranslucentStatusBar(baseInsets: Insets): Boolean? {
+        val window = reactApplicationContext.currentActivity?.window ?: return null
+        val contentView = window.decorView.findViewById<View>(android.R.id.content) ?: return null
+        val decorViewLocation = IntArray(2)
+        val contentViewLocation = IntArray(2)
+
+        // decor view is a top level view with navigationBar and statusBar
+        window.decorView.getLocationOnScreen(decorViewLocation)
+        // content view is view without navigationBar and statusBar
+        contentView.getLocationOnScreen(contentViewLocation)
+
+        val statusBarHeight = contentViewLocation[1] - decorViewLocation[1]
+
+        // if positions are the same, then the status bar is translucent
+        return statusBarHeight == 0
+    }
+
+    private fun getTopInset(baseInsets: Insets, statusBarTranslucent: Boolean, window: Window): Int {
+        if (!statusBarTranslucent) {
+            return 0
+        }
+
+        return baseInsets.top
+    }
+
+    @Suppress("DEPRECATION")
+    private fun getBottomInset(baseInsets: Insets, window: Window): Int {
+        val translucentNavigation = hasTranslucentNavigation(window)
+
+        // Android 11 has inconsistent FLAG_LAYOUT_NO_LIMITS, which alone does nothing
+        // https://stackoverflow.com/questions/64153785/android-11-window-setdecorfitssystemwindow-doesnt-show-screen-behind-status-a
+        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
+            if ((hasFullScreenMode(window) && translucentNavigation) || translucentNavigation) {
+                return baseInsets.bottom
+            }
+
+            return 0
+        }
+
+        return if (hasTranslucentNavigation(window) || hasFullScreenMode(window)) baseInsets.bottom else 0
+    }
+
+    private fun forceLandscapeInsets(baseInsets: Insets, window: Window): Boolean {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            return false
+        }
+
+        val displayMetrics = reactApplicationContext.resources.displayMetrics
+        val isLandscape = displayMetrics.widthPixels > displayMetrics.heightPixels
+
+        if (!isLandscape) {
+            return false
+        }
+
+        val contentView = window.decorView.findViewById<View>(android.R.id.content) ?: return false
+        val visibleRect = Rect()
+        val drawingRect = Rect()
+
+        window.decorView.getGlobalVisibleRect(visibleRect)
+        contentView.getDrawingRect(drawingRect)
+
+        // width is equal to navigationBarHeight + statusBarHeight (in landscape)
+        val width = ((visibleRect.width() - contentView.width) / density).roundToInt()
+
+        // we should correct landscape if insets are equal to width
+        return (baseInsets.left + baseInsets.right) == width
+    }
+
+    @Suppress("DEPRECATION")
+    private fun hasTranslucentNavigation(window: Window): Boolean {
+        return (window.attributes.flags and WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION) == WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION
+    }
+
+    private fun hasFullScreenMode(window: Window): Boolean {
+        return (window.attributes.flags and WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS) == WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS
+    }
+}

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

@@ -0,0 +1,85 @@
+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
+    }
+
+    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
+) {
+    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)
+        }
+    }
+}
+
+class Config(
+    val colorScheme: String,
+    val contentSizeCategory: String,
+) {
+    var hasNewColorScheme: Boolean = false
+    var hasNewContentSizeCategory: Boolean = false
+
+    override fun toString(): String {
+        return "colorScheme=${colorScheme} contentSizeCategory:${contentSizeCategory}"
+    }
+}

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

@@ -1,92 +1,23 @@
 package com.unistyles
 
-import android.annotation.SuppressLint
-import android.content.res.Configuration
-import android.os.Build
-import android.view.WindowInsets
 import com.facebook.react.bridge.ReactApplicationContext
 
-class Platform(private val reactApplicationContext: ReactApplicationContext) {
-    @SuppressLint("InternalInsetResource", "DiscouragedApi", "ObsoleteSdkInt")
-    fun getConfig(): Map<String, Any> {
-        val displayMetrics = reactApplicationContext.resources.displayMetrics
-        val fontScale = reactApplicationContext.resources.configuration.fontScale
-        val screenWidth = (displayMetrics.widthPixels / displayMetrics.density).toInt()
-        val screenHeight = (displayMetrics.heightPixels / displayMetrics.density).toInt()
+class Platform(reactApplicationContext: ReactApplicationContext) {
+    private val config: UnistylesConfig = UnistylesConfig(reactApplicationContext)
 
-        return mapOf(
-            "width" to screenWidth,
-            "height" to screenHeight,
-            "colorScheme" to getColorScheme(),
-            "contentSizeCategory" to getContentSizeCategory(fontScale),
-            "insets" to getScreenInsets(displayMetrics.density),
-            "statusBar" to mapOf(
-                "height" to getStatusBarHeight(displayMetrics.density),
-                "width" to screenWidth
-            )
-        )
+    fun hasNewLayoutConfig(): Boolean {
+        return this.config.hasNewLayoutConfig()
     }
 
-    private fun getContentSizeCategory(fontScale: Float): String {
-        val contentSizeCategory = when {
-            fontScale <= 0.85f -> "Small"
-            fontScale <= 1.0f -> "Default"
-            fontScale <= 1.15f -> "Large"
-            fontScale <= 1.3f -> "ExtraLarge"
-            else -> "Huge"
-        }
-
-        return contentSizeCategory
-    }
-
-    private fun getColorScheme(): String {
-        val colorScheme = when (reactApplicationContext.resources.configuration.uiMode.and(Configuration.UI_MODE_NIGHT_MASK)) {
-            Configuration.UI_MODE_NIGHT_YES -> "dark"
-            Configuration.UI_MODE_NIGHT_NO -> "light"
-            else -> "unspecified"
-        }
-
-        return colorScheme
+    fun hasNewConfig(): Boolean {
+        return this.config.hasNewConfig()
     }
 
-    @Suppress("DEPRECATION")
-    private fun getScreenInsets(density: Float): Map<String, Int> {
-        val insets = mutableMapOf(
-            "top" to 0,
-            "bottom" to 0,
-            "left" to 0,
-            "right" to 0
-        )
-
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-            val systemInsets = reactApplicationContext.currentActivity?.window?.decorView?.rootWindowInsets?.getInsets(WindowInsets.Type.displayCutout())
-
-            insets["top"] = ((systemInsets?.top ?: 0) / density).toInt()
-            insets["bottom"] = ((systemInsets?.bottom ?: 0) / density).toInt()
-            insets["left"] = ((systemInsets?.left ?: 0) / density).toInt()
-            insets["right"] = ((systemInsets?.right ?: 0) / density).toInt()
-
-            return insets
-        }
-
-        val systemInsets = reactApplicationContext.currentActivity?.window?.decorView?.rootWindowInsets
-
-        insets["top"] = ((systemInsets?.systemWindowInsetTop ?: 0) / density).toInt()
-        insets["bottom"] = ((systemInsets?.systemWindowInsetBottom ?: 0) / density).toInt()
-        insets["left"] = ((systemInsets?.systemWindowInsetLeft ?: 0) / density).toInt()
-        insets["right"] = ((systemInsets?.systemWindowInsetRight ?: 0) / density).toInt()
-
-        return insets
+    fun getConfig(): Config {
+        return this.config.getConfig()
     }
 
-    @SuppressLint("InternalInsetResource", "DiscouragedApi")
-    private fun getStatusBarHeight(density: Float): Int {
-        val heightResId = reactApplicationContext.resources.getIdentifier("status_bar_height", "dimen", "android")
-
-        if (heightResId > 0) {
-            return (reactApplicationContext.resources.getDimensionPixelSize(heightResId) / density).toInt()
-        }
-
-        return 0
+    fun getLayoutConfig(): LayoutConfig {
+        return this.config.getLayoutConfig()
     }
 }