rn-system-bar 3.2.4 → 3.2.5

package/android/src/main/AndroidManifest.xml

@@ -6,4 +6,12 @@
         android:name="android.permission.WRITE_SETTINGS"
         tools:ignore="ProtectedPermissions" />
 
-</manifest>
+    <!-- Required for network state / listener -->
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
+
+    <!-- Required for haptic feedback / vibration -->
+    <uses-permission android:name="android.permission.VIBRATE" />
+
+</manifest>

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

@@ -10,13 +10,22 @@ import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
 import android.content.pm.ActivityInfo
+import android.content.res.Configuration
 import android.graphics.Color
 import android.hardware.display.DisplayManager
 import android.media.AudioManager
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import android.os.BatteryManager
 import android.os.Build
 import android.os.Handler
 import android.os.Looper
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.os.VibratorManager
 import android.provider.Settings
+import android.util.DisplayMetrics
 import android.view.View
 import android.view.WindowInsets
 import android.view.WindowInsetsController
@@ -503,10 +512,224 @@ class SystemBarModule(
     displayListener = null
   }
 
+
+  // ═══════════════════════════════════════════════
+  //  NETWORK
+  // ═══════════════════════════════════════════════
+
+  private fun connectivityManager() =
+    reactContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+
+  private fun buildNetworkMap(): WritableMap {
+    val cm  = connectivityManager()
+    val map = Arguments.createMap()
+
+    val net  = cm.activeNetwork
+    val caps = if (net != null) cm.getNetworkCapabilities(net) else null
+
+    val isConnected = caps != null &&
+      (caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) ||
+       caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED))
+
+    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)
+    map.putBoolean("isConnected", isConnected)
+    val airplaneMode = Settings.Global.getInt(
+      reactContext.contentResolver, Settings.Global.AIRPLANE_MODE_ON, 0) == 1
+    map.putBoolean("isAirplaneMode", airplaneMode)
+    map.putNull("ssid")
+    map.putNull("cellularGeneration")
+    return map
+  }
+
+  @ReactMethod
+  fun getNetworkInfo(promise: Promise) {
+    try { promise.resolve(buildNetworkMap()) }
+    catch (e: Exception) { promise.reject("NETWORK_ERROR", e.message, e) }
+  }
+
+  private var networkCallback: ConnectivityManager.NetworkCallback? = null
+
+  @ReactMethod
+  fun startNetworkListener() {
+    if (networkCallback != null) return
+    val cb = object : ConnectivityManager.NetworkCallback() {
+      override fun onAvailable(network: android.net.Network)    { emit("SystemBar_NetworkChange", buildNetworkMap()) }
+      override fun onLost(network: android.net.Network)         { emit("SystemBar_NetworkChange", buildNetworkMap()) }
+      override fun onCapabilitiesChanged(
+        network: android.net.Network,
+        caps: NetworkCapabilities
+      ) { emit("SystemBar_NetworkChange", buildNetworkMap()) }
+    }
+    networkCallback = cb
+    val request = NetworkRequest.Builder().build()
+    connectivityManager().registerNetworkCallback(request, cb)
+  }
+
+  @ReactMethod
+  fun stopNetworkListener() {
+    networkCallback?.let {
+      try { connectivityManager().unregisterNetworkCallback(it) } catch (_: Exception) {}
+    }
+    networkCallback = null
+  }
+
+  // ═══════════════════════════════════════════════
+  //  BATTERY
+  // ═══════════════════════════════════════════════
+
+  private fun buildBatteryMap(): WritableMap {
+    val map    = Arguments.createMap()
+    val intent = reactContext.registerReceiver(null, IntentFilter(Intent.ACTION_BATTERY_CHANGED))
+
+    val level  = intent?.getIntExtra(BatteryManager.EXTRA_LEVEL,  -1) ?: -1
+    val scale  = intent?.getIntExtra(BatteryManager.EXTRA_SCALE, 100) ?: 100
+    val pct    = if (scale > 0) (level * 100 / scale) else -1
+
+    val status = intent?.getIntExtra(BatteryManager.EXTRA_STATUS, BatteryManager.BATTERY_STATUS_UNKNOWN)
+    val state  = when (status) {
+      BatteryManager.BATTERY_STATUS_CHARGING                    -> "charging"
+      BatteryManager.BATTERY_STATUS_FULL                        -> "full"
+      BatteryManager.BATTERY_STATUS_DISCHARGING,
+      BatteryManager.BATTERY_STATUS_NOT_CHARGING                -> "discharging"
+      else                                                      -> "unknown"
+    }
+    val isCharging = state == "charging" || state == "full"
+
+    map.putInt("level",          pct)
+    map.putString("state",       state)
+    map.putBoolean("isCharging", isCharging)
+    map.putBoolean("isLow",      pct in 0..20 && !isCharging)
+    return map
+  }
+
+  @ReactMethod
+  fun getBatteryInfo(promise: Promise) {
+    try { promise.resolve(buildBatteryMap()) }
+    catch (e: Exception) { promise.reject("BATTERY_ERROR", e.message, e) }
+  }
+
+  private var batteryReceiver: BroadcastReceiver? = null
+
+  @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 { try { reactContext.unregisterReceiver(it) } catch (_: Exception) {} }
+    batteryReceiver = null
+  }
+
+  // ═══════════════════════════════════════════════
+  //  HAPTICS
+  // ═══════════════════════════════════════════════
+
+  private fun vibrator(): Vibrator =
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      (reactContext.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager)
+        .defaultVibrator
+    } else {
+      @Suppress("DEPRECATION")
+      reactContext.getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
+    }
+
+  @ReactMethod
+  fun haptic(pattern: String) {
+    try {
+      val vib = vibrator()
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        val effect = when (pattern) {
+          "light"     -> VibrationEffect.createOneShot(30,  80)
+          "medium"    -> VibrationEffect.createOneShot(50,  150)
+          "heavy"     -> VibrationEffect.createOneShot(80,  255)
+          "success"   -> VibrationEffect.createWaveform(longArrayOf(0, 40, 60, 40),         intArrayOf(0, 180, 0, 255),          -1)
+          "warning"   -> VibrationEffect.createWaveform(longArrayOf(0, 60, 40, 60),         intArrayOf(0, 200, 0, 200),          -1)
+          "error"     -> VibrationEffect.createWaveform(longArrayOf(0, 80, 40, 80, 40, 80), intArrayOf(0, 255, 0, 255, 0, 255),  -1)
+          "selection" -> VibrationEffect.createOneShot(20,  60)
+          else        -> VibrationEffect.createOneShot(50,  150)
+        }
+        vib.vibrate(effect)
+      } else {
+        @Suppress("DEPRECATION")
+        vib.vibrate(when (pattern) {
+          "light"     -> 30L
+          "heavy"     -> 80L
+          "selection" -> 20L
+          else        -> 50L
+        })
+      }
+    } catch (_: Exception) {}
+  }
+
+  // ═══════════════════════════════════════════════
+  //  FONT SCALE
+  // ═══════════════════════════════════════════════
+
+  private fun buildFontScaleMap(): WritableMap {
+    val map     = Arguments.createMap()
+    val config  = reactContext.resources.configuration
+    val metrics = reactContext.resources.displayMetrics
+    map.putDouble("fontScale", config.fontScale.toDouble())
+    map.putDouble("density",   metrics.density.toDouble())
+    return map
+  }
+
+  @ReactMethod
+  fun getFontScaleInfo(promise: Promise) {
+    try { promise.resolve(buildFontScaleMap()) }
+    catch (e: Exception) { promise.reject("FONTSCALE_ERROR", e.message, e) }
+  }
+
+  private var fontScaleReceiver: BroadcastReceiver? = null
+
+  @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 { try { reactContext.unregisterReceiver(it) } catch (_: Exception) {} }
+    fontScaleReceiver = null
+  }
+
   // ── Cleanup ───────────────────────────────────
   override fun onCatalystInstanceDestroy() {
     stopBrightnessListener()
     stopVolumeListener()
     stopSystemScreencastListener()
+    stopNetworkListener()
+    stopBatteryListener()
+    stopFontScaleListener()
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rn-system-bar",
-  "version": "3.2.4",
+  "version": "3.2.5",
   "description": "Control Android & iOS system bars, brightness, volume, orientation and screen flags from React Native.",
   "main": "lib/index.js",
   "react-native": "lib/index.js",