rn-system-bar 3.0.2 → 3.1.0

package/android/src/main/java/com/systembar/SystemBarModule.kt

@@ -1,22 +1,36 @@
 // ─────────────────────────────────────────────
-//  rn-system-bar · SystemBarModule.kt
-//  Android Native Module — Old + New Architecture
+//  rn-system-bar · SystemBarModule.kt  v5
+//  New: Network, Battery, Haptics, Screencast, FontScale
 // ─────────────────────────────────────────────
 
 package com.systembar
 
 import android.app.Activity
+import android.content.BroadcastReceiver
 import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
 import android.content.pm.ActivityInfo
-import android.graphics.Color
+import android.hardware.display.DisplayManager
 import android.media.AudioManager
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import android.os.BatteryManager
 import android.os.Build
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.os.VibratorManager
 import android.provider.Settings
+import android.view.Display
 import android.view.View
+import android.view.WindowInsets
 import android.view.WindowInsetsController
 import android.view.WindowManager
 
 import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
 
 class SystemBarModule(
   private val reactContext: ReactApplicationContext
@@ -24,340 +38,413 @@ class SystemBarModule(
 
   override fun getName(): String = "SystemBar"
 
-  // ── Helper ─────────────────────────────────────
   private fun activity(): Activity? = reactContext.currentActivity
 
-  private fun audioManager(): AudioManager =
-    reactContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+  private fun emit(event: String, data: WritableMap) {
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(event, data)
+  }
+
+  private fun audioManager()        = reactContext.getSystemService(Context.AUDIO_SERVICE)        as AudioManager
+  private fun connectivityManager() = reactContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+  private fun batteryManager()      = reactContext.getSystemService(Context.BATTERY_SERVICE)      as BatteryManager
+  private fun displayManager()      = reactContext.getSystemService(Context.DISPLAY_SERVICE)      as DisplayManager
+
+  @Suppress("DEPRECATION")
+  private fun vibrator(): Vibrator = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+    (reactContext.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager).defaultVibrator
+  } else {
+    reactContext.getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
+  }
 
   private fun streamType(stream: String): Int = when (stream) {
     "ring"         -> AudioManager.STREAM_RING
     "notification" -> AudioManager.STREAM_NOTIFICATION
     "alarm"        -> AudioManager.STREAM_ALARM
     "system"       -> AudioManager.STREAM_SYSTEM
-    else           -> AudioManager.STREAM_MUSIC  // default: "music"
+    else           -> AudioManager.STREAM_MUSIC
   }
 
   // ═══════════════════════════════════════════════
-  //  NAVIGATION BAR
+  //  BRIGHTNESS
   // ═══════════════════════════════════════════════
 
   @ReactMethod
-  fun setNavigationBarColor(color: String) {
-    val act = activity() ?: return
-    act.runOnUiThread {
-      try {
-        act.window.navigationBarColor = Color.parseColor(color)
-      } catch (e: Exception) {
-        // ignore invalid color
+  fun setBrightness(level: Float) {
+    activity()?.runOnUiThread {
+      val lp = activity()!!.window.attributes
+      lp.screenBrightness = level.coerceIn(0f, 1f)
+      activity()!!.window.attributes = lp
+    }
+  }
+
+  @ReactMethod
+  fun getBrightness(promise: Promise) {
+    try {
+      val lp = activity()?.window?.attributes
+      if (lp != null && lp.screenBrightness >= 0f) {
+        promise.resolve(lp.screenBrightness.toDouble()); return
       }
+      val sys = Settings.System.getInt(reactContext.contentResolver, Settings.System.SCREEN_BRIGHTNESS, 128)
+      promise.resolve(sys / 255.0)
+    } catch (e: Exception) { promise.reject("BRIGHTNESS_ERROR", e.message, e) }
+  }
+
+  // ═══════════════════════════════════════════════
+  //  VOLUME
+  // ═══════════════════════════════════════════════
+
+  private var suppressVolumeHUD = false
+
+  @ReactMethod fun setVolumeHUDVisible(visible: Boolean) { suppressVolumeHUD = !visible }
+
+  @ReactMethod
+  fun setVolume(level: Float, stream: String) {
+    try {
+      val am = audioManager(); val type = streamType(stream)
+      val vol = (level.coerceIn(0f, 1f) * am.getStreamMaxVolume(type)).toInt()
+      am.setStreamVolume(type, vol, if (suppressVolumeHUD) 0 else AudioManager.FLAG_SHOW_UI)
+    } catch (_: Exception) {}
+  }
+
+  @ReactMethod
+  fun getVolume(stream: String, promise: Promise) {
+    try {
+      val am = audioManager(); val type = streamType(stream)
+      val max = am.getStreamMaxVolume(type)
+      promise.resolve(if (max > 0) am.getStreamVolume(type).toDouble() / max else 0.0)
+    } catch (e: Exception) { promise.reject("VOLUME_ERROR", e.message, e) }
+  }
+
+  // ═══════════════════════════════════════════════
+  //  SCREEN
+  // ═══════════════════════════════════════════════
+
+  @ReactMethod
+  fun keepScreenOn(enable: Boolean) {
+    activity()?.runOnUiThread {
+      if (enable) activity()!!.window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+      else        activity()!!.window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
     }
   }
 
   @ReactMethod
-  fun setNavigationBarVisibility(mode: String) {
-    val act = activity() ?: return
-    act.runOnUiThread {
+  fun immersiveMode(enable: Boolean) {
+    activity()?.runOnUiThread {
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-        val controller = act.window.insetsController ?: return@runOnUiThread
-        if (mode == "hidden") {
-          controller.hide(android.view.WindowInsets.Type.navigationBars())
+        val c = activity()!!.window.insetsController ?: return@runOnUiThread
+        if (enable) {
+          c.hide(WindowInsets.Type.statusBars() or WindowInsets.Type.navigationBars())
+          c.systemBarsBehavior = WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
         } else {
-          controller.show(android.view.WindowInsets.Type.navigationBars())
+          c.show(WindowInsets.Type.statusBars() or WindowInsets.Type.navigationBars())
         }
       } else {
         @Suppress("DEPRECATION")
-        if (mode == "hidden") {
-          act.window.decorView.systemUiVisibility =
-            act.window.decorView.systemUiVisibility or
-            View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or
-            View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
-        } else {
-          act.window.decorView.systemUiVisibility =
-            act.window.decorView.systemUiVisibility and
-            View.SYSTEM_UI_FLAG_HIDE_NAVIGATION.inv()
-        }
+        activity()!!.window.decorView.systemUiVisibility = if (enable) {
+          View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or
+          View.SYSTEM_UI_FLAG_FULLSCREEN or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or
+          View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
+        } else { View.SYSTEM_UI_FLAG_VISIBLE }
       }
     }
   }
 
+  // ═══════════════════════════════════════════════
+  //  ORIENTATION
+  // ═══════════════════════════════════════════════
+
   @ReactMethod
-  fun setNavigationBarButtonStyle(style: String) {
-    val act = activity() ?: return
-    act.runOnUiThread {
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-        val controller = act.window.insetsController ?: return@runOnUiThread
-        controller.setSystemBarsAppearance(
-          if (style == "dark")
-            WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS
-          else 0,
-          WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS
-        )
-      } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        @Suppress("DEPRECATION")
-        val flags = act.window.decorView.systemUiVisibility
-        act.window.decorView.systemUiVisibility = if (style == "dark") {
-          flags or View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR
-        } else {
-          flags and View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR.inv()
-        }
-      }
+  fun setOrientation(mode: String) {
+    activity()?.requestedOrientation = when (mode) {
+      "portrait"        -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+      "landscape"       -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
+      "landscape-left"  -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
+      "landscape-right" -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
+      else              -> ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
     }
   }
 
-  @ReactMethod
-  fun setNavigationBarStyle(style: String) {
-    // "style" maps to button style + optional color hinting
-    val act = activity() ?: return
-    act.runOnUiThread {
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-        val controller = act.window.insetsController ?: return@runOnUiThread
-        val useLightIcons = style == "light"
-        controller.setSystemBarsAppearance(
-          if (useLightIcons) 0
-          else WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS,
-          WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS
-        )
-      } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        @Suppress("DEPRECATION")
-        val flags = act.window.decorView.systemUiVisibility
-        act.window.decorView.systemUiVisibility = when (style) {
-          "dark" -> flags or View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR
-          else   -> flags and View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR.inv()
-        }
+  // ═══════════════════════════════════════════════
+  //  🆕 NETWORK INFO
+  // ═══════════════════════════════════════════════
+
+  private var networkCallback: ConnectivityManager.NetworkCallback? = null
+
+  private fun buildNetworkMap(): WritableMap {
+    val cm = connectivityManager()
+    val map = Arguments.createMap()
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      val net  = cm.activeNetwork
+      val caps = cm.getNetworkCapabilities(net)
+      val connected = caps != null
+
+      map.putBoolean("isConnected", connected)
+
+      val type = when {
+        caps == null                                                     -> "none"
+        caps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)            -> "wifi"
+        caps.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)        -> "cellular"
+        caps.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)        -> "ethernet"
+        else                                                             -> "unknown"
       }
+      map.putString("type", type)
+
+      // Cellular generation
+      val cellGen: String? = if (type == "cellular") {
+        val am = audioManager()  // not audio — reuse context trick; use TelephonyManager instead
+        null // placeholder; TelephonyManager requires READ_PHONE_STATE permission
+      } else null
+      if (cellGen != null) map.putString("cellularGeneration", cellGen)
+      else map.putNull("cellularGeneration")
+
+      // SSID (requires ACCESS_FINE_LOCATION on Android 10+)
+      map.putNull("ssid")
+
+    } else {
+      @Suppress("DEPRECATION")
+      val info = cm.activeNetworkInfo
+      map.putBoolean("isConnected", info?.isConnected == true)
+      map.putString("type", when (info?.type) {
+        ConnectivityManager.TYPE_WIFI     -> "wifi"
+        ConnectivityManager.TYPE_MOBILE   -> "cellular"
+        ConnectivityManager.TYPE_ETHERNET -> "ethernet"
+        else                              -> if (info?.isConnected == true) "unknown" else "none"
+      })
+      map.putNull("cellularGeneration")
+      map.putNull("ssid")
     }
+
+    // Airplane mode
+    val airplaneMode = Settings.Global.getInt(
+      reactContext.contentResolver, Settings.Global.AIRPLANE_MODE_ON, 0
+    ) != 0
+    map.putBoolean("isAirplaneMode", airplaneMode)
+
+    return map
   }
 
   @ReactMethod
-  fun setNavigationBarBehavior(behavior: String) {
-    val act = activity() ?: return
-    act.runOnUiThread {
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-        val controller = act.window.insetsController ?: return@runOnUiThread
-        // BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE is the only non-deprecated
-        // constant on API 30+. "inset-swipe" and "inset-touch" both map to
-        // the default persistent behavior (bars are always visible after show).
-        controller.systemBarsBehavior = when (behavior) {
-          "overlay-swipe" ->
-            WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
-          else ->
-            // "inset-swipe" / "inset-touch": bars stay visible after swipe
-            @Suppress("DEPRECATION")
-            WindowInsetsController.BEHAVIOR_SHOW_BARS_BY_SWIPE
-        }
+  fun getNetworkInfo(promise: Promise) {
+    try { promise.resolve(buildNetworkMap()) }
+    catch (e: Exception) { promise.reject("NETWORK_ERROR", e.message, e) }
+  }
+
+  @ReactMethod
+  fun startNetworkListener() {
+    if (networkCallback != null) return
+    val cb = object : ConnectivityManager.NetworkCallback() {
+      override fun onAvailable(network: Network)     { emit("SystemBar_NetworkChange", buildNetworkMap()) }
+      override fun onLost(network: Network)          { emit("SystemBar_NetworkChange", buildNetworkMap()) }
+      override fun onCapabilitiesChanged(n: Network, c: NetworkCapabilities) {
+        emit("SystemBar_NetworkChange", buildNetworkMap())
       }
-      // API < 30: behavior is controlled via IMMERSIVE_STICKY flag
+    }
+    networkCallback = cb
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+      connectivityManager().registerDefaultNetworkCallback(cb)
+    } else {
+      connectivityManager().registerNetworkCallback(NetworkRequest.Builder().build(), cb)
     }
   }
 
+  @ReactMethod
+  fun stopNetworkListener() {
+    networkCallback?.let { connectivityManager().unregisterNetworkCallback(it) }
+    networkCallback = null
+  }
+
   // ═══════════════════════════════════════════════
-  //  STATUS BAR
+  //  🆕 BATTERY
   // ═══════════════════════════════════════════════
 
-  @ReactMethod
-  fun setStatusBarColor(color: String) {
-    val act = activity() ?: return
-    act.runOnUiThread {
-      try {
-        act.window.statusBarColor = Color.parseColor(color)
-      } catch (e: Exception) {
-        // ignore invalid color
-      }
+  private var batteryReceiver: BroadcastReceiver? = null
+
+  private fun buildBatteryMap(): WritableMap {
+    val bm    = batteryManager()
+    val map   = Arguments.createMap()
+    val level = bm.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
+    val status = bm.getIntProperty(BatteryManager.BATTERY_PROPERTY_STATUS)
+
+    val state = when (status) {
+      BatteryManager.BATTERY_STATUS_CHARGING    -> "charging"
+      BatteryManager.BATTERY_STATUS_FULL        -> "full"
+      BatteryManager.BATTERY_STATUS_DISCHARGING -> "discharging"
+      BatteryManager.BATTERY_STATUS_NOT_CHARGING -> "discharging"
+      else                                       -> "unknown"
     }
+
+    val isCharging = state == "charging" || state == "full"
+
+    map.putInt("level",       level)
+    map.putString("state",    state)
+    map.putBoolean("isCharging", isCharging)
+    map.putBoolean("isLow",   level <= 20 && !isCharging)
+    return map
   }
 
   @ReactMethod
-  fun setStatusBarStyle(style: String) {
-    val act = activity() ?: return
-    act.runOnUiThread {
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-        val controller = act.window.insetsController ?: return@runOnUiThread
-        controller.setSystemBarsAppearance(
-          if (style == "dark")
-            WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS
-          else 0,
-          WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS
-        )
-      } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-        @Suppress("DEPRECATION")
-        val flags = act.window.decorView.systemUiVisibility
-        act.window.decorView.systemUiVisibility = if (style == "dark") {
-          flags or View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
-        } else {
-          flags and View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR.inv()
-        }
-      }
-    }
+  fun getBatteryInfo(promise: Promise) {
+    try { promise.resolve(buildBatteryMap()) }
+    catch (e: Exception) { promise.reject("BATTERY_ERROR", e.message, e) }
   }
 
   @ReactMethod
-  fun setStatusBarVisibility(visible: Boolean) {
-    val act = activity() ?: return
-    act.runOnUiThread {
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-        val controller = act.window.insetsController ?: return@runOnUiThread
-        if (visible) {
-          controller.show(android.view.WindowInsets.Type.statusBars())
-        } else {
-          controller.hide(android.view.WindowInsets.Type.statusBars())
-        }
-      } else {
-        @Suppress("DEPRECATION")
-        if (visible) {
-          act.window.decorView.systemUiVisibility =
-            act.window.decorView.systemUiVisibility and
-            View.SYSTEM_UI_FLAG_FULLSCREEN.inv()
-        } else {
-          act.window.decorView.systemUiVisibility =
-            act.window.decorView.systemUiVisibility or
-            View.SYSTEM_UI_FLAG_FULLSCREEN
-        }
+  fun startBatteryListener() {
+    if (batteryReceiver != null) return
+    val receiver = object : BroadcastReceiver() {
+      override fun onReceive(ctx: Context?, intent: Intent?) {
+        emit("SystemBar_BatteryChange", buildBatteryMap())
       }
     }
+    batteryReceiver = receiver
+    val filter = IntentFilter().apply {
+      addAction(Intent.ACTION_BATTERY_CHANGED)
+      addAction(Intent.ACTION_BATTERY_LOW)
+      addAction(Intent.ACTION_BATTERY_OKAY)
+      addAction(Intent.ACTION_POWER_CONNECTED)
+      addAction(Intent.ACTION_POWER_DISCONNECTED)
+    }
+    reactContext.registerReceiver(receiver, filter)
+  }
+
+  @ReactMethod
+  fun stopBatteryListener() {
+    batteryReceiver?.let { reactContext.unregisterReceiver(it) }
+    batteryReceiver = null
   }
 
   // ═══════════════════════════════════════════════
-  //  BRIGHTNESS
+  //  🆕 HAPTIC FEEDBACK
   // ═══════════════════════════════════════════════
 
   @ReactMethod
-  fun setBrightness(level: Float) {
-    val act = activity() ?: return
-    act.runOnUiThread {
-      val lp = act.window.attributes
-      lp.screenBrightness = level.coerceIn(0f, 1f)
-      act.window.attributes = lp
-    }
-  }
+  fun haptic(pattern: String) {
+    val vib = vibrator()
+    if (!vib.hasVibrator()) return
 
-  @ReactMethod
-  fun getBrightness(promise: Promise) {
-    try {
-      val act = activity()
-      if (act != null) {
-        val lp = act.window.attributes
-        // screenBrightness == -1 means "use system default"
-        if (lp.screenBrightness >= 0f) {
-          promise.resolve(lp.screenBrightness.toDouble())
-          return
-        }
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      val effect = when (pattern) {
+        "light"     -> VibrationEffect.createOneShot(20,  80)
+        "medium"    -> VibrationEffect.createOneShot(40, 128)
+        "heavy"     -> VibrationEffect.createOneShot(60, 255)
+        "success"   -> VibrationEffect.createWaveform(longArrayOf(0, 30, 60, 30), intArrayOf(0, 180, 0, 255), -1)
+        "warning"   -> VibrationEffect.createWaveform(longArrayOf(0, 50, 80, 50), intArrayOf(0, 200, 0, 200), -1)
+        "error"     -> VibrationEffect.createWaveform(longArrayOf(0, 40, 40, 40, 40, 40), intArrayOf(0, 255, 0, 255, 0, 255), -1)
+        "selection" -> VibrationEffect.createOneShot(10, 60)
+        else        -> VibrationEffect.createOneShot(30, 128)
+      }
+      vib.vibrate(effect)
+    } else {
+      @Suppress("DEPRECATION")
+      when (pattern) {
+        "light"     -> vib.vibrate(20)
+        "medium"    -> vib.vibrate(40)
+        "heavy"     -> vib.vibrate(60)
+        "success"   -> vib.vibrate(longArrayOf(0, 30, 60, 30), -1)
+        "warning"   -> vib.vibrate(longArrayOf(0, 50, 80, 50), -1)
+        "error"     -> vib.vibrate(longArrayOf(0, 40, 40, 40, 40, 40), -1)
+        "selection" -> vib.vibrate(10)
+        else        -> vib.vibrate(30)
       }
-      // Fall back to system brightness setting (0–255 → 0.0–1.0)
-      val sysBrightness = Settings.System.getInt(
-        reactContext.contentResolver,
-        Settings.System.SCREEN_BRIGHTNESS,
-        128
-      )
-      promise.resolve(sysBrightness / 255.0)
-    } catch (e: Exception) {
-      promise.reject("BRIGHTNESS_ERROR", e.message, e)
     }
   }
 
   // ═══════════════════════════════════════════════
-  //  VOLUME
+  //  🆕 SCREENCAST
   // ═══════════════════════════════════════════════
 
-  private var suppressVolumeHUD = false
+  private var displayListener: DisplayManager.DisplayListener? = null
+
+  private fun buildScreencastMap(): WritableMap {
+    val dm = displayManager()
+    val map = Arguments.createMap()
+    val presentations = dm.getDisplays(DisplayManager.DISPLAY_CATEGORY_PRESENTATION)
+    val isCasting = presentations.isNotEmpty()
+    map.putBoolean("isCasting", isCasting)
+    if (isCasting) map.putString("displayName", presentations[0].name)
+    else map.putNull("displayName")
+    return map
+  }
 
   @ReactMethod
-  fun setVolumeHUDVisible(visible: Boolean) {
-    suppressVolumeHUD = !visible
+  fun getScreencastInfo(promise: Promise) {
+    try { promise.resolve(buildScreencastMap()) }
+    catch (e: Exception) { promise.reject("SCREENCAST_ERROR", e.message, e) }
   }
 
   @ReactMethod
-  fun setVolume(level: Float, stream: String) {
-    try {
-      val am = audioManager()
-      val streamType = streamType(stream)
-      val max = am.getStreamMaxVolume(streamType)
-      val vol = (level.coerceIn(0f, 1f) * max).toInt()
-      val flags = if (suppressVolumeHUD) 0 else AudioManager.FLAG_SHOW_UI
-      am.setStreamVolume(streamType, vol, flags)
-    } catch (e: Exception) {
-      // ignore
+  fun startScreencastListener() {
+    if (displayListener != null) return
+    val listener = object : DisplayManager.DisplayListener {
+      override fun onDisplayAdded(id: Int)    { emit("SystemBar_ScreencastChange", buildScreencastMap()) }
+      override fun onDisplayRemoved(id: Int)  { emit("SystemBar_ScreencastChange", buildScreencastMap()) }
+      override fun onDisplayChanged(id: Int)  { emit("SystemBar_ScreencastChange", buildScreencastMap()) }
     }
+    displayListener = listener
+    displayManager().registerDisplayListener(listener, null)
   }
 
   @ReactMethod
-  fun getVolume(stream: String, promise: Promise) {
-    try {
-      val am = audioManager()
-      val streamType = streamType(stream)
-      val current = am.getStreamVolume(streamType)
-      val max = am.getStreamMaxVolume(streamType)
-      promise.resolve(if (max > 0) current.toDouble() / max else 0.0)
-    } catch (e: Exception) {
-      promise.reject("VOLUME_ERROR", e.message, e)
+  fun stopScreencastListener() {
+    displayListener?.let { displayManager().unregisterDisplayListener(it) }
+    displayListener = null
+  }
+
+  @ReactMethod
+  fun setSecureScreen(enable: Boolean) {
+    activity()?.runOnUiThread {
+      if (enable) activity()!!.window.addFlags(WindowManager.LayoutParams.FLAG_SECURE)
+      else        activity()!!.window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE)
     }
   }
 
   // ═══════════════════════════════════════════════
-  //  SCREEN
+  //  🆕 FONT SCALE
   // ═══════════════════════════════════════════════
 
+  private var fontScaleReceiver: BroadcastReceiver? = null
+
+  private fun buildFontScaleMap(): WritableMap {
+    val map  = Arguments.createMap()
+    val cfg  = reactContext.resources.configuration
+    val dm   = reactContext.resources.displayMetrics
+    map.putDouble("fontScale", cfg.fontScale.toDouble())
+    map.putDouble("density",   dm.density.toDouble())
+    return map
+  }
+
   @ReactMethod
-  fun keepScreenOn(enable: Boolean) {
-    val act = activity() ?: return
-    act.runOnUiThread {
-      if (enable) {
-        act.window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-      } else {
-        act.window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-      }
-    }
+  fun getFontScaleInfo(promise: Promise) {
+    try { promise.resolve(buildFontScaleMap()) }
+    catch (e: Exception) { promise.reject("FONT_SCALE_ERROR", e.message, e) }
   }
 
   @ReactMethod
-  fun immersiveMode(enable: Boolean) {
-    val act = activity() ?: return
-    act.runOnUiThread {
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-        val controller = act.window.insetsController ?: return@runOnUiThread
-        if (enable) {
-          controller.hide(
-            android.view.WindowInsets.Type.statusBars() or
-            android.view.WindowInsets.Type.navigationBars()
-          )
-          controller.systemBarsBehavior =
-            WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
-        } else {
-          controller.show(
-            android.view.WindowInsets.Type.statusBars() or
-            android.view.WindowInsets.Type.navigationBars()
-          )
-        }
-      } else {
-        @Suppress("DEPRECATION")
-        if (enable) {
-          act.window.decorView.systemUiVisibility =
-            View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or
-            View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or
-            View.SYSTEM_UI_FLAG_FULLSCREEN or
-            View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or
-            View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
-        } else {
-          act.window.decorView.systemUiVisibility =
-            View.SYSTEM_UI_FLAG_VISIBLE
-        }
+  fun startFontScaleListener() {
+    if (fontScaleReceiver != null) return
+    val receiver = object : BroadcastReceiver() {
+      override fun onReceive(ctx: Context?, intent: Intent?) {
+        emit("SystemBar_FontScaleChange", buildFontScaleMap())
       }
     }
+    fontScaleReceiver = receiver
+    reactContext.registerReceiver(receiver, IntentFilter(Intent.ACTION_CONFIGURATION_CHANGED))
   }
 
-  // ═══════════════════════════════════════════════
-  //  ORIENTATION
-  // ═══════════════════════════════════════════════
-
   @ReactMethod
-  fun setOrientation(mode: String) {
-    val act = activity() ?: return
-    act.requestedOrientation = when (mode) {
-      "portrait"         -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
-      "landscape"        -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
-      "landscape-left"   -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
-      "landscape-right"  -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
-      else               -> ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR  // "auto"
-    }
+  fun stopFontScaleListener() {
+    fontScaleReceiver?.let { reactContext.unregisterReceiver(it) }
+    fontScaleReceiver = null
+  }
+
+  // ── Cleanup on host destroy ──────────────────
+  override fun onCatalystInstanceDestroy() {
+    stopNetworkListener()
+    stopBatteryListener()
+    stopScreencastListener()
+    stopFontScaleListener()
   }
 }