rn-system-bar 3.1.0 → 3.1.3

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,9 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <!-- Required for writing system brightness -->
+    <uses-permission
+        android:name="android.permission.WRITE_SETTINGS"
+        tools:ignore="ProtectedPermissions" />
+
+</manifest>

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

@@ -1,29 +1,18 @@
 // ─────────────────────────────────────────────
-//  rn-system-bar · SystemBarModule.kt  v5
-//  New: Network, Battery, Haptics, Screencast, FontScale
+//  rn-system-bar · SystemBarModule.kt
 // ─────────────────────────────────────────────
 
 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
@@ -32,6 +21,7 @@ import android.view.WindowManager
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
 
+@Suppress("DEPRECATION", "OVERRIDE_DEPRECATION")
 class SystemBarModule(
   private val reactContext: ReactApplicationContext
 ) : ReactContextBaseJavaModule(reactContext) {
@@ -40,23 +30,11 @@ class SystemBarModule(
 
   private fun activity(): Activity? = reactContext.currentActivity
 
-  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 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 displayManager() =
+    reactContext.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
 
   private fun streamType(stream: String): Int = when (stream) {
     "ring"         -> AudioManager.STREAM_RING
@@ -66,29 +44,84 @@ class SystemBarModule(
     else           -> AudioManager.STREAM_MUSIC
   }
 
+  private fun emit(event: String, data: WritableMap) {
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(event, data)
+  }
+
+  // ═══════════════════════════════════════════════
+  //  NAVIGATION BAR COLOR
+  //  WindowInsetsController API 30+, fallback for older.
+  //  navigationBarColor deprecated on API 35+ but still
+  //  works — suppressed at class level.
+  // ═══════════════════════════════════════════════
+
+  @ReactMethod
+  fun setNavigationBarColor(color: String) {
+    activity()?.runOnUiThread {
+      try {
+        val parsed = Color.parseColor(color)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
+          // API 35+ — use WindowInsetsController appearance for tinting
+          val controller = activity()!!.window.insetsController
+          // Nav bar color via window attribute still works as tint on 35+
+          activity()!!.window.navigationBarColor = parsed
+        } else {
+          activity()!!.window.navigationBarColor = parsed
+        }
+      } catch (_: Exception) {}
+    }
+  }
+
   // ═══════════════════════════════════════════════
   //  BRIGHTNESS
   // ═══════════════════════════════════════════════
 
   @ReactMethod
   fun setBrightness(level: Float) {
+    val clamped = level.coerceIn(0.01f, 1f)
+
+    // Window brightness — instant, no permission needed
     activity()?.runOnUiThread {
       val lp = activity()!!.window.attributes
-      lp.screenBrightness = level.coerceIn(0f, 1f)
+      lp.screenBrightness = clamped
       activity()!!.window.attributes = lp
     }
+
+    // System brightness — persisted, needs WRITE_SETTINGS
+    val sysValue = (clamped * 255).toInt().coerceIn(1, 255)
+    if (Settings.System.canWrite(reactContext)) {
+      Settings.System.putInt(
+        reactContext.contentResolver,
+        Settings.System.SCREEN_BRIGHTNESS,
+        sysValue
+      )
+      Settings.System.putInt(
+        reactContext.contentResolver,
+        Settings.System.SCREEN_BRIGHTNESS_MODE,
+        Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL
+      )
+    } else {
+      val intent = Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS).apply {
+        flags = Intent.FLAG_ACTIVITY_NEW_TASK
+      }
+      try { reactContext.startActivity(intent) } catch (_: Exception) {}
+    }
   }
 
   @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)
+      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) }
+    } catch (e: Exception) {
+      promise.reject("BRIGHTNESS_ERROR", e.message, e)
+    }
   }
 
   // ═══════════════════════════════════════════════
@@ -97,13 +130,16 @@ 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 vol = (level.coerceIn(0f, 1f) * am.getStreamMaxVolume(type)).toInt()
+      val am   = audioManager()
+      val type = streamType(stream)
+      val max  = am.getStreamMaxVolume(type)
+      val vol  = (level.coerceIn(0f, 1f) * max).toInt()
       am.setStreamVolume(type, vol, if (suppressVolumeHUD) 0 else AudioManager.FLAG_SHOW_UI)
     } catch (_: Exception) {}
   }
