rn-system-bar 3.1.7 → 3.2.0

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

@@ -56,11 +56,60 @@ class SystemBarModule(
   //  NAVIGATION BAR — 100% native, no expo dep
   // ═══════════════════════════════════════════════
 
+  // ── Helpers for transparent / translucent bars ──────────────────────────
+
+  private fun applyEdgeToEdgeFlags() {
+    // Required so our colour / transparency actually shows through
+    activity()!!.window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS)
+  }
+
+  private fun setNavBarTransparent() {
+    val win = activity()!!.window
+    applyEdgeToEdgeFlags()
+    win.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION)
+    win.navigationBarColor = Color.TRANSPARENT
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      win.setDecorFitsSystemWindows(false)
+    } else {
+      @Suppress("DEPRECATION")
+      win.decorView.systemUiVisibility =
+        win.decorView.systemUiVisibility or
+        View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or
+        View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+    }
+  }
+
+  private fun setNavBarTranslucent() {
+    val win = activity()!!.window
+    win.addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION)
+    win.clearFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS)
+  }
+
+  private fun setNavBarSolid(color: String) {
+    val win = activity()!!.window
+    applyEdgeToEdgeFlags()
+    win.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      win.setDecorFitsSystemWindows(true)
+    } else {
+      @Suppress("DEPRECATION")
+      win.decorView.systemUiVisibility =
+        win.decorView.systemUiVisibility and
+        View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION.inv() and
+        View.SYSTEM_UI_FLAG_LAYOUT_STABLE.inv()
+    }
+    try { win.navigationBarColor = Color.parseColor(color) }
+    catch (_: Exception) {}
+  }
+
   @ReactMethod
   fun setNavigationBarColor(color: String) {
     activity()?.runOnUiThread {
-      try { activity()!!.window.navigationBarColor = Color.parseColor(color) }
-      catch (_: Exception) {}
+      when (color.trim().lowercase()) {
+        "transparent" -> setNavBarTransparent()
+        "translucent" -> setNavBarTranslucent()
+        else          -> setNavBarSolid(color)
+      }
     }
   }
 
@@ -147,6 +196,47 @@ class SystemBarModule(
     }
   }
 
