@cloudflare/realtimekit-react-native 1.2.0-staging.0 → 1.2.0-staging.1

package/android/src/main/AndroidManifest.xml

@@ -16,7 +16,7 @@
   <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
   <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CAMERA" />
   <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
-  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
   <uses-permission android:name="android.permission.CAPTURE_VIDEO_OUTPUT" />
   <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
   <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
@@ -27,5 +27,10 @@
       android:authorities="@string/blob_provider_authority"
       android:exported="false"
     />
+    <service
+      android:name="com.cloudflare.realtimekit.KeepAliveService"
+      android:enabled="true"
+      android:exported="false"
+      android:foregroundServiceType="camera|microphone|mediaPlayback" />
   </application>
 </manifest>

package/android/src/main/java/com/cloudflare/realtimekit/KeepAliveService.java

@@ -0,0 +1,176 @@
+package com.cloudflare.realtimekit;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ServiceInfo;
+import android.graphics.Bitmap;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.os.IBinder;
+import android.util.Log;
+
+import androidx.core.app.NotificationCompat;
+
+/**
+ * Foreground service that keeps the app alive in the background during a
+ * meeting.  Declares foreground service types CAMERA, MICROPHONE, and
+ * MEDIA_PLAYBACK so Android does not kill the process while participants have
+ * camera / microphone active or audio is playing.
+ *
+ * Lifecycle is managed from JS via RTKHelper.startMeetingService() and
+ * RTKHelper.stopMeetingService(), which are called by LocalMediaHandler.
+ */
+public class KeepAliveService extends Service {
+
+    private static final String TAG = "KeepAliveService";
+    private static final int NOTIFICATION_ID = 42002;
+
+    static final String ACTION_START =
+            "com.cloudflare.realtimekit.KEEP_ALIVE_START";
+
+    // Notification config — set by RTKHelperModule.startMeetingService() before launch().
+    static volatile String sTitle       = "In a call";
+    static volatile String sText        = "Tap to return to your meeting";
+    static volatile String sChannelId   = "rtk_meeting";
+    static volatile String sChannelName = "Ongoing Meeting";
+
+    // -----------------------------------------------------------------------
+
+    public static void launch(Context context,
+                              String title,
+                              String text,
+                              String channelId,
+                              String channelName) {
+        sTitle       = title       != null ? title       : "In a call";
+        sText        = text        != null ? text        : "Tap to return to your meeting";
+        sChannelId   = channelId   != null ? channelId   : "rtk_meeting";
+        sChannelName = channelName != null ? channelName : "Ongoing Meeting";
+
+        Intent intent = new Intent(context, KeepAliveService.class);
+        intent.setAction(ACTION_START);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            context.startForegroundService(intent);
+        } else {
+            context.startService(intent);
+        }
+    }
+
+    public static void stop(Context context) {
+        context.stopService(new Intent(context, KeepAliveService.class));
+    }
+
+    // -----------------------------------------------------------------------
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    @Override
+    public void onTaskRemoved(Intent rootIntent) {
+        // Stop when the user swipes the app away from recents.
+        stopSelf();
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        if (intent == null) {
+            return START_NOT_STICKY;
+        }
+
+        String action = intent.getAction();
+
+        if (ACTION_START.equals(action)) {
+            createNotificationChannel();
+            Notification notification = buildNotification();
+            try {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    startForeground(NOTIFICATION_ID, notification,
+                            ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA
+                            | ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE
+                            | ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK);
+                } else {
+                    startForeground(NOTIFICATION_ID, notification);
+                }
+            } catch (RuntimeException e) {
+                Log.e(TAG, "startForeground failed, stopping service: " + e.getMessage());
+                stopSelf();
+            }
+        }
+
+        return START_NOT_STICKY;
+    }
+
+    // -----------------------------------------------------------------------
+
+    private void createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            NotificationChannel channel = new NotificationChannel(
+                    sChannelId, sChannelName, NotificationManager.IMPORTANCE_DEFAULT);
+            channel.enableVibration(false);
+            NotificationManager nm =
+                    (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+            if (nm != null) {
+                nm.createNotificationChannel(channel);
+            }
+        }
+    }
+
+    private Notification buildNotification() {
+        Intent launchIntent = getPackageManager().getLaunchIntentForPackage(getPackageName());
+        if (launchIntent == null) {
+            launchIntent = new Intent();
+        }
+
+        PendingIntent pendingIntent;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            pendingIntent = PendingIntent.getActivity(
+                    this, 0, launchIntent, PendingIntent.FLAG_IMMUTABLE);
+        } else {
+            pendingIntent = PendingIntent.getActivity(
+                    this, 0, launchIntent, PendingIntent.FLAG_UPDATE_CURRENT);
+        }
+
+        int appIconResId = android.R.mipmap.sym_def_app_icon;
+        Bitmap largeIcon = null;
+        try {
+            PackageManager pm = getPackageManager();
+            ApplicationInfo ai = pm.getApplicationInfo(getPackageName(), PackageManager.GET_META_DATA);
+            appIconResId = ai.icon;
+            Drawable drawable = ai.loadIcon(pm);
+            if (drawable instanceof BitmapDrawable) {
+                largeIcon = ((BitmapDrawable) drawable).getBitmap();
+            }
+        } catch (Exception e) {
+            Log.w(TAG, "Failed to load app icon: " + e.getMessage());
+        }
+
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(this, sChannelId)
+                .setCategory(NotificationCompat.CATEGORY_CALL)
+                .setContentTitle(sTitle)
+                .setContentText(sText)
+                .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+                .setContentIntent(pendingIntent)
+                .setOngoing(true)
+                .setAutoCancel(false)
+                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+                .setOnlyAlertOnce(true)
+                .setUsesChronometer(false)
+                .setSmallIcon(appIconResId)
+                .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE);
+
+        if (largeIcon != null) {
+            builder.setLargeIcon(largeIcon);
+        }
+
+        return builder.build();
+    }
+}