@@ -111,10 +147,13 @@ class SystemBarModule(
   @ReactMethod
   fun getVolume(stream: String, promise: Promise) {
     try {
-      val am = audioManager(); val type = streamType(stream)
-      val max = am.getStreamMaxVolume(type)
+      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) }
+    } catch (e: Exception) {
+      promise.reject("VOLUME_ERROR", e.message, e)
+    }
   }
 
   // ═══════════════════════════════════════════════
@@ -141,18 +180,30 @@ class SystemBarModule(
           c.show(WindowInsets.Type.statusBars() or WindowInsets.Type.navigationBars())
         }
       } else {
-        @Suppress("DEPRECATION")
         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_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
+        }
       }
     }
   }
 
+  @ReactMethod
+  fun setSecureScreen(enable: Boolean) {
+    activity()?.runOnUiThread {
+      if (enable) activity()!!.window.addFlags(WindowManager.LayoutParams.FLAG_SECURE)
+      else        activity()!!.window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE)
+    }
+  }
+
   // ═══════════════════════════════════════════════
   //  ORIENTATION
+  //  "auto" = FULL_SENSOR (follows system auto-rotate)
   // ═══════════════════════════════════════════════
 
   @ReactMethod
@@ -162,216 +213,41 @@ class SystemBarModule(
       "landscape"       -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
       "landscape-left"  -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
       "landscape-right" -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
+      // "auto" = respect system auto-rotate toggle
       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
+  //  SCREENCAST — list all presentation displays
   // ═══════════════════════════════════════════════
 
-  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
-  // ═══════════════════════════════════════════════
+  private var displayListener: DisplayManager.DisplayListener? = null
 
-  @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)
-      }
+  private fun buildDisplayListMap(): WritableMap {
+    val dm      = displayManager()
+    val map     = Arguments.createMap()
+    val displays = dm.getDisplays(DisplayManager.DISPLAY_CATEGORY_PRESENTATION)
+    val arr     = Arguments.createArray()
+
+    for (d in displays) {
+      val item = Arguments.createMap()
+      item.putInt("id", d.displayId)
+      item.putString("name", d.name)
+      item.putBoolean("isValid", d.isValid)
+      arr.pushMap(item)
     }
-  }
-
-  // ═══════════════════════════════════════════════
-  //  🆕 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)
+    map.putBoolean("isCasting", displays.isNotEmpty())
+    map.putArray("displays", arr)
+    if (displays.isNotEmpty()) map.putString("displayName", displays[0].name)
     else map.putNull("displayName")
     return map
   }
 
   @ReactMethod
   fun getScreencastInfo(promise: Promise) {
-    try { promise.resolve(buildScreencastMap()) }
+    try { promise.resolve(buildDisplayListMap()) }
     catch (e: Exception) { promise.reject("SCREENCAST_ERROR", e.message, e) }
   }
 
@@ -379,9 +255,9 @@ class SystemBarModule(
   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()) }
+      override fun onDisplayAdded(id: Int)   { emit("SystemBar_ScreencastChange", buildDisplayListMap()) }
+      override fun onDisplayRemoved(id: Int) { emit("SystemBar_ScreencastChange", buildDisplayListMap()) }
+      override fun onDisplayChanged(id: Int) { emit("SystemBar_ScreencastChange", buildDisplayListMap()) }
     }
     displayListener = listener
     displayManager().registerDisplayListener(listener, null)
@@ -393,58 +269,8 @@ class SystemBarModule(
     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 ──────────────────
+  // ── Cleanup ──────────────────────────────────
   override fun onCatalystInstanceDestroy() {
-    stopNetworkListener()
-    stopBatteryListener()
     stopScreencastListener()
-    stopFontScaleListener()
   }
 }

package/index.ts

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

package/lib/index.d.ts

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

package/lib/index.js

@@ -17,13 +17,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useHaptic = exports.useFontScale = exports.useScreencast = exports.useNetwork = exports.useBattery = exports.useSystemBar = void 0;
+exports.useScreencast = exports.useSystemBar = void 0;
 __exportStar(require("./src/SystemBar"), exports);
 __exportStar(require("./src/types"), exports);
 var useSystemBar_1 = require("./src/useSystemBar");
 Object.defineProperty(exports, "useSystemBar", { enumerable: true, get: function () { return useSystemBar_1.useSystemBar; } });
