react-native-unistyles 2.8.0-beta.1 → 2.8.0-beta.3

package/android/CMakeLists.txt

@@ -5,8 +5,11 @@ project(unistyles)
 add_library(unistyles
     SHARED
     ../cxx/UnistylesRuntime.cpp
+    ../cxx/UnistylesModel.cpp
+    ../cxx/UnistylesImpl.cpp
     ./src/main/cxx/cpp-adapter.cpp
     ./src/main/cxx/helpers.cpp
+    ./src/main/cxx/platform.cpp
 )
 
 include_directories(
@@ -14,15 +17,19 @@ include_directories(
 )
 
 set_target_properties(unistyles PROPERTIES
-    CXX_STANDARD 17
+    CXX_STANDARD 20
     CXX_STANDARD_REQUIRED ON
     CXX_EXTENSIONS OFF
     POSITION_INDEPENDENT_CODE ON
 )
 
 find_package(ReactAndroid REQUIRED CONFIG)
+find_package(fbjni REQUIRED CONFIG)
 
 target_link_libraries(unistyles
     ReactAndroid::jsi
+    ReactAndroid::turbomodulejsijni
+    ReactAndroid::react_nativemodule_core
     android
+    fbjni::fbjni
 )

package/android/build.gradle

@@ -60,7 +60,10 @@ android {
             "META-INF",
             "META-INF/**",
             "**/libjsi.so",
-            "**/libc++_shared.so"
+            "**/libc++_shared.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libturbomodulejsijni.so",
+            "**/libfbjni.so"
         ]
     }
 }

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

@@ -1,8 +1,10 @@
 #include <jni.h>
 #include <jsi/jsi.h>
 #include <map>
+#include <ReactCommon/CallInvokerHolder.h>
 #include "UnistylesRuntime.h"
 #include "helpers.h"
+#include "platform.h"
 
 using namespace facebook;
 
@@ -11,116 +13,24 @@ std::shared_ptr<UnistylesRuntime> unistylesRuntime = nullptr;
 
 extern "C"
 JNIEXPORT void JNICALL
