@stream-io/video-react-native-sdk 1.28.2 → 1.29.0-beta.0

package/android/src/main/AndroidManifest.xml

@@ -2,6 +2,13 @@
         package="com.streamvideo.reactnative">
 
     <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.DEVICE_POWER" />
     <uses-permission android:name="android.permission.WAKE_LOCK" />
+
+    <application>
+        <service
+            android:name="com.streamvideo.reactnative.keepalive.StreamCallKeepAliveHeadlessService"
+            android:exported="false"
+            android:stopWithTask="true"
+            android:foregroundServiceType="mediaPlayback|camera|microphone" />
+    </application>
 </manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -1,2 +1,13 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+
+    <application>
+        <service
+            android:name="com.streamvideo.reactnative.keepalive.StreamCallKeepAliveHeadlessService"
+            android:exported="false"
+            android:stopWithTask="true"
+            android:foregroundServiceType="mediaPlayback|camera|microphone" />
+    </application>
 </manifest>

package/android/src/main/java/com/streamvideo/reactnative/StreamVideoReactNativeModule.kt

@@ -15,6 +15,7 @@ import android.os.Build
 import android.os.PowerManager
 import android.util.Base64
 import android.util.Log
+import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
@@ -23,8 +24,8 @@ import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
 import com.oney.WebRTCModule.WebRTCModule
+import com.streamvideo.reactnative.keepalive.StreamCallKeepAliveHeadlessService
 import com.streamvideo.reactnative.util.CallAlivePermissionsHelper
-import com.streamvideo.reactnative.util.CallAliveServiceChecker
 import com.streamvideo.reactnative.util.PiPHelper
 import com.streamvideo.reactnative.util.RingtoneUtil
 import com.streamvideo.reactnative.util.YuvFrame
@@ -115,11 +116,47 @@ class StreamVideoReactNativeModule(reactContext: ReactApplicationContext) :
             promise.resolve(false)
             return
         }
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            val isForegroundServiceDeclared = CallAliveServiceChecker.isForegroundServiceDeclared(reactApplicationContext)
-            promise.resolve(isForegroundServiceDeclared)
-        } else {
+        // Service is declared in the SDK's own AndroidManifest and merged by default.
+        // Permissions are expected to be provided by the app (or via Expo config plugin).
+        promise.resolve(true)
+    }
+
+
+    @ReactMethod
+    fun startKeepCallAliveService(
+        callCid: String,
+        channelId: String,
+        channelName: String,
+        title: String,
+        body: String,
+        smallIconName: String?,
+        promise: Promise
+    ) {
+        try {
+            val intent = StreamCallKeepAliveHeadlessService.buildStartIntent(
+                reactApplicationContext,
+                callCid,
+                channelId,
+                channelName,
+                title,
+                body,
+                smallIconName
+            )
+            ContextCompat.startForegroundService(reactApplicationContext, intent)
             promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject(NAME, "Failed to start keep call alive foreground service", e)
+        }
+    }
+
+    @ReactMethod
+    fun stopKeepCallAliveService(promise: Promise) {
+        try {
+            val intent = StreamCallKeepAliveHeadlessService.buildStopIntent(reactApplicationContext)
+            val stopped = reactApplicationContext.stopService(intent)
+            promise.resolve(stopped)
+        } catch (e: Exception) {
+            promise.reject(NAME, "Failed to stop keep call alive foreground service", e)
         }
     }
 

package/android/src/main/java/com/streamvideo/reactnative/keepalive/KeepAliveNotification.kt

@@ -0,0 +1,83 @@
+package com.streamvideo.reactnative.keepalive
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.app.NotificationCompat
+
+internal object KeepAliveNotification {
+    private const val DEFAULT_CHANNEL_DESCRIPTION = "Stream call keep-alive"
+
+    fun ensureChannel(
+        context: Context,
+        channelId: String,
+        channelName: String
+    ) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        val existing = manager.getNotificationChannel(channelId)
+        if (existing != null) return
+
+        val channel = NotificationChannel(
+            channelId,
+            channelName,
+            NotificationManager.IMPORTANCE_LOW
+        ).apply {
+            description = DEFAULT_CHANNEL_DESCRIPTION
+            setShowBadge(false)
+        }
+        manager.createNotificationChannel(channel)
+    }
+
+    fun buildOngoingNotification(
+        context: Context,
+        channelId: String,
+        title: String,
+        body: String,
+        smallIconName: String?
+    ): Notification {
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+        val pendingIntentFlags =
+            PendingIntent.FLAG_UPDATE_CURRENT or
+               PendingIntent.FLAG_IMMUTABLE
+        val contentIntent = if (launchIntent != null) {
+            PendingIntent.getActivity(context, 0, launchIntent, pendingIntentFlags)
+        } else {
+            // Fallback: empty intent to avoid crash if launch activity is missing for some reason
+            PendingIntent.getActivity(context, 0, Intent(), pendingIntentFlags)
+        }
+
+        val iconResId = resolveSmallIconResId(context, smallIconName)
+        return NotificationCompat.Builder(context, channelId)
+            .setContentTitle(title)
+            .setContentText(body)
+            .setOngoing(true)
+            .setOnlyAlertOnce(true)
+            .setCategory(NotificationCompat.CATEGORY_CALL)
+            .setContentIntent(contentIntent)
+            .setSmallIcon(iconResId)
+            .build()
+    }
+
+    private fun resolveSmallIconResId(context: Context, smallIconName: String?): Int {
+        val resources = context.resources
+        val packageName = context.packageName
+        if (!smallIconName.isNullOrBlank()) {
+            val id = resources.getIdentifier(smallIconName, "drawable", packageName)
+            if (id != 0) return id
+        }
+        // Default to the app icon
+        return try {
+            val appInfo = context.packageManager.getApplicationInfo(packageName, 0)
+            appInfo.icon
+        } catch (_: PackageManager.NameNotFoundException) {
+            android.R.drawable.ic_dialog_info
+        }
+    }
+}
+