+  @ReactMethod
+  fun setStatusBarColor(color: String) {
+    activity()?.runOnUiThread {
+      val win = activity()!!.window
+      when (color.trim().lowercase()) {
+        "transparent" -> {
+          applyEdgeToEdgeFlags()
+          win.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS)
+          win.statusBarColor = Color.TRANSPARENT
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            win.setDecorFitsSystemWindows(false)
+          } else {
+            @Suppress("DEPRECATION")
+            win.decorView.systemUiVisibility =
+              win.decorView.systemUiVisibility or
+              View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or
+              View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+          }
+        }
+        "translucent" -> {
+          win.addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS)
+          win.clearFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS)
+        }
+        else -> {
+          applyEdgeToEdgeFlags()
+          win.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS)
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            win.setDecorFitsSystemWindows(true)
+          } else {
+            @Suppress("DEPRECATION")
+            win.decorView.systemUiVisibility =
+              win.decorView.systemUiVisibility and
+              View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN.inv()
+          }
+          try { win.statusBarColor = Color.parseColor(color) }
+          catch (_: Exception) {}
+        }
+      }
+    }
+  }
+
   @ReactMethod
   fun setStatusBarVisibility(visible: Boolean) {
     activity()?.runOnUiThread {
@@ -379,12 +469,13 @@ class SystemBarModule(
   }
 
   // ═══════════════════════════════════════════════
-  //  SCREENCAST
+  //  SYSTEM SCREENCAST  (external display / HDMI / Miracast)
+  //  Detects OS-level external displays via DisplayManager.
   // ═══════════════════════════════════════════════
 
   private var displayListener: DisplayManager.DisplayListener? = null
 
-  private fun buildDisplayListMap(): WritableMap {
+  private fun buildSystemDisplayMap(): WritableMap {
     val dm       = displayManager()
     val map      = Arguments.createMap()
     val displays = dm.getDisplays(DisplayManager.DISPLAY_CATEGORY_PRESENTATION)
@@ -404,33 +495,217 @@ class SystemBarModule(
   }
 
   @ReactMethod
-  fun getScreencastInfo(promise: Promise) {
-    try { promise.resolve(buildDisplayListMap()) }
+  fun getSystemScreencastInfo(promise: Promise) {
+    try { promise.resolve(buildSystemDisplayMap()) }
     catch (e: Exception) { promise.reject("SCREENCAST_ERROR", e.message, e) }
   }
 
   @ReactMethod
-  fun startScreencastListener() {
+  fun startSystemScreencastListener() {
     if (displayListener != null) return
     val listener = object : DisplayManager.DisplayListener {
-      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()) }
+      override fun onDisplayAdded(id: Int)   { emit("SystemBar_SystemScreencastChange", buildSystemDisplayMap()) }
+      override fun onDisplayRemoved(id: Int) { emit("SystemBar_SystemScreencastChange", buildSystemDisplayMap()) }
+      override fun onDisplayChanged(id: Int) { emit("SystemBar_SystemScreencastChange", buildSystemDisplayMap()) }
     }
     displayListener = listener
     displayManager().registerDisplayListener(listener, null)
   }
 
   @ReactMethod
-  fun stopScreencastListener() {
+  fun stopSystemScreencastListener() {
     displayListener?.let { displayManager().unregisterDisplayListener(it) }
     displayListener = null
   }
 
+  // ═══════════════════════════════════════════════
+  //  APP-ONLY CAST  (MediaRouter — Chromecast / TV)
+  //
+  //  Casts ONLY this app's screen — not the whole system.
+  //  Uses android.media.MediaRouter (API 16+, no Play Services required).
+  //
+  //  Flow:
+  //    startAppCastScan()          → devices arrive via SystemBar_AppCastChange
+  //    connectAppCast(deviceId)    → state = "connecting" then "connected"
+  //    disconnectAppCast()         → state = "disconnecting" then "idle"
+  // ═══════════════════════════════════════════════
+
+  private val mediaRouter: android.media.MediaRouter by lazy {
+    reactContext.getSystemService(Context.MEDIA_ROUTER_SERVICE) as android.media.MediaRouter
+  }
+
+  // Current state
+  private var appCastState    = "idle"
+  private var connectedRoute: android.media.MediaRouter.RouteInfo? = null
+  private var appCastCallback: android.media.MediaRouter.Callback? = null
+
+  // All routes discovered during the current scan (id → route)
+  private val discoveredRoutes = mutableMapOf<String, android.media.MediaRouter.RouteInfo>()
+
+  // ── Serialisation helpers ──────────────────
+
+  private fun routeId(r: android.media.MediaRouter.RouteInfo): String =
+    r.name?.toString()?.replace(" ", "_")?.plus("_${r.hashCode()}") ?: r.hashCode().toString()
+
+  private fun routeToMap(r: android.media.MediaRouter.RouteInfo): WritableMap {
+    val m = Arguments.createMap()
+    m.putString("id",   routeId(r))
+    m.putString("name", r.name?.toString() ?: "Unknown")
+    val desc = r.description?.toString()
+    if (desc != null) m.putString("description", desc) else m.putNull("description")
+    // MediaRouter doesn't expose signal strength — set null
+    m.putNull("signalStrength")
+    // Consider a device to require pairing when its status matches "connecting"
+    m.putBoolean("requiresPairing", false)
+    return m
+  }
+
+  private fun buildAppCastMap(): WritableMap {
+    val map = Arguments.createMap()
+    map.putString("state", appCastState)
+    map.putNull("error")
+
+    val devArr = Arguments.createArray()
+    for (r in discoveredRoutes.values) devArr.pushMap(routeToMap(r))
+    map.putArray("devices", devArr)
+
+    val connected = connectedRoute
+    if (connected != null) map.putMap("connectedDevice", routeToMap(connected))
+    else                   map.putNull("connectedDevice")
+
+    return map
+  }
+
+  private fun emitAppCastChange(error: String? = null) {
+    val map = buildAppCastMap()
+    if (error != null) map.putString("error", error)
+    emit("SystemBar_AppCastChange", map)
+  }
+
+  // ── Scan ──────────────────────────────────
+
+  @ReactMethod
+  fun startAppCastScan() {
+    if (appCastCallback != null) return          // already scanning
+    appCastState = "scanning"
+    discoveredRoutes.clear()
+
+    val cb = object : android.media.MediaRouter.Callback() {
+      override fun onRouteAdded(router: android.media.MediaRouter, route: android.media.MediaRouter.RouteInfo) {
+        // Skip the default phone speaker / earpiece
+        if (route.isDefault) return
+        val id = routeId(route)
+        discoveredRoutes[id] = route
+        emitAppCastChange()
+      }
+      override fun onRouteRemoved(router: android.media.MediaRouter, route: android.media.MediaRouter.RouteInfo) {
+        discoveredRoutes.remove(routeId(route))
+        if (connectedRoute?.let { routeId(it) } == routeId(route)) {
+          connectedRoute = null
+          appCastState   = "idle"
+        }
+        emitAppCastChange()
+      }
+      override fun onRouteChanged(router: android.media.MediaRouter, route: android.media.MediaRouter.RouteInfo) {
+        val id = routeId(route)
+        if (!route.isDefault) discoveredRoutes[id] = route
+        emitAppCastChange()
+      }
+      override fun onRouteSelected(router: android.media.MediaRouter, type: Int, route: android.media.MediaRouter.RouteInfo) {
+        if (route.isDefault) return
+        connectedRoute = route
+        appCastState   = "connected"
+        emitAppCastChange()
+      }
+      override fun onRouteUnselected(router: android.media.MediaRouter, type: Int, route: android.media.MediaRouter.RouteInfo) {
+        if (appCastState != "idle") {
+          connectedRoute = null
+          appCastState   = "idle"
+          emitAppCastChange()
+        }
+      }
+    }
+
+    appCastCallback = cb
+    mainHandler.post {
+      mediaRouter.addCallback(
+        android.media.MediaRouter.ROUTE_TYPE_LIVE_VIDEO,
+        cb,
+        android.media.MediaRouter.CALLBACK_FLAG_REQUEST_DISCOVERY or
+        android.media.MediaRouter.CALLBACK_FLAG_PERFORM_ACTIVE_SCAN
+      )
+    }
+    emitAppCastChange()
+  }
+
+  @ReactMethod
+  fun stopAppCastScan() {
+    appCastCallback?.let { mainHandler.post { mediaRouter.removeCallback(it) } }
+    appCastCallback = null
+    if (appCastState == "scanning") {
+      appCastState = "idle"
+      emitAppCastChange()
+    }
+  }
+
+  // ── Connect / Disconnect ──────────────────
+
+  @ReactMethod
+  fun connectAppCast(deviceId: String, pairingPin: String?) {
+    val route = discoveredRoutes[deviceId]
+    if (route == null) {
+      val err = Arguments.createMap()
+      err.putString("state", appCastState)
+      err.putString("error", "Device not found: $deviceId")
+      err.putNull("connectedDevice")
+      err.putArray("devices", Arguments.createArray())
+      emit("SystemBar_AppCastChange", err)
+      return
+    }
+    appCastState = "connecting"
+    emitAppCastChange()
+    mainHandler.post {
+      try {
+        mediaRouter.selectRoute(android.media.MediaRouter.ROUTE_TYPE_LIVE_VIDEO, route)
+        // onRouteSelected callback will set state = "connected" and re-emit
+      } catch (e: Exception) {
+        appCastState = "idle"
+        emitAppCastChange(error = e.message ?: "Connection failed")
+      }
+    }
+  }
+
+  @ReactMethod
+  fun disconnectAppCast() {
+    if (connectedRoute == null) return
+    appCastState = "disconnecting"
+    emitAppCastChange()
+    mainHandler.post {
+      try {
+        // Select the default (phone) route to stop remote casting
+        val defaultRoute = mediaRouter.getDefaultRoute()
+        mediaRouter.selectRoute(android.media.MediaRouter.ROUTE_TYPE_LIVE_VIDEO, defaultRoute)
+        connectedRoute = null
+        appCastState   = "idle"
+        emitAppCastChange()
+      } catch (e: Exception) {
+        appCastState = "idle"
+        emitAppCastChange(error = e.message ?: "Disconnect failed")
+      }
+    }
+  }
+
+  @ReactMethod
+  fun getAppCastInfo(promise: Promise) {
+    try { promise.resolve(buildAppCastMap()) }
+    catch (e: Exception) { promise.reject("APP_CAST_ERROR", e.message, e) }
+  }
+
   // ── Cleanup ──────────────────────────────────
   override fun onCatalystInstanceDestroy() {
     stopBrightnessListener()
     stopVolumeListener()
-    stopScreencastListener()
+    stopSystemScreencastListener()
+    stopAppCastScan()
   }
-}
+}

package/index.ts

@@ -2,7 +2,28 @@
 //  rn-system-bar · index.ts
 // ─────────────────────────────────────────────
 
+// All imperative JS/TS APIs
 export * from "./src/SystemBar";
+
+// All TypeScript types
 export * from "./src/types";
-export { useSystemBar, useScreencast } from "./src/useSystemBar";
-export type { SystemBarConfig } from "./src/useSystemBar";
+
+// Theme hook (standalone access)
+export { setGlobalThemeMode, useTheme } from "./src/useTheme";
+
+// React hooks
+export {
+  useAppCast,
+  useScreencast,
+  useSystemBar,
+  useSystemScreencast,
+  useTheme as useThemeHook,
+  useThemeSystemBar,
+} from "./src/useSystemBar";
+
+// Types from hooks
+export type {
+  SystemBarConfig,
+  ThemedSystemBarConfig,
+  UseAppCastReturn,
+} from "./src/useSystemBar";

package/ios/SystemBarModule.m

@@ -1,5 +1,5 @@
 // ─────────────────────────────────────────────
-//  rn-system-bar · SystemBarModule.m  v5
+//  rn-system-bar · SystemBarModule.m  v6
 //  Objective-C bridge — exposes Swift to React Native
 // ─────────────────────────────────────────────
 
@@ -36,10 +36,17 @@ 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)
+// System Screencast (external display / AirPlay mirror)
+RCT_EXTERN_METHOD(getSystemScreencastInfo:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(startSystemScreencastListener)
+RCT_EXTERN_METHOD(stopSystemScreencastListener)
+
+// App-only Cast (Android MediaRouter — stubs on iOS)
+RCT_EXTERN_METHOD(startAppCastScan)
+RCT_EXTERN_METHOD(stopAppCastScan)
+RCT_EXTERN_METHOD(connectAppCast:(NSString *)deviceId pairingPin:(NSString *)pairingPin)
+RCT_EXTERN_METHOD(disconnectAppCast)
+RCT_EXTERN_METHOD(getAppCastInfo:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 
 // Font Scale
 RCT_EXTERN_METHOD(getFontScaleInfo:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
@@ -58,4 +65,4 @@ RCT_EXTERN_METHOD(setStatusBarVisibility:(BOOL)visible)
 RCT_EXTERN_METHOD(setVolumeHUDVisible:(BOOL)visible)
 RCT_EXTERN_METHOD(immersiveMode:(BOOL)enable)
 
-@end
+@end

package/ios/SystemBarModule.swift

@@ -226,36 +226,70 @@ class SystemBarModule: RCTEventEmitter {
   }
 
   // ═══════════════════════════════════════════════
-  //  🆕 SCREENCAST
+  //  🆕 SYSTEM SCREENCAST  (external display / AirPlay mirror)
+  //  Detects OS-level external screens via UIScreen.
   // ═══════════════════════════════════════════════
 
-  private func currentScreencastMap() -> [String: Any] {
+  private func currentSystemScreencastMap() -> [String: Any] {
     let isCasting = UIScreen.screens.count > 1
     return [
       "isCasting":   isCasting,
       "displayName": isCasting ? "External Display" : NSNull(),
+      "displays":    UIScreen.screens.dropFirst().enumerated().map { idx, _ in
+        ["id": idx + 1, "name": "External Display \(idx + 1)", "isValid": true]
+      },
     ]
   }
 
   @objc
-  func getScreencastInfo(_ resolve: @escaping RCTPromiseResolveBlock,
-                         rejecter reject: RCTPromiseRejectBlock) {
-    resolve(currentScreencastMap())
+  func getSystemScreencastInfo(_ resolve: @escaping RCTPromiseResolveBlock,
+                                rejecter reject: RCTPromiseRejectBlock) {
+    resolve(currentSystemScreencastMap())
   }
 
-  @objc func startScreencastListener() {
+  @objc func startSystemScreencastListener() {
     screencastObserver = NotificationCenter.default.addObserver(
       forName: UIScreen.didConnectNotification, object: nil, queue: .main
     ) { [weak self] _ in
-      self?.emit("SystemBar_ScreencastChange", body: self?.currentScreencastMap() ?? [:])
+      self?.emit("SystemBar_SystemScreencastChange", body: self?.currentSystemScreencastMap() ?? [:])
     }
   }
 
-  @objc func stopScreencastListener() {
+  @objc func stopSystemScreencastListener() {
     if let obs = screencastObserver { NotificationCenter.default.removeObserver(obs) }
     screencastObserver = nil
   }
 
+  // ═══════════════════════════════════════════════
+  //  APP-ONLY CAST  (Android MediaRouter — iOS stubs)
+  //  AirPlay is system-managed on iOS; no public API for app-only casting.
+  // ═══════════════════════════════════════════════
+
+  @objc func startAppCastScan() {
+    // iOS: AirPlay is system-managed — no-op. Emit idle state.
+    emit("SystemBar_AppCastChange", body: [
+      "state": "idle", "devices": [], "connectedDevice": NSNull(), "error": NSNull()
+    ])
+  }
+  @objc func stopAppCastScan() {}
+
+  @objc func connectAppCast(_ deviceId: String, pairingPin: String?) {
+    emit("SystemBar_AppCastChange", body: [
+      "state": "idle", "devices": [], "connectedDevice": NSNull(),
+      "error": "App-only cast not supported on iOS"
+    ])
+  }
+
+  @objc func disconnectAppCast() {}
+
+  @objc
+  func getAppCastInfo(_ resolve: @escaping RCTPromiseResolveBlock,
+                      rejecter reject: RCTPromiseRejectBlock) {
+    resolve([
+      "state": "idle", "devices": [], "connectedDevice": NSNull(), "error": NSNull()
+    ])
+  }
+
   // setSecureScreen — iOS doesn't support this via public API (no-op)
   @objc func setSecureScreen(_ enable: Bool) {}
 
@@ -295,9 +329,10 @@ class SystemBarModule: RCTEventEmitter {
   @objc func setNavigationBarButtonStyle(_ style: String) {}
   @objc func setNavigationBarStyle(_ style: String) {}
   @objc func setNavigationBarBehavior(_ behavior: String) {}
+  // color: hex | "transparent" | "translucent" — Android only
   @objc func setStatusBarColor(_ color: String) {}
   @objc func setVolumeHUDVisible(_ visible: Bool) {}
   @objc func immersiveMode(_ enable: Bool) {}
   @objc func setStatusBarStyle(_ style: String) {}
   @objc func setStatusBarVisibility(_ visible: Bool) {}
-}
+}

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./src/SystemBar";
 export * from "./src/types";
-export { useSystemBar, useScreencast } from "./src/useSystemBar";
-export type { SystemBarConfig } from "./src/useSystemBar";
+export { setGlobalThemeMode, useTheme } from "./src/useTheme";
+export { useAppCast, useScreencast, useSystemBar, useSystemScreencast, useTheme as useThemeHook, useThemeSystemBar, } from "./src/useSystemBar";
+export type { SystemBarConfig, ThemedSystemBarConfig, UseAppCastReturn, } from "./src/useSystemBar";

package/lib/index.js

@@ -17,9 +17,20 @@ 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.useScreencast = exports.useSystemBar = void 0;
+exports.useThemeSystemBar = exports.useThemeHook = exports.useSystemScreencast = exports.useSystemBar = exports.useScreencast = exports.useAppCast = exports.useTheme = exports.setGlobalThemeMode = void 0;
+// All imperative JS/TS APIs
 __exportStar(require("./src/SystemBar"), exports);
+// All TypeScript types
 __exportStar(require("./src/types"), exports);
+// Theme hook (standalone access)
+var useTheme_1 = require("./src/useTheme");
+Object.defineProperty(exports, "setGlobalThemeMode", { enumerable: true, get: function () { return useTheme_1.setGlobalThemeMode; } });
+Object.defineProperty(exports, "useTheme", { enumerable: true, get: function () { return useTheme_1.useTheme; } });
+// React hooks
 var useSystemBar_1 = require("./src/useSystemBar");
-Object.defineProperty(exports, "useSystemBar", { enumerable: true, get: function () { return useSystemBar_1.useSystemBar; } });
+Object.defineProperty(exports, "useAppCast", { enumerable: true, get: function () { return useSystemBar_1.useAppCast; } });
 Object.defineProperty(exports, "useScreencast", { enumerable: true, get: function () { return useSystemBar_1.useScreencast; } });
+Object.defineProperty(exports, "useSystemBar", { enumerable: true, get: function () { return useSystemBar_1.useSystemBar; } });
+Object.defineProperty(exports, "useSystemScreencast", { enumerable: true, get: function () { return useSystemBar_1.useSystemScreencast; } });
+Object.defineProperty(exports, "useThemeHook", { enumerable: true, get: function () { return useSystemBar_1.useTheme; } });
+Object.defineProperty(exports, "useThemeSystemBar", { enumerable: true, get: function () { return useSystemBar_1.useThemeSystemBar; } });

package/lib/specs/NativeSystemBar.d.ts

@@ -15,7 +15,16 @@ export interface Spec extends TurboModule {
     setVolumeHUDVisible(visible: boolean): void;
     keepScreenOn(enable: boolean): void;
     immersiveMode(enable: boolean): void;
+    setSecureScreen(enable: boolean): void;
     setOrientation(mode: string): void;
+    getSystemScreencastInfo(): Promise<Object>;
+    startSystemScreencastListener(): void;
+    stopSystemScreencastListener(): void;
+    startAppCastScan(): void;
+    stopAppCastScan(): void;
+    connectAppCast(deviceId: string, pairingPin: string | null): void;
+    disconnectAppCast(): void;
+    getAppCastInfo(): Promise<Object>;
 }
 declare const _default: Spec;
 export default _default;

package/lib/src/SystemBar.d.ts

@@ -1,15 +1,42 @@
-import type { NavigationBarBehavior, NavigationBarButtonStyle, NavigationBarStyle, NavigationBarVisibility, Orientation, ScreencastInfo, StatusBarStyle, VolumeStream } from "./types";
-export declare const setNavigationBarColor: (color: string) => void;
+import type { AppCastInfo, NavigationBarBehavior, NavigationBarButtonStyle, NavigationBarColorValue, NavigationBarStyle, NavigationBarVisibility, Orientation, StatusBarColorValue, StatusBarStyle, SystemScreencastInfo, VolumeStream } from "./types";
+/**
+ * Set the navigation bar background colour.
+ *
+ * @param color
+ *   - Any hex string   →  solid colour        e.g. `"#1a1a2e"`
+ *   - `"transparent"`  →  fully transparent   (content draws behind bar)
+ *   - `"translucent"`  →  semi-transparent    (system scrim over content)
+ *
+ * @example
+ * setNavigationBarColor("#000000");       // solid black
+ * setNavigationBarColor("transparent");   // glass / edge-to-edge
+ * setNavigationBarColor("translucent");   // frosted glass
+ */
+export declare const setNavigationBarColor: (color: NavigationBarColorValue) => void;
+/**
+ * Hide or show the navigation bar.
+ *
+ * @param mode `"visible"` | `"hidden"`
+ */
 export declare const setNavigationBarVisibility: (mode: NavigationBarVisibility) => void;
 export declare const setNavigationBarButtonStyle: (style: NavigationBarButtonStyle) => void;
 export declare const setNavigationBarStyle: (style: NavigationBarStyle) => void;
 export declare const setNavigationBarBehavior: (behavior: NavigationBarBehavior) => void;
+/**
+ * Set the status bar background colour (Android only).
+ *
+ * @param color
+ *   - Any hex string   →  solid colour
+ *   - `"transparent"`  →  fully transparent
+ *   - `"translucent"`  →  semi-transparent
+ */
+export declare const setStatusBarColor: (color: StatusBarColorValue) => void;
 export declare const setStatusBarStyle: (style: StatusBarStyle) => void;
 export declare const setStatusBarVisibility: (visible: boolean) => void;
 export declare const setBrightness: (level: number) => void;
 export declare const getBrightness: () => Promise<number>;
 /**
- * Subscribe to system brightness changes (polls every 500ms on Android).
+ * Subscribe to system brightness changes (polls every 500 ms on Android).
  * @returns unsubscribe function
  */
 export declare const onBrightnessChange: (callback: (brightness: number) => void) => (() => void);
@@ -25,5 +52,56 @@ 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;
-export declare const getScreencastInfo: () => Promise<ScreencastInfo>;
-export declare const onScreencastChange: (callback: (info: ScreencastInfo) => void) => (() => void);
+/**
+ * One-shot snapshot of system-level external display state.
+ * Works on both Android (DisplayManager) and iOS (UIScreen.screens).
+ */
+export declare const getSystemScreencastInfo: () => Promise<SystemScreencastInfo>;
+/**
+ * Subscribe to system external-display changes.
+ * Fires when an HDMI / Miracast / AirPlay display connects or disconnects.
+ * @returns unsubscribe function
+ */
+export declare const onSystemScreencastChange: (callback: (info: SystemScreencastInfo) => void) => (() => void);
+/** @deprecated Use getSystemScreencastInfo() */
+export declare const getScreencastInfo: () => Promise<SystemScreencastInfo>;
+/** @deprecated Use onSystemScreencastChange() */
+export declare const onScreencastChange: (callback: (info: SystemScreencastInfo) => void) => (() => void);
+/**
+ * Start scanning for nearby castable devices (Chromecast, TV, etc.).
+ * Listen for results via `onAppCastChange`.
+ * Android: uses MediaRouter. iOS: no-op (AirPlay is system-only).
+ */
+export declare const startAppCastScan: () => void;
+/**
+ * Stop the device discovery scan.
+ */
+export declare const stopAppCastScan: () => void;
+/**
+ * Connect to a discovered device and begin casting this app's screen.
+ * @param deviceId  The `id` field from `AppCastDevice` (MediaRouter route ID).
+ * @param pairingPin  Optional PIN string if `requiresPairing` is true.
+ */
+export declare const connectAppCast: (deviceId: string, pairingPin?: string) => void;
+/**
+ * Disconnect the active in-app cast session.
+ */
+export declare const disconnectAppCast: () => void;
+/**
+ * Get the current in-app cast snapshot (state + device list).
+ */
+export declare const getAppCastInfo: () => Promise<AppCastInfo>;
+/**
+ * Subscribe to in-app cast state changes.
+ * Fires on: device discovered/lost, state changes (scanning → connecting → connected),
+ * pairing requests, errors.
+ *
+ * @example
+ * const unsub = onAppCastChange((info) => {
+ *   if (info.state === "connected") console.log("Casting to", info.connectedDevice?.name);
+ *   if (info.error) console.warn("Cast error:", info.error);
+ * });
+ *
+ * @returns unsubscribe function
+ */
+export declare const onAppCastChange: (callback: (info: AppCastInfo) => void) => (() => void);