-Java_com_unistyles_UnistylesModule_nativeInstall(
-        JNIEnv *env,
-        jobject thiz,
-        jlong jsi,
-        jobject screen,
-        jstring colorScheme,
-        jstring contentSizeCategory,
-        jobject insets,
-        jobject statusBar,
-        jobject navigationBar
-) {
-    auto runtime = reinterpret_cast<facebook::jsi::Runtime *>(jsi);
+Java_com_unistyles_UnistylesModule_nativeInstall(JNIEnv *env, jobject thiz, jlong jsi, jobject callInvokerHolder) {
+    auto runtime = reinterpret_cast<jsi::Runtime *>(jsi);
+    auto callInvoker{
+        jni::alias_ref<react::CallInvokerHolder::javaobject>{ reinterpret_cast<react::CallInvokerHolder::javaobject>(callInvokerHolder)} -> cthis() ->getCallInvoker()
+    };
 
     if (unistylesModule == nullptr) {
         unistylesModule = env->NewGlobalRef(thiz);
     }
 
-    if (runtime == nullptr || unistylesModule == nullptr) {
+    if (unistylesModule == nullptr) {
         return throwKotlinException(env, "Something went wrong while initializing UnistylesModule");
     }
 
-    const char *colorSchemeChars = env->GetStringUTFChars(colorScheme, nullptr);
-    std::string colorSchemeStr(colorSchemeChars);
-    env->ReleaseStringUTFChars(colorScheme, colorSchemeChars);
-
-    const char *contentSizeCategoryChars = env->GetStringUTFChars(contentSizeCategory, nullptr);
-    std::string contentSizeCategoryStr(contentSizeCategoryChars);
-    env->ReleaseStringUTFChars(contentSizeCategory, contentSizeCategoryChars);
-
-    unistylesRuntime = std::make_shared<UnistylesRuntime>(
-        jobjectToDimensions(env, screen),
-        colorSchemeStr,
-        contentSizeCategoryStr,
-        jobjectToInsets(env, insets),
-        jobjectToDimensions(env, statusBar),
-        jobjectToDimensions(env, navigationBar)
-    );
-
-    unistylesRuntime->onThemeChange([=](const std::string &theme) {
-        jstring themeStr = env->NewStringUTF(theme.c_str());
-        jclass cls = env->GetObjectClass(unistylesModule);
-        jmethodID methodId = env->GetMethodID(cls, "onThemeChange", "(Ljava/lang/String;)V");
-
-        env->CallVoidMethod(unistylesModule, methodId, themeStr);
-        env->DeleteLocalRef(themeStr);
-        env->DeleteLocalRef(cls);
-    });
-
-    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);
-        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);
-    });
-
-    unistylesRuntime->onPluginChange([=]() {
-        jclass cls = env->GetObjectClass(unistylesModule);
-        jmethodID methodId = env->GetMethodID(cls, "onPluginChange", "()V");
-
-        env->CallVoidMethod(unistylesModule, methodId);
-        env->DeleteLocalRef(cls);
-    });
-
-    unistylesRuntime->onContentSizeCategoryChange([=](const std::string &contentSizeCategory) {
-        jstring contentSizeCategoryStr = env->NewStringUTF(contentSizeCategory.c_str());
-        jclass cls = env->GetObjectClass(unistylesModule);
-        jmethodID methodId = env->GetMethodID(cls, "onContentSizeCategoryChange", "(Ljava/lang/String;)V");
-
-        env->CallVoidMethod(unistylesModule, methodId, contentSizeCategoryStr);
-        env->DeleteLocalRef(contentSizeCategoryStr);
-        env->DeleteLocalRef(cls);
-    });
-
-    unistylesRuntime->onSetNavigationBarColor([=](const 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");
-
-        env->CallVoidMethod(unistylesModule, methodId, colorStr);
-        env->DeleteLocalRef(colorStr);
-        env->DeleteLocalRef(cls);
-    });
-
-    unistylesRuntime->onSetStatusBarColor([=](const 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");
-
-        env->CallVoidMethod(unistylesModule, methodId, colorStr);
-        env->DeleteLocalRef(colorStr);
-        env->DeleteLocalRef(cls);
-    });
+    unistylesRuntime = std::make_shared<UnistylesRuntime>(*runtime, callInvoker);
+    makeShared(env, unistylesModule, unistylesRuntime);
 
     jsi::Object hostObject = jsi::Object::createFromHostObject(*runtime, unistylesRuntime);
-
     runtime->global().setProperty(*runtime, "__UNISTYLES__", std::move(hostObject));
 }
 

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

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <jni.h>
 #include <string>
 #include <map>

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

@@ -0,0 +1,126 @@
+#include "platform.h"
+
+void makeShared(JNIEnv *env, jobject unistylesModule, std::shared_ptr<UnistylesRuntime> unistylesRuntime) {
+    unistylesRuntime->setScreenDimensionsCallback([&](){
+        return getScreenDimensions(env, unistylesModule);
+    });
+
+    unistylesRuntime->setColorSchemeCallback([&](){
+        return getColorScheme(env, unistylesModule);
+    });
+
+    unistylesRuntime->setStatusBarDimensionsCallback([&](){
+        return getStatusBarDimensions(env, unistylesModule);
+    });
+
+    unistylesRuntime->setNavigationBarDimensionsCallback([&](){
+        return getNavigationBarDimensions(env, unistylesModule);
+    });
+
+    unistylesRuntime->setInsetsCallback([&](){
+        return getInsets(env, unistylesModule);
+    });
+
+    unistylesRuntime->setContentSizeCategoryCallback([&](){
+        return getContentSizeCategory(env, unistylesModule);
+    });
+
+    unistylesRuntime->setNavigationBarColorCallback([=](const std::string &color) {
+        setNavigationBarColor(env, unistylesModule, color);
+    });
+
+    unistylesRuntime->setStatusBarColorCallback([=](const std::string &color) {
+        setStatusBarColor(env, unistylesModule, color);
+    });
+
+    unistylesRuntime->screen = getScreenDimensions(env, unistylesModule);
+    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);
+}
+
+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);
+
+    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);
+    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);
+    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);
+    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);
+    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);
+    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");
+
+    env->CallVoidMethod(unistylesModule, methodId, colorStr);
+    env->DeleteLocalRef(colorStr);
+    env->DeleteLocalRef(cls);
+}
+
+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");
+
+    env->CallVoidMethod(unistylesModule, methodId, colorStr);
+    env->DeleteLocalRef(colorStr);
+    env->DeleteLocalRef(cls);
+}

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

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "UnistylesRuntime.h"
+#include "helpers.h"
+
+void makeShared(JNIEnv *env, jobject unistylesModule, std::shared_ptr<UnistylesRuntime> unistylesRuntime);
+Dimensions getScreenDimensions(JNIEnv *env, jobject unistylesModule);
+std::string getColorScheme(JNIEnv *env, jobject unistylesModule);
+Dimensions getStatusBarDimensions(JNIEnv *env, jobject unistylesModule);
+Dimensions getNavigationBarDimensions(JNIEnv *env, jobject unistylesModule);
+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);

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