package/android/src/main/java/com/streamvideo/reactnative/keepalive/StreamCallKeepAliveHeadlessService.kt

@@ -0,0 +1,134 @@
+package com.streamvideo.reactnative.keepalive
+
+import android.Manifest
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.content.pm.ServiceInfo
+import android.os.Build
+import androidx.annotation.RequiresApi
+import androidx.core.app.ServiceCompat
+import androidx.core.content.ContextCompat
+import com.facebook.react.HeadlessJsTaskService
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.jstasks.HeadlessJsTaskConfig
+
+/**
+ * Foreground service that runs a React Native HeadlessJS task to keep a call alive.
+ *
+ */
+class StreamCallKeepAliveHeadlessService : HeadlessJsTaskService() {
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        val safeIntent = intent ?: Intent()
+        val channelId = safeIntent.getStringExtra(EXTRA_CHANNEL_ID) ?: DEFAULT_CHANNEL_ID
+        val channelName = safeIntent.getStringExtra(EXTRA_CHANNEL_NAME) ?: DEFAULT_CHANNEL_NAME
+        val title = safeIntent.getStringExtra(EXTRA_TITLE) ?: DEFAULT_TITLE
+        val body = safeIntent.getStringExtra(EXTRA_BODY) ?: DEFAULT_BODY
+        val smallIconName = safeIntent.getStringExtra(EXTRA_SMALL_ICON_NAME)
+
+        KeepAliveNotification.ensureChannel(this, channelId, channelName)
+        val notification = KeepAliveNotification.buildOngoingNotification(
+            context = this,
+            channelId = channelId,
+            title = title,
+            body = body,
+            smallIconName = smallIconName
+        )
+
+        startForegroundCompat(notification)
+
+        // Ensure HeadlessJS task is started
+        return super.onStartCommand(safeIntent, flags, startId)
+    }
+
+    override fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig? {
+        val callCid = intent?.getStringExtra(EXTRA_CALL_CID) ?: return null
+        val data = Arguments.createMap().apply {
+            putString("callCid", callCid)
+        }
+        // We intentionally allow long-running work (the JS task can return a never-resolving Promise).
+        return HeadlessJsTaskConfig(
+            TASK_NAME,
+            data,
+            0, // timeout (0 = no timeout)
+            true // allowedInForeground
+        )
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        stopForeground(STOP_FOREGROUND_REMOVE)
+    }
+
+    @RequiresApi(Build.VERSION_CODES.R)
+    private fun computeForegroundServiceTypes(): Int {
+        var types = ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
+
+        val hasCameraPermission =
+            ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED
+        if (hasCameraPermission) {
+            types = types or ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA
+        }
+
+        val hasMicrophonePermission =
+            ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
+        if (hasMicrophonePermission) {
+            types = types or ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE
+        }
+
+        return types
+    }
+
+    private fun startForegroundCompat(notification: android.app.Notification) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            val types = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) computeForegroundServiceTypes() else ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
+            startForeground(NOTIFICATION_ID, notification, types)
+        } else {
+            startForeground(NOTIFICATION_ID, notification)
+        }
+    }
+
+    companion object {
+        const val TASK_NAME = "StreamVideoKeepCallAlive"
+
+        const val EXTRA_CALL_CID = "callCid"
+        const val EXTRA_CHANNEL_ID = "channelId"
+        const val EXTRA_CHANNEL_NAME = "channelName"
+        const val EXTRA_TITLE = "title"
+        const val EXTRA_BODY = "body"
+        const val EXTRA_SMALL_ICON_NAME = "smallIconName"
+
+        private const val NOTIFICATION_ID = 6061
+
+        private const val DEFAULT_CHANNEL_ID = "stream_call_foreground_service"
+        private const val DEFAULT_CHANNEL_NAME = "Call in progress"
+        private const val DEFAULT_TITLE = "Call in progress"
+        private const val DEFAULT_BODY = "Tap to return to the call"
+
+        fun buildStartIntent(
+            context: android.content.Context,
+            callCid: String,
+            channelId: String,
+            channelName: String,
+            title: String,
+            body: String,
+            smallIconName: String?
+        ): Intent {
+            return Intent(context, StreamCallKeepAliveHeadlessService::class.java).apply {
+                putExtra(EXTRA_CALL_CID, callCid)
+                putExtra(EXTRA_CHANNEL_ID, channelId)
+                putExtra(EXTRA_CHANNEL_NAME, channelName)
+                putExtra(EXTRA_TITLE, title)
+                putExtra(EXTRA_BODY, body)
+                if (!smallIconName.isNullOrBlank()) {
+                    putExtra(EXTRA_SMALL_ICON_NAME, smallIconName)
+                }
+            }
+        }
+
+        fun buildStopIntent(context: android.content.Context): Intent {
+            return Intent(context, StreamCallKeepAliveHeadlessService::class.java)
+        }
+    }
+}
+

