rn-system-bar 3.0.3 → 3.1.0

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

@@ -1,25 +1,36 @@
 // ─────────────────────────────────────────────
-//  rn-system-bar · SystemBarModule.kt
-//  v4 — Navigation bar removed (handled by expo-navigation-bar).
-//       Status bar removed (handled by RN StatusBar).
-//       Only: Brightness, Volume, Screen flags, Orientation.
-//       Zero deprecated APIs.
+//  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.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
@@ -29,8 +40,23 @@ class SystemBarModule(
 
   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
@@ -46,34 +72,23 @@ class SystemBarModule(
 
   @ReactMethod
   fun setBrightness(level: Float) {
-    val act = activity() ?: return
-    act.runOnUiThread {
-      val lp = act.window.attributes
+    activity()?.runOnUiThread {
+      val lp = activity()!!.window.attributes
       lp.screenBrightness = level.coerceIn(0f, 1f)
-      act.window.attributes = lp
+      activity()!!.window.attributes = lp
     }
   }
 
   @ReactMethod
   fun getBrightness(promise: Promise) {
     try {
-      val act = activity()
-      if (act != null) {
-        val lp = act.window.attributes
-        if (lp.screenBrightness >= 0f) {
-          promise.resolve(lp.screenBrightness.toDouble())
-          return
-        }
+      val lp = activity()?.window?.attributes
+      if (lp != null && lp.screenBrightness >= 0f) {
+        promise.resolve(lp.screenBrightness.toDouble()); return
       }
-      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)
-    }
+      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) }
   }
 
   // ═══════════════════════════════════════════════
@@ -82,34 +97,24 @@ class SystemBarModule(
 
   private var suppressVolumeHUD = false
 
-  @ReactMethod
-  fun setVolumeHUDVisible(visible: Boolean) {
-    suppressVolumeHUD = !visible
-  }
+  @ReactMethod fun setVolumeHUDVisible(visible: Boolean) { suppressVolumeHUD = !visible }
 
   @ReactMethod
   fun setVolume(level: Float, stream: String) {
     try {
-      val am = audioManager()
-      val type = streamType(stream)
-      val max = am.getStreamMaxVolume(type)
-      val vol = (level.coerceIn(0f, 1f) * max).toInt()
-      val flags = if (suppressVolumeHUD) 0 else AudioManager.FLAG_SHOW_UI
-      am.setStreamVolume(type, vol, flags)
+      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 current = am.getStreamVolume(type)
+      val am = audioManager(); val type = streamType(stream)
       val max = am.getStreamMaxVolume(type)
-      promise.resolve(if (max > 0) current.toDouble() / max else 0.0)
-    } catch (e: Exception) {
-      promise.reject("VOLUME_ERROR", e.message, e)
-    }
+      promise.resolve(if (max > 0) am.getStreamVolume(type).toDouble() / max else 0.0)
+    } catch (e: Exception) { promise.reject("VOLUME_ERROR", e.message, e) }
   }
 
   // ═══════════════════════════════════════════════
@@ -118,46 +123,30 @@ class SystemBarModule(
 
   @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)
-      }
+    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 immersiveMode(enable: Boolean) {
-    val act = activity() ?: return
-    act.runOnUiThread {
+    activity()?.runOnUiThread {
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-        // API 30+ — WindowInsetsController (modern, no deprecated flags)
-        val controller = act.window.insetsController ?: return@runOnUiThread
+        val c = activity()!!.window.insetsController ?: return@runOnUiThread
         if (enable) {
-          controller.hide(
-            WindowInsets.Type.statusBars() or WindowInsets.Type.navigationBars()
-          )
-          controller.systemBarsBehavior =
-            WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+          c.hide(WindowInsets.Type.statusBars() or WindowInsets.Type.navigationBars())
+          c.systemBarsBehavior = WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
         } else {
-          controller.show(
-            WindowInsets.Type.statusBars() or WindowInsets.Type.navigationBars()
-          )
+          c.show(WindowInsets.Type.statusBars() or WindowInsets.Type.navigationBars())
         }
       } else {
-        // API 21–29: only path available; suppressed intentionally
         @Suppress("DEPRECATION")
-        act.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
+        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
-        }
+        } else { View.SYSTEM_UI_FLAG_VISIBLE }
       }
     }
   }
