react-native-unistyles 2.10.0 → 3.0.0-alpha.2

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

@@ -1,27 +0,0 @@
-package com.unistyles
-
-class Dimensions(
-    var width: Int,
-    var height: Int
-) {
-    override fun toString(): String {
-        return "${width}x${height}"
-    }
-}
-
-class Screen(
-    var width: Int,
-    var height: Int,
-    var pixelRatio: Float,
-    var fontScale: Float
-) {
-    override fun toString(): String {
-        return "${width}x${height} ${pixelRatio} ${fontScale}"
-    }
-}
-
-class Insets(var top: Int, var bottom: Int, var left: Int, var right: Int) {
-    override fun toString(): String {
-        return "T:${top}B:${bottom}L:${left}R:${right}"
-    }
-}

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

@@ -1,324 +0,0 @@
-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(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
-
-    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 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())
-    }
-}

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

@@ -1,217 +0,0 @@
-package com.unistyles
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.os.Build
-import android.os.Handler
-import android.os.Looper
-import android.util.Log
-import android.view.View
-import androidx.core.view.ViewCompat
-import androidx.core.view.WindowCompat
-import androidx.core.view.WindowInsetsAnimationCompat
-import androidx.core.view.WindowInsetsCompat
-import com.facebook.react.bridge.LifecycleEventListener
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder
-import kotlin.math.roundToInt
-
-class UnistylesModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext), LifecycleEventListener {
-    private var isCxxReady: Boolean = false
-    private var platform: Platform = Platform(reactContext)
-
-    private val configurationChangeReceiver = object : BroadcastReceiver() {
-        override fun onReceive(context: Context, intent: Intent) {
-            if (!this@UnistylesModule.isCxxReady) {
-                return
-            }
-
-            if (intent.action == Intent.ACTION_CONFIGURATION_CHANGED) {
-                Handler(Looper.getMainLooper()).postDelayed({
-                    this@UnistylesModule.onConfigChange()
-                }, 10)
-            }
-
-            val newConfig = context.resources.configuration
-
-            if (newConfig.orientation != platform.orientation) {
-                platform.orientation = newConfig.orientation
-
-                this@UnistylesModule.onLayoutConfigChange()
-            }
-        }
-    }
-
-    override fun getName() = NAME
-    companion object {
-        const val NAME = "Unistyles"
-    }
-
-    init {
-        reactApplicationContext.registerReceiver(configurationChangeReceiver, IntentFilter(Intent.ACTION_CONFIGURATION_CHANGED))
-        reactApplicationContext.addLifecycleEventListener(this)
-    }
-
-    override fun invalidate() {
-        reactApplicationContext.unregisterReceiver(configurationChangeReceiver)
-        reactApplicationContext.removeLifecycleEventListener(this)
-
-        if (this.isCxxReady) {
-            this.nativeDestroy()
-        }
-    }
-
-    private fun onConfigChange() {
-        val colorScheme = this.platform.getColorScheme()
-        val contentSizeCategory = this.platform.getContentSizeCategory()
-
-        reactApplicationContext.runOnJSQueueThread {
-            this.nativeOnAppearanceChange(colorScheme)
-            this.nativeOnContentSizeCategoryChange(contentSizeCategory)
-        }
-    }
-
-    private fun onLayoutConfigChange() {
-        val screen = this.platform.getScreenDimensions()
-        val insets = this.platform.getInsets()
-        val statusBar = this.platform.getStatusBarDimensions()
-        val navigationBar = this.platform.getNavigationBarDimensions()
-
-        reactApplicationContext.runOnJSQueueThread {
-            this.nativeOnOrientationChange(
-                screen,
-                insets,
-                statusBar,
-                navigationBar
-            )
-        }
-    }
-
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    fun install(): Boolean {
-        return try {
-            System.loadLibrary("unistyles")
-
-            this.reactApplicationContext.javaScriptContextHolder?.let { contextHolder ->
-                this.reactApplicationContext.catalystInstance.jsCallInvokerHolder?.let { callInvokerHolder: CallInvokerHolder ->
-                    this.nativeInstall(contextHolder.get(), callInvokerHolder)
-                    this.isCxxReady = true
-
-                    Log.i(NAME, "Installed Unistyles \uD83E\uDD84!")
-
-                    return true
-                }
-            }
-
-            false
-        } catch (e: Exception) {
-            this.isCxxReady = false
-
-            return false
-        }
-    }
-
-    private external fun nativeInstall(jsi: Long, callInvoker: CallInvokerHolder)
-    private external fun nativeDestroy()
-    private external fun nativeOnOrientationChange(screen: Screen, insets: Insets, statusBar: Dimensions, navigationBar: Dimensions)
-    private external fun nativeOnAppearanceChange(colorScheme: String)
-    private external fun nativeOnContentSizeCategoryChange(contentSizeCategory: String)
-
-    private fun enableEdgeToEdge() {
-        this.reactApplicationContext.currentActivity?.let { activity ->
-            activity.runOnUiThread {
-                WindowCompat.setDecorFitsSystemWindows(activity.window, false)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun addListener(eventName: String?) = Unit
-
-    @ReactMethod
-    fun removeListeners(count: Double) = Unit
-
-    override fun onHostResume() {
-        this.enableEdgeToEdge()
-
-        if (isCxxReady) {
-            this.onConfigChange()
-        }
-
-        this.reactApplicationContext.currentActivity?.let { activity ->
-            activity.findViewById<View>(android.R.id.content)?.let { mainView ->
-                ViewCompat.setOnApplyWindowInsetsListener(mainView) { _, insets ->
-                    this.platform.setInsetsCompat(insets, activity.window, null)
-
-                    if (this.isCxxReady) {
-                        this.onLayoutConfigChange()
-                    }
-
-                    insets
-                }
-
-                if (platform.hasAnimatedInsets && Build.VERSION.SDK_INT >= 30) {
-                    ViewCompat.setWindowInsetsAnimationCallback(
-                        mainView,
-                        object : WindowInsetsAnimationCompat.Callback(DISPATCH_MODE_STOP) {
-                            var initialBottomInsets = 0
-                            var isGoingUp = false
-
-                            override fun onPrepare(animation: WindowInsetsAnimationCompat) {
-                                val insets = ViewCompat.getRootWindowInsets(mainView)
-                                val isKeyboardVisible = insets?.isVisible(WindowInsetsCompat.Type.ime()) ?: false
-
-                                if (!isKeyboardVisible) {
-                                    val density = reactApplicationContext.resources.displayMetrics.density
-
-                                    initialBottomInsets = (this@UnistylesModule.platform.getInsets().bottom * density).roundToInt()
-                                }
-
-                                isGoingUp = !isKeyboardVisible
-                            }
-
-                            override fun onProgress(
-                                insets: WindowInsetsCompat,
-                                runningAnimations: List<WindowInsetsAnimationCompat>
-                            ): WindowInsetsCompat {
-                                runningAnimations.firstOrNull()?.let { animation ->
-                                    val progress = animation.fraction
-                                    val nextBottomInset = if (isGoingUp) {
-                                        (initialBottomInsets - (progress * initialBottomInsets).roundToInt())
-                                    } else {
-                                        // enable this in Unistyles 3.0 to get real time bottom insets
-                                        // initialBottomInsets - (initialBottomInsets - (progress * initialBottomInsets).roundToInt())
-                                        initialBottomInsets
-                                    }
-
-                                    this@UnistylesModule.platform.setInsetsCompat(insets, activity.window, nextBottomInset)
-
-                                    if (!isGoingUp) {
-                                        this@UnistylesModule.onLayoutConfigChange()
-                                    }
-                                }
-
-                                return insets
-                            }
-                        }
-                    )
-                }
-            }
-        }
-    }
-
-    override fun onHostPause() {
-        this.reactApplicationContext.currentActivity?.let { activity ->
-            activity.window?.decorView?.let { view ->
-                ViewCompat.setOnApplyWindowInsetsListener(view, null)
-                ViewCompat.setWindowInsetsAnimationCallback(view, null)
-            }
-        }
-    }
-
-    override fun onHostDestroy() {}
-}

package/cxx/Macros.h

@@ -1,11 +0,0 @@
-#pragma once
-
-#define HOST_FN(name, args, fn_body) \
-    jsi::Function::createFromHostFunction(rt, \
-        jsi::PropNameID::forAscii(rt, name), \
-        args, \
-        [this, &fnName](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) -> jsi::Value \
-        fn_body \
-    ); \
-
-#define BIND_FN(fn) std::bind(&UnistylesRuntime::fn, this, std::placeholders::_1, std::placeholders::_2)