package/dist/commonjs/hooks/push/useCallingExpWithCallingStateEffect.js

@@ -0,0 +1,235 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCallingExpWithCallingStateEffect = void 0;
+var _videoClient = require("@stream-io/video-client");
+var _videoReactBindings = require("@stream-io/video-react-bindings");
+var _react = require("react");
+var _callingx = require("../../utils/push/libs/callingx");
+const logger = _videoClient.videoLoggerSystem.getLogger('useCallingExpWithCallingStateEffect');
+
+//calling state methods are not exhaustive, so we need to add more methods to cover different cases
+const canAcceptIncomingCall = (prevState, currentState) => {
+  if (!prevState && !currentState) {
+    return false;
+  }
+  const isJoined = state => {
+    if (!state) {
+      return false;
+    }
+    return state === _videoClient.CallingState.JOINING || state === _videoClient.CallingState.JOINED;
+  };
+  return !isJoined(prevState) && isJoined(currentState) || prevState === _videoClient.CallingState.JOINING && currentState === _videoClient.CallingState.JOINED;
+};
+const canEndCall = (prevState, currentState) => {
+  if (!prevState && !currentState) {
+    return false;
+  }
+  return (prevState === _videoClient.CallingState.JOINED || prevState === _videoClient.CallingState.JOINING || prevState === _videoClient.CallingState.RINGING || prevState === _videoClient.CallingState.RECONNECTING || prevState === _videoClient.CallingState.MIGRATING || prevState === _videoClient.CallingState.OFFLINE) && (currentState === _videoClient.CallingState.LEFT || currentState === _videoClient.CallingState.RECONNECTING_FAILED || currentState === _videoClient.CallingState.IDLE);
+};
+const canStartCall = (prevState, currentState) => {
+  if (!prevState && !currentState) {
+    return false;
+  }
+  return (!prevState || prevState === _videoClient.CallingState.IDLE || prevState === _videoClient.CallingState.UNKNOWN) && (currentState === _videoClient.CallingState.JOINED || currentState === _videoClient.CallingState.JOINING || currentState === _videoClient.CallingState.RINGING);
+};
+function getCallDisplayName(callMembers, participants, currentUserId) {
+  if (!callMembers || !participants || !currentUserId) {
+    return 'Call';
+  }
+  let names = [];
+  if (callMembers.length > 0) {
+    names = callMembers.filter(member => member.user.id !== currentUserId).map(member => member.user.name).filter(name => name !== undefined);
+  } else if (participants.length > 0) {
+    names = participants.filter(participant => participant.userId !== currentUserId).map(participant => participant.name).filter(Boolean);
+  }
+  return names.length > 0 ? names.sort().join(', ') : 'Call';
+}
+
+/**
+ * This hook is used to inform sync call state with CallKit/Telecom (i.e. start call, end call, mute/unmute call).
+ */
+const useCallingExpWithCallingStateEffect = () => {
+  const {
+    useCallCallingState,
+    // useMicrophoneState,
+    useParticipants,
+    useCallMembers
+  } = (0, _videoReactBindings.useCallStateHooks)();
+  const activeCall = (0, _videoReactBindings.useCall)();
+  const callingState = useCallCallingState();
+  // const { isMute, microphone } = useMicrophoneState();
+  const callMembers = useCallMembers();
+  const participants = useParticipants();
+  const prevState = (0, _react.useRef)(undefined);
+  const activeCallCid = activeCall?.cid;
+  const isIncomingCall = activeCall?.ringing && !activeCall?.isCreatedByMe;
+  const isOutcomingCall = activeCall?.ringing && activeCall?.isCreatedByMe;
+  const currentUserId = activeCall?.currentUserId;
+  const isVideoCall = activeCall?.state.settings?.video?.enabled ?? false;
+  const callDisplayName = (0, _react.useMemo)(() => getCallDisplayName(callMembers, participants, currentUserId), [callMembers, participants, currentUserId]);
+  (0, _react.useEffect)(() => {
+    return () => {
+      const callingx = (0, _callingx.getCallingxLibIfAvailable)();
+      if (!callingx?.isSetup || !activeCallCid) {
+        return;
+      }
+      const isCallRegistered = callingx.isCallRegistered(activeCallCid);
+      if (!isCallRegistered) {
+        logger.debug(`No active call cid to end in calling exp: ${activeCallCid} isCallRegistered: ${isCallRegistered}`);
+        return;
+      }
+      //if incoming stream call was unmounted, we need to end the call in CallKit/Telecom
+      logger.debug(`Ending call in calling exp: ${activeCallCid}`);
+      callingx.endCallWithReason(activeCallCid, 'local').catch(error => {
+        logger.error(`Error ending call in calling exp: ${activeCallCid}`, error);
+      });
+    };
+  }, [activeCallCid]);
+  (0, _react.useEffect)(() => {
+    const callingx = (0, _callingx.getCallingxLibIfAvailable)();
+    if (!callingx?.isSetup || !activeCallCid || prevState.current === callingState) {
+      return;
+    }
+
+    //tells if call is registered in CallKit/Telecom
+    const isCallRegistered = callingx.isCallRegistered(activeCallCid);
+    logger.debug(`useEffect: ${activeCallCid} isCallRegistered: ${isCallRegistered} 
+      isIncomingCall: ${isIncomingCall} isOutcomingCall: ${isOutcomingCall} 
+      prevState: ${prevState.current}, currentState: ${callingState} 
+      isOngoingCallsEnabled: ${callingx.isOngoingCallsEnabled}`);
+    if (isIncomingCall && isCallRegistered && canAcceptIncomingCall(prevState.current, callingState)) {
+      logger.debug(`Should accept call in callkeep: ${activeCallCid}`);
+      callingx.answerIncomingCall(activeCallCid).catch(error => {
+        logger.error(`Error answering call in calling exp: ${activeCallCid}`, error);
+      });
+    } else if ((isOutcomingCall || !isIncomingCall && callingx.isOngoingCallsEnabled) &&
+    //we register call in case if is outcoming ringing call or it is non-ringing call and ongoing calls are enabled
+    !isCallRegistered && canStartCall(prevState.current, callingState)) {
+      logger.debug(`Should register call in callkeep: ${activeCallCid}`);
+      //we request start call action from CallKit/Telecom, next step is to make call active when we receive call started event
+      callingx.startCall(activeCallCid, activeCallCid, callDisplayName, isVideoCall).catch(error => {
+        logger.error(`Error starting call in calling exp: ${activeCallCid}`, error);
+      });
+    } else if (isCallRegistered && canEndCall(prevState.current, callingState)) {
+      //in case call was registered as incoming and state changed to "not joined", we need to end the call and clear rxjs subject
+      logger.debug(`Should end call in callkeep: ${activeCallCid}`);
+      //TODO: think about sending appropriate reason for end call
+      callingx.endCallWithReason(activeCallCid, 'local').catch(error => {
+        logger.error(`Error ending call in calling exp: ${activeCallCid}`, error);
+      });
+    }
+    prevState.current = callingState;
+  }, [activeCallCid, callingState, callDisplayName, isIncomingCall, isOutcomingCall, isVideoCall]);
+  (0, _react.useEffect)(() => {
+    const callingx = (0, _callingx.getCallingxLibIfAvailable)();
+    if (!callingx?.isSetup || !activeCallCid) {
+      logger.debug(`No active call cid to listen to start call action in calling exp: ${activeCallCid} callingx is not setup`);
+      return;
+    }
+    if (!isOutcomingCall && !(!isIncomingCall && callingx.isOngoingCallsEnabled)) {
+      logger.debug(`Call is not outcoming or ongoing calls are not enabled for non-ringing calls`);
+      return;
+    }
+
+    //listen to start call action from CallKit/Telecom and set the current call active
+    const subscription = callingx.addEventListener('didReceiveStartCallAction', ({
+      callId
+    }) => {
+      if (callId === activeCallCid) {
+        logger.debug(`Received start call action for call: ${activeCallCid}`);
+        callingx.setCurrentCallActive(activeCallCid).catch(error => {
+          logger.error(`Error answering call in calling exp: ${activeCallCid}`, error);
+        });
+      }
+    });
+    return () => {
+      subscription.remove();
+    };
+  }, [activeCallCid, isOutcomingCall, isIncomingCall]);
+  (0, _react.useEffect)(() => {
+    const callingx = (0, _callingx.getCallingxLibIfAvailable)();
+    if (!callingx?.isSetup || !activeCallCid) {
+      return;
+    }
+    const isCallRegistered = callingx.isCallRegistered(activeCallCid);
+    if (!isCallRegistered) {
+      logger.debug(`No active call cid to update calling exp: ${activeCallCid} isCallRegistered: ${isCallRegistered}`);
+      return;
+    }
+    callingx.updateDisplay(activeCallCid, activeCallCid, callDisplayName);
+  }, [activeCallCid, callDisplayName]);
+
+  // useEffect(() => {
+  //   const callingx = getCallingxLibIfAvailable();
+  //   if (!callingx?.isSetup || !activeCallCid) {
+  //     return;
+  //   }
+
+  //   const isCallRegistered = callingx.isCallRegistered(activeCallCid);
+  //   if (!isCallRegistered) {
+  //     logger.debug(
+  //       `No active call cid to set muted in calling exp: ${activeCallCid} isCallRegistered: ${isCallRegistered}`,
+  //     );
+  //     return;
+  //   }
+
+  //   callingx.setMutedCall(activeCallCid, isMute);
+  // }, [activeCallCid, isMute]);
+
+  // useEffect(() => {
+  //   const callingx = getCallingxLibIfAvailable();
+  //   if (!callingx?.isSetup || !activeCallCid) {
+  //     return;
+  //   }
+
+  //   const isCallRegistered = callingx.isCallRegistered(activeCallCid);
+  //   if (!isCallRegistered) {
+  //     logger.debug(
+  //       `No active call cid to set muted in calling exp: ${activeCallCid} isCallRegistered: ${isCallRegistered}`,
+  //     );
+  //     return;
+  //   }
+
+  //   //listen to mic toggle events from CallKit/Telecom and update stream call microphone state
+  //   const subscription = callingx.addEventListener(
+  //     'didPerformSetMutedCallAction',
+  //     async (event: { callId: string; muted: boolean }) => {
+  //       const { callId, muted } = event;
+
+  //       if (callId === activeCallCid) {
+  //         const isCurrentlyMuted =
+  //           RxUtils.getCurrentValue(microphone.state.status$) === 'disabled';
+  //         if (isCurrentlyMuted === muted) {
+  //           logger.debug(
+  //             `Mic toggle is already in the desired state: ${muted} for call: ${activeCallCid}`,
+  //           );
+  //           //this check prevents mic toggle when state change was initiated from client and not from CallKit/Telecom
+  //           return;
+  //         }
+
+  //         try {
+  //           if (muted) {
+  //             await microphone.disable();
+  //           } else {
+  //             await microphone.enable();
+  //           }
+  //         } catch (error: unknown) {
+  //           logger.error(
+  //             `Error toggling mic in calling exp: ${activeCallCid}`,
+  //             error,
+  //           );
+  //         }
+  //       }
+  //     },
+  //   );
+
+  //   return () => {
+  //     subscription.remove();
+  //   };
+  // }, [activeCallCid, microphone, isOutcomingCall, isIncomingCall]);
+};
+exports.useCallingExpWithCallingStateEffect = useCallingExpWithCallingStateEffect;
+//# sourceMappingURL=useCallingExpWithCallingStateEffect.js.map