@@ -36,50 +36,29 @@ class Insets(var top: Int, var bottom: Int, var left: Int, var right: Int) {
     }
 }
 
-class LayoutConfig(
-    val screen: Dimensions,
-    val insets: Insets,
-    val statusBar: Dimensions,
-    val navigationBar: Dimensions
+class InsetsCompat(
+    val statusBar: Insets,
+    val navigationBar: Insets,
+    val cutout: Insets
 ) {
-    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)
+            append(" cutout=")
+            append(cutout)
         }
     }
-}
 
-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}"
+    companion object {
+        fun getDefaults(): InsetsCompat {
+            return InsetsCompat(
+                Insets(0, 0, 0, 0),
+                Insets(0, 0, 0, 0),
+                Insets(0, 0, 0, 0)
+            )
+        }
     }
 }

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

@@ -1,26 +1,107 @@
 package com.unistyles
 
+import android.content.res.Configuration
+import android.graphics.Rect
+import android.util.DisplayMetrics
+import android.view.View
+import androidx.core.view.WindowInsetsCompat
 import com.facebook.react.bridge.ReactApplicationContext
+import kotlin.math.max
 
-class Platform(reactApplicationContext: ReactApplicationContext) {
-    private val config: UnistylesConfig = UnistylesConfig(reactApplicationContext)
+class Platform(private val reactApplicationContext: ReactApplicationContext) {
+    private val displayMetrics: DisplayMetrics = reactApplicationContext.resources.displayMetrics
+    private val density: Float = reactApplicationContext.resources.displayMetrics.density
+    private var insetsCompat: InsetsCompat = InsetsCompat.getDefaults()
 
     var defaultNavigationBarColor: Int? = null
     var defaultStatusBarColor: Int? = null
 
-    fun hasNewLayoutConfig(): Boolean {
-        return this.config.hasNewLayoutConfig()
+    fun getScreenDimensions(): Dimensions {
+        val screenWidth = (displayMetrics.widthPixels / density).toInt()
+        val screenHeight = (displayMetrics.heightPixels / density).toInt()
+
+        return Dimensions(screenWidth, screenHeight)
+    }
+
+    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 screenWidth = (displayMetrics.widthPixels / density).toInt()
+
+        return Dimensions(screenWidth, getStatusBarHeight())
+    }
+
+    fun getNavigationBarDimensions(): Dimensions {
+        val screenWidth = (displayMetrics.widthPixels / density).toInt()
+
+        return Dimensions(screenWidth, getNavigationBarHeight())
     }
 
-    fun hasNewConfig(): Boolean {
-        return this.config.hasNewConfig()
+    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, decorView: View) {
+        val statusBar = insetsCompat.getInsets(WindowInsetsCompat.Type.statusBars())
+        val navigationBar = insetsCompat.getInsets(WindowInsetsCompat.Type.navigationBars())
+        val cutout = insetsCompat.getInsets(WindowInsetsCompat.Type.displayCutout())
+
+        // 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)
+
+        val visibleTopFrame = max(visibleFrame.top, statusBar.top)
+
+        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)
+        )
+    }
+
+    fun getInsets(): Insets {
+        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()
+        )
     }
 
-    fun getConfig(): Config {
-        return this.config.getConfig()
+    private fun getStatusBarHeight(): Int {
+        return (this.insetsCompat.statusBar.top / density).toInt()
     }
 
-    fun getLayoutConfig(): LayoutConfig {
-        return this.config.getLayoutConfig()
+    private fun getNavigationBarHeight(): Int {
+        return (this.insetsCompat.navigationBar.bottom / density).toInt()
     }
 }