package/android/src/main/java/com/cloudflare/realtimekit/RTKHelperModule.java

@@ -1,17 +1,14 @@
 package com.cloudflare.realtimekit;
 
 import android.app.Activity;
-import android.app.ActivityManager;
-import android.content.ComponentName;
-import android.content.Intent;
 import android.content.Context;
 import android.content.pm.ActivityInfo;
 import android.os.Build;
 import android.os.Handler;
 import android.os.PowerManager;
+import android.util.Log;
 import android.view.WindowManager;
 
-import com.cloudflare.realtimekit.ForegroundService;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.Promise;
@@ -35,6 +32,7 @@ import com.cloudflare.realtimekit.RTKHolder;
 @ReactModule(name = "RTKHelper")
 public class RTKHelperModule extends ReactContextBaseJavaModule {
 
+    private static final String TAG = "RTKHelperModule";
     private final ReactApplicationContext reactContext;
     private static final String ERROR_INVALID_ACTIVITY = "E_INVALID_ACTIVITY";
 
@@ -59,9 +57,8 @@ public class RTKHelperModule extends ReactContextBaseJavaModule {
         public void onHostDestroy() {
             if (wakeLock.isHeld())
                 wakeLock.release();
-            Intent intent = new Intent(getReactApplicationContext(), ForegroundService.class);
-            intent.setAction(Constants.ACTION_FOREGROUND_SERVICE_STOP);
-            getReactApplicationContext().stopService(intent);
+            // MediaProjectionService is owned by react-native-webrtc and stops itself
+            // via MediaProjection.Callback.onStop() — no explicit stop needed here.
         }
     };
     // react-native-background-timer end
@@ -90,59 +87,6 @@ public class RTKHelperModule extends ReactContextBaseJavaModule {
         return "RTKHelper";
     }
 
-    @ReactMethod
-    public void createNotificationChannel(Promise promise) {
-        NotificationHelper.getInstance(getReactApplicationContext()).createNotificationChannel(promise);
-    }
-
-    @ReactMethod
-    public void startService(Promise promise) {
-        ComponentName mediaService;
-        RTKHolder.currActivity = this.getCurrentActivity();
-        Intent intent = new Intent(getReactApplicationContext(), ForegroundService.class);
-        intent.setAction(Constants.ACTION_FOREGROUND_SERVICE_START);
-        try{
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                mediaService = getReactApplicationContext().startForegroundService(intent);
-            } else {
-                mediaService = getReactApplicationContext().startService(intent);
-            } 
-        } catch (RuntimeException e) {
-            // Avoid crashing due to ForegroundServiceStartNotAllowedException (API level 31).
-            // See: https://developer.android.com/guide/components/foreground-services#background-start-restrictions
-            RTKLogger.w("RTKHelper", "Media projection service not started: " + e.getMessage());
-            return;
-        }
-        if (mediaService != null) {
-            promise.resolve(null);
-        } else {
-            promise.reject(Constants.ERROR_SERVICE_ERROR, "RTKForegroundService: Foreground service is not started");
-        }
-    }
-
-    @ReactMethod
-    public void stopService(Promise promise) {
-        Intent intent = new Intent(getReactApplicationContext(), ForegroundService.class);
-        intent.setAction(Constants.ACTION_FOREGROUND_SERVICE_STOP);
-        boolean stopped = getReactApplicationContext().stopService(intent);
-        if (stopped) {
-            promise.resolve(null);
-        } else {
-            promise.reject(Constants.ERROR_SERVICE_ERROR, "RTKForegroundService: Foreground service failed to stop");
-        }
-    }
-    @ReactMethod
-    private void isForegroundServiceRunning(Promise promise) {
-        ActivityManager manager = (ActivityManager) this.getCurrentActivity().getSystemService(getReactApplicationContext().ACTIVITY_SERVICE);
-        for (ActivityManager.RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
-            if ((ForegroundService.class).getName().equals(service.service.getClassName())) {
-                promise.resolve(true);
-                return;
-            }
-        }
-        promise.resolve(false);
-    }
-
     @ReactMethod
     public void activateScreenWake() {
         final Activity activity = getCurrentActivity();
@@ -255,6 +199,29 @@ public class RTKHelperModule extends ReactContextBaseJavaModule {
                 .emit(eventName, null);
     }
 
+    @ReactMethod
+    public void startMeetingService(ReadableMap config, Promise promise) {
+        ReactApplicationContext context = getReactApplicationContext();
+        String title       = config.hasKey("title")       ? config.getString("title")       : null;
+        String text        = config.hasKey("text")        ? config.getString("text")        : null;
+        String channelId   = config.hasKey("channelId")   ? config.getString("channelId")   : null;
+        String channelName = config.hasKey("channelName") ? config.getString("channelName") : null;
+        try {
+            KeepAliveService.launch(context, title, text, channelId, channelName);
+            promise.resolve(null);
+        } catch (RuntimeException e) {
+            // ForegroundServiceStartNotAllowedException or similar — not fatal.
+            Log.w(TAG, "startMeetingService failed: " + e.getMessage());
+            promise.resolve(null); // best-effort, never reject
+        }
+    }
+
+    @ReactMethod
+    public void stopMeetingService(Promise promise) {
+        KeepAliveService.stop(getReactApplicationContext());
+        promise.resolve(null);
+    }
+
     @ReactMethod
     public void backgroundTimerSetTimeout(final int id, final double timeout) {
         Handler handler = new Handler();

package/lib/commonjs/LocalMediaHandler.js

@@ -25,6 +25,19 @@ const {
 } = _reactNative.NativeModules;
 const broadcastEmitter = exports.broadcastEmitter = new _reactNative.NativeEventEmitter(BroadcastEventEmitter);
 
+// ---------------------------------------------------------------------------
+// Meeting foreground service config
+// Set by LocalMediaHandler.configure() before the first init() call.
+// ---------------------------------------------------------------------------
+
+let _meetingServiceConfig = {
+  enabled: true,
+  title: 'In a call',
+  text: 'Tap to return to your meeting',
+  channelId: 'rtk_meeting',
+  channelName: 'Ongoing Meeting'
+};
+
 // eslint-disable-next-line no-shadow
 let MediaEvents = exports.MediaEvents = /*#__PURE__*/function (MediaEvents) {
   MediaEvents[MediaEvents["AUDIO_TRACK_CHANGE"] = 0] = "AUDIO_TRACK_CHANGE";
@@ -51,26 +64,6 @@ var _broadcastEmitter = /*#__PURE__*/new WeakMap();
 var _broadcastStartedSubscription = /*#__PURE__*/new WeakMap();
 var _broadcastStoppedSubscription = /*#__PURE__*/new WeakMap();
 class LocalMediaHandler extends _events.EventEmitter {
-  async configureForeground() {
-    if (_reactNative.Platform.OS !== 'android') return;
-    const val = await RTKHelper.isForegroundServiceRunning();
-    if (!val) {
-      if (_reactNative.Platform.Version >= 33) {
-        const res = await _reactNative.PermissionsAndroid.request(_reactNative.PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS);
-        if (res !== _reactNative.PermissionsAndroid.RESULTS.GRANTED) {
-          console.warn('Permission required for screenshare notification');
-        }
-      }
-      if (_reactNative.Platform.Version >= 26) {
-        await RTKHelper.createNotificationChannel();
-      }
-      try {
-        await RTKHelper.startService();
-      } catch (e) {
-        console.warn('Failed to start foreground service', e);
-      }
-    }
-  }
   constructor(localMediaUtils) {
     super();
     _classPrivateFieldInitSpec(this, _localMediaUtils, void 0);
@@ -94,9 +87,15 @@ class LocalMediaHandler extends _events.EventEmitter {
     _classPrivateFieldInitSpec(this, _broadcastStartedSubscription, void 0);
     _classPrivateFieldInitSpec(this, _broadcastStoppedSubscription, void 0);
     _defineProperty(this, "_handleAppStateChange", nextAppState => {
-      if (_classPrivateFieldGet(_appState, this).match(/inactive|background/) && nextAppState === 'active') {
-        _BackgroundHandler.default.clearInterval(_classPrivateFieldGet(_interval, this));
-        _classPrivateFieldSet(_interval, this, null);
+      const prevAppState = _classPrivateFieldGet(_appState, this);
+      _classPrivateFieldSet(_appState, this, nextAppState);
+      if (prevAppState.match(/inactive|background/) && nextAppState === 'active') {
+        // App returned to foreground — stop the background keep-alive timer
+        // and kick the video track to recover the camera feed.
+        if (_classPrivateFieldGet(_interval, this) !== null) {
+          _BackgroundHandler.default.clearInterval(_classPrivateFieldGet(_interval, this));
+          _classPrivateFieldSet(_interval, this, null);
+        }
         if (this.videoTrack) {
           this.videoTrack.enabled = false;
           setTimeout(() => {
@@ -105,16 +104,23 @@ class LocalMediaHandler extends _events.EventEmitter {
             }
           }, 100);
         }
-      } else {
-        if (_classPrivateFieldGet(_interval, this) === null) {
-          if (this.screenShareEnabled || this._pendingScreenShare) {
-            this.configureForeground();
-          }
+      } else if (nextAppState.match(/inactive|background/)) {
+        // App moved to background — start a recurring no-op timer to keep the
+        // JS thread alive so WebRTC/native events continue to be processed.
+        // Clear any existing interval first to avoid accumulation.
+        if (_classPrivateFieldGet(_interval, this) !== null) {
+          _BackgroundHandler.default.clearInterval(_classPrivateFieldGet(_interval, this));
         }
         _classPrivateFieldSet(_interval, this, _BackgroundHandler.default.setInterval(() => {}, 1000));
-        _classPrivateFieldSet(_appState, this, nextAppState);
       }
     });
+    // Arrow function so `this` is stable — the same reference is used in both
+    // addEventListener (setScreenShareTracks) and removeEventListener
+    // (removeScreenShareTracks).  A regular method + .bind(this) creates a new
+    // function object on every call, making removeEventListener a no-op.
+    _defineProperty(this, "onScreenShareEnded", () => {
+      this.emit('SCREENSHARE_ENDED');
+    });
     _classPrivateFieldSet(_localMediaUtils, this, localMediaUtils);
     _classPrivateFieldSet(_broadcastEmitter, this, broadcastEmitter);
     _classPrivateFieldSet(_appState, this, '');
@@ -492,6 +498,11 @@ class LocalMediaHandler extends _events.EventEmitter {
     if (_reactNative.Platform.OS === 'android') {
       _classPrivateFieldSet(_appStateSubscription, this, _reactNative.AppState.addEventListener('change', this._handleAppStateChange));
     }
+
+    // Start the meeting foreground service so Android keeps the app alive
+    // in the background during a call. The app is guaranteed to be in the
+    // foreground at this point (user just tapped join / setup screen).
+    await this.startMeetingService();
   }
   stopScreenShareTracks(tracks = {}) {
     const {
@@ -499,20 +510,22 @@ class LocalMediaHandler extends _events.EventEmitter {
       video = true
     } = tracks;
     if (audio) {
-      var _this$screenShareTrac;
+      var _this$screenShareTrac, _this$screenShareTrac2;
       (_this$screenShareTrac = this.screenShareTracks) === null || _this$screenShareTrac === void 0 || (_this$screenShareTrac = _this$screenShareTrac.audio) === null || _this$screenShareTrac === void 0 || _this$screenShareTrac.stop();
+      (_this$screenShareTrac2 = this.screenShareTracks) === null || _this$screenShareTrac2 === void 0 || (_this$screenShareTrac2 = _this$screenShareTrac2.audio) === null || _this$screenShareTrac2 === void 0 || _this$screenShareTrac2.release();
     }
     if (video) {
-      var _this$screenShareTrac2;
-      (_this$screenShareTrac2 = this.screenShareTracks) === null || _this$screenShareTrac2 === void 0 || (_this$screenShareTrac2 = _this$screenShareTrac2.video) === null || _this$screenShareTrac2 === void 0 || _this$screenShareTrac2.stop();
+      var _this$screenShareTrac3, _this$screenShareTrac4;
+      (_this$screenShareTrac3 = this.screenShareTracks) === null || _this$screenShareTrac3 === void 0 || (_this$screenShareTrac3 = _this$screenShareTrac3.video) === null || _this$screenShareTrac3 === void 0 || _this$screenShareTrac3.stop();
+      (_this$screenShareTrac4 = this.screenShareTracks) === null || _this$screenShareTrac4 === void 0 || (_this$screenShareTrac4 = _this$screenShareTrac4.video) === null || _this$screenShareTrac4 === void 0 || _this$screenShareTrac4.release();
     }
     if (audio && video) {
       this.screenShareEnabled = false;
     }
   }
   removeScreenShareTracks(tracks) {
-    var _this$screenShareTrac3;
-    (_this$screenShareTrac3 = this.screenShareTracks.video) === null || _this$screenShareTrac3 === void 0 || _this$screenShareTrac3.removeEventListener('ended', this.onScreenShareEnded);
+    var _this$screenShareTrac5;
+    (_this$screenShareTrac5 = this.screenShareTracks.video) === null || _this$screenShareTrac5 === void 0 || _this$screenShareTrac5.removeEventListener('ended', this.onScreenShareEnded);
     this.stopScreenShareTracks(tracks);
     this.screenShareTracks = {
       audio: undefined,
@@ -544,7 +557,7 @@ class LocalMediaHandler extends _events.EventEmitter {
     this.videoTrack = videoTrack;
   }
   setScreenShareTracks(tracks) {
-    var _this$screenShareTrac4;
+    var _this$screenShareTrac6;
     const {
       audio,
       video
@@ -556,10 +569,7 @@ class LocalMediaHandler extends _events.EventEmitter {
       });
     }
     this.screenShareTracks = tracks;
-    (_this$screenShareTrac4 = this.screenShareTracks.video) === null || _this$screenShareTrac4 === void 0 || _this$screenShareTrac4.addEventListener('ended', this.onScreenShareEnded.bind(this));
-  }
-  onScreenShareEnded() {
-    this.emit('SCREENSHARE_ENDED');
+    (_this$screenShareTrac6 = this.screenShareTracks.video) === null || _this$screenShareTrac6 === void 0 || _this$screenShareTrac6.addEventListener('ended', this.onScreenShareEnded);
   }
   async disableAudio() {
     await this.toggleAudio();
@@ -685,53 +695,19 @@ class LocalMediaHandler extends _events.EventEmitter {
       return;
     }
   }
-  async toggleScreenShare() {
-    if (this.screenShareEnabled && _reactNative.Platform.OS !== 'ios') {
-      this.removeScreenShareTracks();
-      try {
-        const val = await RTKHelper.isForegroundServiceRunning();
-        if (val) {
-          await RTKHelper.stopService();
-        }
-      } catch (e) {
-        console.warn('Failed to stop foreground service', e);
-      }
-      return;
-    }
-    if (_reactNative.Platform.OS === 'ios' && this.screenShareEnabled) {
-      _reactNative.NativeModules.RTKScreensharePickerView.showScreenSharePickerView();
-      _classPrivateFieldSet(_screenShareState, this, 'PENDING');
-      await new Promise((resolve, reject) => {
-        let timeoutId;
-        let time = 0;
-        timeoutId = setInterval(() => {
-          if (_classPrivateFieldGet(_screenShareState, this) === 'STOPPED') {
-            clearInterval(timeoutId);
-            resolve();
-          }
-          time = time + 100;
-          if (time > 20000) {
-            clearInterval(timeoutId);
-            reject('Timeout exceeded for disableScreenShare()');
-          }
-        }, 100);
-      });
-      return;
-    }
+  async enableScreenShare() {
+    // Guard: do nothing if already sharing or a consent dialog is in flight.
+    if (this.screenShareEnabled || this._pendingScreenShare) return;
     if (_reactNative.Platform.OS === 'android') {
       this._pendingScreenShare = true;
-      await this.configureForeground();
       try {
+        // getScreenShareTracks() manages the full flow:
+        // consent dialog → start MediaProjectionService → create MediaStream
         this.setScreenShareTracks(await _LocalMediaUtils.default.getScreenShareTracks());
         this.screenShareEnabled = true;
       } catch (e) {
         console.warn('Failed to start screenshare', e);
         this.screenShareEnabled = false;
-        const val = await RTKHelper.isForegroundServiceRunning();
-        if (val) {
-          await RTKHelper.stopService();
-        }
-        this._pendingScreenShare = false;
       } finally {
         this._pendingScreenShare = false;
       }
@@ -756,11 +732,32 @@ class LocalMediaHandler extends _events.EventEmitter {
       });
     }
   }
-  async enableScreenShare() {
-    await this.toggleScreenShare();
-  }
   async disableScreenShare() {
-    await this.toggleScreenShare();
+    // Guard: nothing to stop if not sharing and no consent dialog is pending.
+    if (!this.screenShareEnabled && !this._pendingScreenShare) return;
+    if (_reactNative.Platform.OS !== 'ios') {
+      this.removeScreenShareTracks();
+      return;
+    }
+
+    // iOS: trigger the broadcast picker to stop the extension.
+    _reactNative.NativeModules.RTKScreensharePickerView.showScreenSharePickerView();
+    _classPrivateFieldSet(_screenShareState, this, 'PENDING');
+    await new Promise((resolve, reject) => {
+      let timeoutId;
+      let time = 0;
+      timeoutId = setInterval(() => {
+        if (_classPrivateFieldGet(_screenShareState, this) === 'STOPPED') {
+          clearInterval(timeoutId);
+          resolve();
+        }
+        time = time + 100;
+        if (time > 20000) {
+          clearInterval(timeoutId);
+          reject('Timeout exceeded for disableScreenShare()');
+        }
+      }, 100);
+    });
   }
   getAllDevices() {
     return _classPrivateFieldGet(_localMediaUtils, this).availableDevices;
@@ -887,10 +884,45 @@ class LocalMediaHandler extends _events.EventEmitter {
       this.emit('DEVICE_LIST_UPDATED', changedDevices);
     }
   }
+
+  /**
+   * Override the meeting foreground service config before the first meeting
+   * session.  Called by useRealtimeKitClient when keepAliveService is set.
+   */
+  static configure(config) {
+    _meetingServiceConfig = {
+      ..._meetingServiceConfig,
+      ...config
+    };
+  }
   static async init(_) {
     const localMediaUtils = await _LocalMediaUtils.default.init();
     return new LocalMediaHandler(localMediaUtils);
   }
+  async startMeetingService() {
+    if (_reactNative.Platform.OS !== 'android') return;
+    if (!_meetingServiceConfig.enabled) return;
+
+    // Android 13+ (API 33): request POST_NOTIFICATIONS so the foreground-service
+    // notification appears in the shade.
+    if (Number(_reactNative.Platform.Version) >= 33) {
+      try {
+        await _reactNative.PermissionsAndroid.request(_reactNative.PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS);
+      } catch (e) {
+        console.warn('Failed to request POST_NOTIFICATIONS permission', e);
+      }
+    }
+    try {
+      await RTKHelper.startMeetingService({
+        title: _meetingServiceConfig.title,
+        text: _meetingServiceConfig.text,
+        channelId: _meetingServiceConfig.channelId,
+        channelName: _meetingServiceConfig.channelName
+      });
+    } catch (e) {
+      console.warn('Failed to start KeepAliveService', e);
+    }
+  }
   emit(event, ...args) {
     return super.emit(event, ...args);
   }