package/dist/commonjs/hooks/push/useCallingExpWithCallingStateEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_videoClient","require","_videoReactBindings","_react","_callingx","logger","videoLoggerSystem","getLogger","canAcceptIncomingCall","prevState","currentState","isJoined","state","CallingState","JOINING","JOINED","canEndCall","RINGING","RECONNECTING","MIGRATING","OFFLINE","LEFT","RECONNECTING_FAILED","IDLE","canStartCall","UNKNOWN","getCallDisplayName","callMembers","participants","currentUserId","names","length","filter","member","user","id","map","name","undefined","participant","userId","Boolean","sort","join","useCallingExpWithCallingStateEffect","useCallCallingState","useParticipants","useCallMembers","useCallStateHooks","activeCall","useCall","callingState","useRef","activeCallCid","cid","isIncomingCall","ringing","isCreatedByMe","isOutcomingCall","isVideoCall","settings","video","enabled","callDisplayName","useMemo","useEffect","callingx","getCallingxLibIfAvailable","isSetup","isCallRegistered","debug","endCallWithReason","catch","error","current","isOngoingCallsEnabled","answerIncomingCall","startCall","subscription","addEventListener","callId","setCurrentCallActive","remove","updateDisplay","exports"],"sourceRoot":"../../../../src","sources":["hooks/push/useCallingExpWithCallingStateEffect.ts"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAMA,IAAAC,mBAAA,GAAAD,OAAA;AACA,IAAAE,MAAA,GAAAF,OAAA;AACA,IAAAG,SAAA,GAAAH,OAAA;AAEA,MAAMI,MAAM,GAAGC,8BAAiB,CAACC,SAAS,CACxC,qCACF,CAAC;;AAED;AACA,MAAMC,qBAAqB,GAAGA,CAC5BC,SAAmC,EACnCC,YAAsC,KACnC;EACH,IAAI,CAACD,SAAS,IAAI,CAACC,YAAY,EAAE;IAC/B,OAAO,KAAK;EACd;EAEA,MAAMC,QAAQ,GAAIC,KAA+B,IAAK;IACpD,IAAI,CAACA,KAAK,EAAE;MACV,OAAO,KAAK;IACd;IAEA,OAAOA,KAAK,KAAKC,yBAAY,CAACC,OAAO,IAAIF,KAAK,KAAKC,yBAAY,CAACE,MAAM;EACxE,CAAC;EAED,OACG,CAACJ,QAAQ,CAACF,SAAS,CAAC,IAAIE,QAAQ,CAACD,YAAY,CAAC,IAC9CD,SAAS,KAAKI,yBAAY,CAACC,OAAO,IAAIJ,YAAY,KAAKG,yBAAY,CAACE,MAAO;AAEhF,CAAC;AAED,MAAMC,UAAU,GAAGA,CACjBP,SAAmC,EACnCC,YAAsC,KACnC;EACH,IAAI,CAACD,SAAS,IAAI,CAACC,YAAY,EAAE;IAC/B,OAAO,KAAK;EACd;EAEA,OACE,CAACD,SAAS,KAAKI,yBAAY,CAACE,MAAM,IAChCN,SAAS,KAAKI,yBAAY,CAACC,OAAO,IAClCL,SAAS,KAAKI,yBAAY,CAACI,OAAO,IAClCR,SAAS,KAAKI,yBAAY,CAACK,YAAY,IACvCT,SAAS,KAAKI,yBAAY,CAACM,SAAS,IACpCV,SAAS,KAAKI,yBAAY,CAACO,OAAO,MACnCV,YAAY,KAAKG,yBAAY,CAACQ,IAAI,IACjCX,YAAY,KAAKG,yBAAY,CAACS,mBAAmB,IACjDZ,YAAY,KAAKG,yBAAY,CAACU,IAAI,CAAC;AAEzC,CAAC;AAED,MAAMC,YAAY,GAAGA,CACnBf,SAAmC,EACnCC,YAAsC,KACnC;EACH,IAAI,CAACD,SAAS,IAAI,CAACC,YAAY,EAAE;IAC/B,OAAO,KAAK;EACd;EAEA,OACE,CAAC,CAACD,SAAS,IACTA,SAAS,KAAKI,yBAAY,CAACU,IAAI,IAC/Bd,SAAS,KAAKI,yBAAY,CAACY,OAAO,MACnCf,YAAY,KAAKG,yBAAY,CAACE,MAAM,IACnCL,YAAY,KAAKG,yBAAY,CAACC,OAAO,IACrCJ,YAAY,KAAKG,yBAAY,CAACI,OAAO,CAAC;AAE5C,CAAC;AAED,SAASS,kBAAkBA,CACzBC,WAAyC,EACzCC,YAAkD,EAClDC,aAAiC,EACjC;EACA,IAAI,CAACF,WAAW,IAAI,CAACC,YAAY,IAAI,CAACC,aAAa,EAAE;IACnD,OAAO,MAAM;EACf;EAEA,IAAIC,KAAe,GAAG,EAAE;EAExB,IAAIH,WAAW,CAACI,MAAM,GAAG,CAAC,EAAE;IAC1BD,KAAK,GAAGH,WAAW,CAChBK,MAAM,CAAEC,MAAM,IAAKA,MAAM,CAACC,IAAI,CAACC,EAAE,KAAKN,aAAa,CAAC,CACpDO,GAAG,CAAEH,MAAM,IAAKA,MAAM,CAACC,IAAI,CAACG,IAAI,CAAC,CACjCL,MAAM,CAAEK,IAAI,IAAqBA,IAAI,KAAKC,SAAS,CAAC;EACzD,CAAC,MAAM,IAAIV,YAAY,CAACG,MAAM,GAAG,CAAC,EAAE;IAClCD,KAAK,GAAGF,YAAY,CACjBI,MAAM,CAAEO,WAAW,IAAKA,WAAW,CAACC,MAAM,KAAKX,aAAa,CAAC,CAC7DO,GAAG,CAAEG,WAAW,IAAKA,WAAW,CAACF,IAAI,CAAC,CACtCL,MAAM,CAACS,OAAO,CAAC;EACpB;EAEA,OAAOX,KAAK,CAACC,MAAM,GAAG,CAAC,GAAGD,KAAK,CAACY,IAAI,CAAC,CAAC,CAACC,IAAI,CAAC,IAAI,CAAC,GAAG,MAAM;AAC5D;;AAEA;AACA;AACA;AACO,MAAMC,mCAAmC,GAAGA,CAAA,KAAM;EACvD,MAAM;IACJC,mBAAmB;IACnB;IACAC,eAAe;IACfC;EACF,CAAC,GAAG,IAAAC,qCAAiB,EAAC,CAAC;EAEvB,MAAMC,UAAU,GAAG,IAAAC,2BAAO,EAAC,CAAC;EAC5B,MAAMC,YAAY,GAAGN,mBAAmB,CAAC,CAAC;EAC1C;EACA,MAAMlB,WAAW,GAAGoB,cAAc,CAAC,CAAC;EACpC,MAAMnB,YAAY,GAAGkB,eAAe,CAAC,CAAC;EAEtC,MAAMrC,SAAS,GAAG,IAAA2C,aAAM,EAA2Bd,SAAS,CAAC;EAE7D,MAAMe,aAAa,GAAGJ,UAAU,EAAEK,GAAG;EACrC,MAAMC,cAAc,GAAGN,UAAU,EAAEO,OAAO,IAAI,CAACP,UAAU,EAAEQ,aAAa;EACxE,MAAMC,eAAe,GAAGT,UAAU,EAAEO,OAAO,IAAIP,UAAU,EAAEQ,aAAa;EACxE,MAAM5B,aAAa,GAAGoB,UAAU,EAAEpB,aAAa;EAC/C,MAAM8B,WAAW,GAAGV,UAAU,EAAErC,KAAK,CAACgD,QAAQ,EAAEC,KAAK,EAAEC,OAAO,IAAI,KAAK;EAEvE,MAAMC,eAAe,GAAG,IAAAC,cAAO,EAC7B,MAAMtC,kBAAkB,CAACC,WAAW,EAAEC,YAAY,EAAEC,aAAa,CAAC,EAClE,CAACF,WAAW,EAAEC,YAAY,EAAEC,aAAa,CAC3C,CAAC;EAED,IAAAoC,gBAAS,EAAC,MAAM;IACd,OAAO,MAAM;MACX,MAAMC,QAAQ,GAAG,IAAAC,mCAAyB,EAAC,CAAC;MAC5C,IAAI,CAACD,QAAQ,EAAEE,OAAO,IAAI,CAACf,aAAa,EAAE;QACxC;MACF;MAEA,MAAMgB,gBAAgB,GAAGH,QAAQ,CAACG,gBAAgB,CAAChB,aAAa,CAAC;MACjE,IAAI,CAACgB,gBAAgB,EAAE;QACrBhE,MAAM,CAACiE,KAAK,CACV,6CAA6CjB,aAAa,sBAAsBgB,gBAAgB,EAClG,CAAC;QACD;MACF;MACA;MACAhE,MAAM,CAACiE,KAAK,CAAC,+BAA+BjB,aAAa,EAAE,CAAC;MAC5Da,QAAQ,CACLK,iBAAiB,CAAClB,aAAa,EAAE,OAAO,CAAC,CACzCmB,KAAK,CAAEC,KAAc,IAAK;QACzBpE,MAAM,CAACoE,KAAK,CACV,qCAAqCpB,aAAa,EAAE,EACpDoB,KACF,CAAC;MACH,CAAC,CAAC;IACN,CAAC;EACH,CAAC,EAAE,CAACpB,aAAa,CAAC,CAAC;EAEnB,IAAAY,gBAAS,EAAC,MAAM;IACd,MAAMC,QAAQ,GAAG,IAAAC,mCAAyB,EAAC,CAAC;IAC5C,IACE,CAACD,QAAQ,EAAEE,OAAO,IAClB,CAACf,aAAa,IACd5C,SAAS,CAACiE,OAAO,KAAKvB,YAAY,EAClC;MACA;IACF;;IAEA;IACA,MAAMkB,gBAAgB,GAAGH,QAAQ,CAACG,gBAAgB,CAAChB,aAAa,CAAC;IACjEhD,MAAM,CAACiE,KAAK,CACV,cAAcjB,aAAa,sBAAsBgB,gBAAgB;AACvE,wBAAwBd,cAAc,qBAAqBG,eAAe;AAC1E,mBAAmBjD,SAAS,CAACiE,OAAO,mBAAmBvB,YAAY;AACnE,+BAA+Be,QAAQ,CAACS,qBAAqB,EACzD,CAAC;IAED,IACEpB,cAAc,IACdc,gBAAgB,IAChB7D,qBAAqB,CAACC,SAAS,CAACiE,OAAO,EAAEvB,YAAY,CAAC,EACtD;MACA9C,MAAM,CAACiE,KAAK,CAAC,mCAAmCjB,aAAa,EAAE,CAAC;MAChEa,QAAQ,CAACU,kBAAkB,CAACvB,aAAa,CAAC,CAACmB,KAAK,CAAEC,KAAc,IAAK;QACnEpE,MAAM,CAACoE,KAAK,CACV,wCAAwCpB,aAAa,EAAE,EACvDoB,KACF,CAAC;MACH,CAAC,CAAC;IACJ,CAAC,MAAM,IACL,CAACf,eAAe,IACb,CAACH,cAAc,IAAIW,QAAQ,CAACS,qBAAsB;IAAK;IAC1D,CAACN,gBAAgB,IACjB7C,YAAY,CAACf,SAAS,CAACiE,OAAO,EAAEvB,YAAY,CAAC,EAC7C;MACA9C,MAAM,CAACiE,KAAK,CAAC,qCAAqCjB,aAAa,EAAE,CAAC;MAClE;MACAa,QAAQ,CACLW,SAAS,CAACxB,aAAa,EAAEA,aAAa,EAAEU,eAAe,EAAEJ,WAAW,CAAC,CACrEa,KAAK,CAAEC,KAAc,IAAK;QACzBpE,MAAM,CAACoE,KAAK,CACV,uCAAuCpB,aAAa,EAAE,EACtDoB,KACF,CAAC;MACH,CAAC,CAAC;IACN,CAAC,MAAM,IACLJ,gBAAgB,IAChBrD,UAAU,CAACP,SAAS,CAACiE,OAAO,EAAEvB,YAAY,CAAC,EAC3C;MACA;MACA9C,MAAM,CAACiE,KAAK,CAAC,gCAAgCjB,aAAa,EAAE,CAAC;MAC7D;MACAa,QAAQ,CACLK,iBAAiB,CAAClB,aAAa,EAAE,OAAO,CAAC,CACzCmB,KAAK,CAAEC,KAAc,IAAK;QACzBpE,MAAM,CAACoE,KAAK,CACV,qCAAqCpB,aAAa,EAAE,EACpDoB,KACF,CAAC;MACH,CAAC,CAAC;IACN;IAEAhE,SAAS,CAACiE,OAAO,GAAGvB,YAAY;EAClC,CAAC,EAAE,CACDE,aAAa,EACbF,YAAY,EACZY,eAAe,EACfR,cAAc,EACdG,eAAe,EACfC,WAAW,CACZ,CAAC;EAEF,IAAAM,gBAAS,EAAC,MAAM;IACd,MAAMC,QAAQ,GAAG,IAAAC,mCAAyB,EAAC,CAAC;IAC5C,IAAI,CAACD,QAAQ,EAAEE,OAAO,IAAI,CAACf,aAAa,EAAE;MACxChD,MAAM,CAACiE,KAAK,CACV,qEAAqEjB,aAAa,wBACpF,CAAC;MACD;IACF;IAEA,IACE,CAACK,eAAe,IAChB,EAAE,CAACH,cAAc,IAAIW,QAAQ,CAACS,qBAAqB,CAAC,EACpD;MACAtE,MAAM,CAACiE,KAAK,CACV,8EACF,CAAC;MACD;IACF;;IAEA;IACA,MAAMQ,YAAY,GAAGZ,QAAQ,CAACa,gBAAgB,CAC5C,2BAA2B,EAC3B,CAAC;MAAEC;IAA2B,CAAC,KAAK;MAClC,IAAIA,MAAM,KAAK3B,aAAa,EAAE;QAC5BhD,MAAM,CAACiE,KAAK,CAAC,wCAAwCjB,aAAa,EAAE,CAAC;QACrEa,QAAQ,CACLe,oBAAoB,CAAC5B,aAAa,CAAC,CACnCmB,KAAK,CAAEC,KAAc,IAAK;UACzBpE,MAAM,CAACoE,KAAK,CACV,wCAAwCpB,aAAa,EAAE,EACvDoB,KACF,CAAC;QACH,CAAC,CAAC;MACN;IACF,CACF,CAAC;IAED,OAAO,MAAM;MACXK,YAAY,CAACI,MAAM,CAAC,CAAC;IACvB,CAAC;EACH,CAAC,EAAE,CAAC7B,aAAa,EAAEK,eAAe,EAAEH,cAAc,CAAC,CAAC;EAEpD,IAAAU,gBAAS,EAAC,MAAM;IACd,MAAMC,QAAQ,GAAG,IAAAC,mCAAyB,EAAC,CAAC;IAC5C,IAAI,CAACD,QAAQ,EAAEE,OAAO,IAAI,CAACf,aAAa,EAAE;MACxC;IACF;IAEA,MAAMgB,gBAAgB,GAAGH,QAAQ,CAACG,gBAAgB,CAAChB,aAAa,CAAC;IACjE,IAAI,CAACgB,gBAAgB,EAAE;MACrBhE,MAAM,CAACiE,KAAK,CACV,6CAA6CjB,aAAa,sBAAsBgB,gBAAgB,EAClG,CAAC;MACD;IACF;IAEAH,QAAQ,CAACiB,aAAa,CAAC9B,aAAa,EAAEA,aAAa,EAAEU,eAAe,CAAC;EACvE,CAAC,EAAE,CAACV,aAAa,EAAEU,eAAe,CAAC,CAAC;;EAEpC;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;;EAEA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;AACF,CAAC;AAACqB,OAAA,CAAAxC,mCAAA,GAAAA,mCAAA","ignoreList":[]}