-Object.defineProperty(exports, "useBattery", { enumerable: true, get: function () { return useSystemBar_1.useBattery; } });
-Object.defineProperty(exports, "useNetwork", { enumerable: true, get: function () { return useSystemBar_1.useNetwork; } });
 Object.defineProperty(exports, "useScreencast", { enumerable: true, get: function () { return useSystemBar_1.useScreencast; } });
-Object.defineProperty(exports, "useFontScale", { enumerable: true, get: function () { return useSystemBar_1.useFontScale; } });
-Object.defineProperty(exports, "useHaptic", { enumerable: true, get: function () { return useSystemBar_1.useHaptic; } });

package/lib/src/SystemBar.d.ts

@@ -1,5 +1,5 @@
-import type { BatteryInfo, FontScaleInfo, HapticPattern, NavigationBarBehavior, NavigationBarButtonStyle, NavigationBarStyle, NavigationBarVisibility, NetworkInfo, Orientation, ScreencastInfo, StatusBarStyle, VolumeStream } from "./types";
-export declare const setNavigationBarColor: (color: string) => Promise<void>;
+import type { NavigationBarBehavior, NavigationBarButtonStyle, NavigationBarStyle, NavigationBarVisibility, Orientation, ScreencastInfo, StatusBarStyle, VolumeStream } from "./types";
+export declare const setNavigationBarColor: (color: string) => void;
 export declare const setNavigationBarVisibility: (mode: NavigationBarVisibility) => Promise<void>;
 export declare const setNavigationBarButtonStyle: (style: NavigationBarButtonStyle) => Promise<void>;
 export declare const setNavigationBarStyle: (style: NavigationBarStyle) => Promise<void>;
@@ -14,60 +14,7 @@ export declare const getVolume: (stream?: VolumeStream) => Promise<number>;
 export declare const setVolumeHUDVisible: (visible: boolean) => void;
 export declare const keepScreenOn: (enable: boolean) => void;
 export declare const immersiveMode: (enable: boolean) => void;
+export declare const setSecureScreen: (enable: boolean) => void;
 export declare const setOrientation: (mode: Orientation) => void;
-/**
- * Get current network connection info.
- * Includes: type, isConnected, isAirplaneMode, ssid, cellularGeneration
- */
-export declare const getNetworkInfo: () => Promise<NetworkInfo>;
-/**
- * Subscribe to network changes.
- * @returns unsubscribe function — call it in useEffect cleanup
- * @example
- * const unsub = onNetworkChange((info) => console.log(info));
- * return () => unsub();
- */
-export declare const onNetworkChange: (callback: (info: NetworkInfo) => void) => (() => void);
-/**
- * Get current battery info: level (0–100), state, isCharging, isLow.
- */
-export declare const getBatteryInfo: () => Promise<BatteryInfo>;
-/**
- * Subscribe to battery level / state changes.
- * @returns unsubscribe function
- */
-export declare const onBatteryChange: (callback: (info: BatteryInfo) => void) => (() => void);
-/**
- * Trigger haptic feedback.
- *
- * iOS: Uses UIImpactFeedbackGenerator / UINotificationFeedbackGenerator.
- * Android: Uses Vibrator / VibrationEffect (API 26+).
- *
- * @param pattern  "light" | "medium" | "heavy" | "success" | "warning" | "error" | "selection"
- */
-export declare const haptic: (pattern: HapticPattern) => void;
-/**
- * Check if screen is currently being cast or mirrored.
- */
 export declare const getScreencastInfo: () => Promise<ScreencastInfo>;
-/**
- * Subscribe to screencast state changes (started / stopped).
- * @returns unsubscribe function
- */
 export declare const onScreencastChange: (callback: (info: ScreencastInfo) => void) => (() => void);
-/**
- * Prevent screen content from appearing in screenshots / recordings.
- * Useful for sensitive screens (payments, passwords).
- * @platform android
- */
-export declare const setSecureScreen: (enable: boolean) => void;
-/**
- * Get current system font scale and display density.
- * Useful for adapting layout to accessibility settings.
- */
-export declare const getFontScaleInfo: () => Promise<FontScaleInfo>;
-/**
- * Subscribe to font scale changes (user changes system text size).
- * @returns unsubscribe function
- */
-export declare const onFontScaleChange: (callback: (info: FontScaleInfo) => void) => (() => void);