@@ -168,8 +157,7 @@ class SystemBarModule(
 
   @ReactMethod
   fun setOrientation(mode: String) {
-    val act = activity() ?: return
-    act.requestedOrientation = when (mode) {
+    activity()?.requestedOrientation = when (mode) {
       "portrait"        -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
       "landscape"       -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
       "landscape-left"  -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
@@ -177,4 +165,286 @@ class SystemBarModule(
       else              -> ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
     }
   }
-}
+
+  // ═══════════════════════════════════════════════
+  //  🆕 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 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())
+      }
+    }
+    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
+  }
+
+  // ═══════════════════════════════════════════════
+  //  🆕 BATTERY
+  // ═══════════════════════════════════════════════
+
+  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 getBatteryInfo(promise: Promise) {
+    try { promise.resolve(buildBatteryMap()) }
+    catch (e: Exception) { promise.reject("BATTERY_ERROR", e.message, e) }
+  }
+
+  @ReactMethod
+  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
+  }
+
+  // ═══════════════════════════════════════════════
+  //  🆕 HAPTIC FEEDBACK
+  // ═══════════════════════════════════════════════
+
+  @ReactMethod
+  fun haptic(pattern: String) {
+    val vib = vibrator()
+    if (!vib.hasVibrator()) 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)
+      }
+    }
+  }
+
+  // ═══════════════════════════════════════════════
+  //  🆕 SCREENCAST
+  // ═══════════════════════════════════════════════
+
+  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 getScreencastInfo(promise: Promise) {
+    try { promise.resolve(buildScreencastMap()) }
+    catch (e: Exception) { promise.reject("SCREENCAST_ERROR", e.message, e) }
+  }
+
+  @ReactMethod
+  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 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)
+    }
+  }
+
+  // ═══════════════════════════════════════════════
+  //  🆕 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 getFontScaleInfo(promise: Promise) {
+    try { promise.resolve(buildFontScaleMap()) }
+    catch (e: Exception) { promise.reject("FONT_SCALE_ERROR", e.message, e) }
+  }
+
+  @ReactMethod
+  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))
+  }
+
+  @ReactMethod
+  fun stopFontScaleListener() {
+    fontScaleReceiver?.let { reactContext.unregisterReceiver(it) }
+    fontScaleReceiver = null
+  }
+
+  // ── Cleanup on host destroy ──────────────────
+  override fun onCatalystInstanceDestroy() {
+    stopNetworkListener()
+    stopBatteryListener()
+    stopScreencastListener()
+    stopFontScaleListener()
+  }
+}

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

@@ -9,13 +9,14 @@ import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
 
+// @Suppress at class level — covers all overrides of deprecated ReactPackage members
+@Suppress("DEPRECATION", "OVERRIDE_DEPRECATION")
 class SystemBarPackage : ReactPackage {
 
   override fun createNativeModules(
     reactContext: ReactApplicationContext
   ): List<NativeModule> = listOf(SystemBarModule(reactContext))
 
-  @Suppress("DEPRECATION")
   override fun createViewManagers(
     reactContext: ReactApplicationContext
   ): List<ViewManager<*, *>> = emptyList()

package/index.ts

@@ -4,3 +4,12 @@
 
 export * from "./src/SystemBar";
 export * from "./src/types";
+export {
+  useSystemBar,
+  useBattery,
+  useNetwork,
+  useScreencast,
+  useFontScale,
+  useHaptic,
+} from "./src/useSystemBar";
+export type { SystemBarConfig } from "./src/useSystemBar";

package/ios/SystemBarModule.m

@@ -1,40 +1,60 @@
 // ─────────────────────────────────────────────
-//  rn-system-bar · SystemBarModule.m
+//  rn-system-bar · SystemBarModule.m  v5
 //  Objective-C bridge — exposes Swift to React Native
 // ─────────────────────────────────────────────
 
 #import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
 
-@interface RCT_EXTERN_MODULE(SystemBar, NSObject)
-
-// Status Bar
-RCT_EXTERN_METHOD(setStatusBarStyle:(NSString *)style)
-RCT_EXTERN_METHOD(setStatusBarVisibility:(BOOL)visible)
+@interface RCT_EXTERN_MODULE(SystemBar, RCTEventEmitter)
 
 // Brightness
 RCT_EXTERN_METHOD(setBrightness:(float)level)
-RCT_EXTERN_METHOD(getBrightness:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getBrightness:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 
 // Volume
 RCT_EXTERN_METHOD(setVolume:(float)level stream:(NSString *)stream)
-RCT_EXTERN_METHOD(getVolume:(NSString *)stream
-                  resolver:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getVolume:(NSString *)stream resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 
 // Screen
 RCT_EXTERN_METHOD(keepScreenOn:(BOOL)enable)
+RCT_EXTERN_METHOD(setSecureScreen:(BOOL)enable)
 
 // Orientation
 RCT_EXTERN_METHOD(setOrientation:(NSString *)mode)
 
-// Android-only stubs (no-ops on iOS)
+// Network
+RCT_EXTERN_METHOD(getNetworkInfo:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(startNetworkListener)
+RCT_EXTERN_METHOD(stopNetworkListener)
+
+// Battery
+RCT_EXTERN_METHOD(getBatteryInfo:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(startBatteryListener)
+RCT_EXTERN_METHOD(stopBatteryListener)
+
+// Haptics
+RCT_EXTERN_METHOD(haptic:(NSString *)pattern)
+
+// Screencast
+RCT_EXTERN_METHOD(getScreencastInfo:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(startScreencastListener)
+RCT_EXTERN_METHOD(stopScreencastListener)
+
+// Font Scale
+RCT_EXTERN_METHOD(getFontScaleInfo:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(startFontScaleListener)
+RCT_EXTERN_METHOD(stopFontScaleListener)
+
+// Android-only stubs
 RCT_EXTERN_METHOD(setNavigationBarColor:(NSString *)color)
 RCT_EXTERN_METHOD(setNavigationBarVisibility:(NSString *)mode)
 RCT_EXTERN_METHOD(setNavigationBarButtonStyle:(NSString *)style)
 RCT_EXTERN_METHOD(setNavigationBarStyle:(NSString *)style)
 RCT_EXTERN_METHOD(setNavigationBarBehavior:(NSString *)behavior)
 RCT_EXTERN_METHOD(setStatusBarColor:(NSString *)color)
+RCT_EXTERN_METHOD(setStatusBarStyle:(NSString *)style)
+RCT_EXTERN_METHOD(setStatusBarVisibility:(BOOL)visible)
 RCT_EXTERN_METHOD(setVolumeHUDVisible:(BOOL)visible)
 RCT_EXTERN_METHOD(immersiveMode:(BOOL)enable)