package/dist/commonjs/hooks/push/useIosVoipPushEventsSetupEffect.js

@@ -5,13 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useIosVoipPushEventsSetupEffect = void 0;
 var _react = require("react");
-var _libs = require("../../utils/push/libs");
 var _reactNative = require("react-native");
 var _utils = require("../../utils");
 var _ios = require("../../utils/push/internal/ios");
 var _videoReactBindings = require("@stream-io/video-react-bindings");
 var _pushLogoutCallback = require("../../utils/internal/pushLogoutCallback");
 var _videoClient = require("@stream-io/video-client");
+var _libs = require("../../utils/push/libs");
 const logger = _videoClient.videoLoggerSystem.getLogger('useIosVoipPushEventsSetupEffect');
 
 /* VoipPushNotificationLib has support for only one listener type at a time
@@ -29,6 +29,7 @@ function setLogoutCallback(client, token, lastVoipTokenRef) {
     };
     try {
       await client.removeDevice(token);
+      logger.debug('PushLogoutCallback - Removed voip token', token);
     } catch (err) {
       logger.warn('PushLogoutCallback - Failed to remove voip token', err);
     }
@@ -83,20 +84,10 @@ const useIosVoipPushEventsSetupEffect = () => {
   (0, _react.useEffect)(() => {
     const pushConfig = _utils.StreamVideoRN.getConfig().push;
     const pushProviderName = pushConfig?.ios.pushProviderName;
-    if (_reactNative.Platform.OS !== 'ios' || !client || !pushProviderName) {
-      return;
-    }
-    if (!pushConfig.android.incomingCallChannel) {
-      // TODO: remove this check and find a better way once we have telecom integration for android
-      logger.debug('android incomingCallChannel is not defined, so skipping the useIosVoipPushEventsSetupEffect');
+    const callingx = (0, _libs.getCallingxLibIfAvailable)();
+    if (_reactNative.Platform.OS !== 'ios' || !client || !pushProviderName || !callingx) {
       return;
     }
-    const voipPushNotification = (0, _libs.getVoipPushNotificationLib)();
-
-    // even though we do this natively, we have to still register here again
-    // natively this will make sure "register" event for JS is sent with the last push token
-    // Necessary if client changed before we got the event here or user logged out and logged in again
-    voipPushNotification.registerVoipToken();
     const onTokenReceived = token => {
       const userId = client.streamClient._user?.id ?? '';
       if (client.streamClient.anonymous || !token || !userId) {
@@ -124,27 +115,24 @@ const useIosVoipPushEventsSetupEffect = () => {
       });
     };
     // fired when PushKit give us the latest token
-    voipPushNotification.addEventListener('register', token => {
+    const voipRegisterListener = callingx.addEventListener('voipNotificationsRegistered', ({
+      token
+    }) => {
       onTokenReceived(token);
     });
 
-    // this will fire when there are events occured before js bridge initialized
-    voipPushNotification.addEventListener('didLoadWithEvents', events => {
-      if (!events || !Array.isArray(events) || events.length < 1) {
-        return;
-      }
-      for (const voipPushEvent of events) {
-        const {
-          name,
-          data
-        } = voipPushEvent;
-        if (name === 'RNVoipPushRemoteNotificationsRegisteredEvent') {
-          onTokenReceived(data);
-        } else if (name === 'RNVoipPushRemoteNotificationReceivedEvent') {
-          (0, _ios.onVoipNotificationReceived)(data, pushConfig);
-        }
+    // this will return events that were fired before js bridge initialized
+    callingx.getInitialVoipEvents().forEach(({
+      eventName,
+      params
+    }) => {
+      if (eventName === 'voipNotificationsRegistered' && 'token' in params) {
+        onTokenReceived(params.token);
+      } else if (eventName === 'voipNotificationReceived') {
+        (0, _ios.onVoipNotificationReceived)(params, pushConfig);
       }
     });
+    callingx.registerVoipToken();
     lastListener.count += 1;
     const currentListenerCount = lastListener.count;
     return () => {
@@ -154,8 +142,7 @@ const useIosVoipPushEventsSetupEffect = () => {
         return;
       }
       logger.debug(`Voip event listeners are removed for user: ${userId}`);
-      voipPushNotification.removeEventListener('didLoadWithEvents');
-      voipPushNotification.removeEventListener('register');
+      voipRegisterListener.remove();
     };
   }, [client]);
 };