@stream-io/video-react-native-sdk 1.34.0 → 1.36.0

package/src/components/Livestream/ViewerLivestream/ViewerLivestream.tsx

@@ -148,11 +148,19 @@ export const ViewerLivestream = ({
   ]);
 
   if (endedAt != null) {
-    return <CallEndedView />;
+    return (
+      <View style={[styles.container, viewerLivestream.container]}>
+        <CallEndedView />
+      </View>
+    );
   }
 
   if (!canJoinLive || callingState !== CallingState.JOINED) {
-    return <ViewerLobby isLive={canJoinLive} />;
+    return (
+      <View style={[styles.container, viewerLivestream.container]}>
+        <ViewerLobby isLive={canJoinLive} />
+      </View>
+    );
   }
 
   return (

package/src/components/Participant/ParticipantView/VideoRenderer/TrackSubscriber.tsx

@@ -63,7 +63,7 @@ const TrackSubscriber = forwardRef<TrackSubscriberHandle, TrackSubscriberProps>(
         call.state.updateParticipantTracks(trackType, {
           [participantSessionId]: { dimension },
         });
-        call.dynascaleManager.applyTrackSubscriptions(debounceType);
+        call.trackSubscriptionManager.apply(debounceType);
       };
       const isPublishingTrack$ = call.state.participants$.pipe(
         map((ps) => ps.find((p) => p.sessionId === participantSessionId)),

package/src/hooks/push/index.ts

@@ -1,15 +1,11 @@
 import { useIosVoipPushEventsSetupEffect } from './useIosVoipPushEventsSetupEffect';
 import { useInitAndroidTokenAndRest } from './useInitAndroidTokenAndRest';
-import { useIosInitRemoteNotifications } from './useIosInitRemoteNotifications';
-import { useProcessPushNonRingingCallEffect } from './useProcessPushNonRingingCallEffect';
 
 /**
  * This hook is used to do the initial setup for push notifications.
  * It must be used in a component which is a child of StreamVideo from bindings
  */
 export const usePushRegisterEffect = () => {
-  useIosInitRemoteNotifications();
   useIosVoipPushEventsSetupEffect();
-  useProcessPushNonRingingCallEffect();
   useInitAndroidTokenAndRest();
 };

package/src/modules/call-manager/CallManager.ts

@@ -112,6 +112,12 @@ export class CallManager {
    */
   start = (config?: StreamInCallManagerConfig): void => {
     if (shouldBypassForCallKit()) {
+      // Forward only the passive endpoint preference; callingx reads it when
+      // CallKit drives session activation.
+      if (config?.audioRole === 'communicator' && CallingxModule) {
+        const type = config.deviceEndpointType ?? 'speaker';
+        CallingxModule.setDefaultAudioDeviceEndpointType(type);
+      }
       videoLoggerSystem
         .getLogger('CallManager')
         .debug(

package/src/utils/StreamVideoRN/index.ts

@@ -1,8 +1,5 @@
 import type { StreamVideoConfig } from './types';
 import pushLogoutCallbacks from '../internal/pushLogoutCallback';
-import newNotificationCallbacks, {
-  type NewCallNotificationCallback,
-} from '../internal/newNotificationCallbacks';
 import { setupIosVoipPushEvents } from '../push/setupIosVoipPushEvents';
 import { setupCallingExpEvents } from '../push/setupCallingExpEvents';
 import {
@@ -160,25 +157,6 @@ export class StreamVideoRN {
     pushLogoutCallbacks.current = [];
   }
 
-  /**
-   * This function is used to add a callback to be called when a new call notification is received.
-   * @param callback
-   * @returns Unsubscribe function
-   */
-  static addOnNewCallNotificationListener(
-    callback: NewCallNotificationCallback,
-  ) {
-    if (!newNotificationCallbacks.current) {
-      newNotificationCallbacks.current = [callback];
-    } else {
-      newNotificationCallbacks.current.push(callback);
-    }
-    return () => {
-      newNotificationCallbacks.current =
-        newNotificationCallbacks.current?.filter((cb) => cb !== callback);
-    };
-  }
-
   /**
    * Play native busy tone for call rejection
    */

package/src/utils/StreamVideoRN/types.ts

@@ -3,7 +3,6 @@ import {
   StreamVideoClient,
   type Call,
 } from '@stream-io/video-client';
-import type { AndroidChannel } from '@notifee/react-native';
 
 export type AndroidChannelConfig = {
   id: string;
@@ -70,6 +69,21 @@ export type StreamVideoConfig = {
        * @default false
        */
       enableOngoingCalls?: boolean;
+      /**
+       * When true, ringing pushes that arrive while the app is in the
+       * foreground are not shown by CallKit. The push is still delivered to
+       * JS, so the app must show its own ringing UI. Background pushes are unaffected.
+       * Requires iOS 26.4 or newer version of iOS.
+       * @default false
+       */
+      skipIncomingPushInForeground?: boolean;
+      /**
+       * Default audio endpoint for CallKit-managed calls on iOS.
+       * `'earpiece'` routes voice-only / phone-style calls to the built-in receiver.
+       * Set via `setPushConfig` so it's in place before CallKit's `CXAnswerCallAction`.
+       * @default 'speaker'
+       */
+      defaultDeviceEndpointType?: 'speaker' | 'earpiece';
     };
     android?: {
       /**
@@ -84,17 +98,6 @@ export type StreamVideoConfig = {
        * @example "production-fcm-video" or "staging-fcm-video" based on the environment
        */
       pushProviderName?: string;
-      /**
-       * The notification channel to be used for non ringing calls for Android.
-       * @example
-       * {
-       *  id: 'stream_call_notifications',
-       *  name: 'Call notifications',
-       *  importance: AndroidImportance.HIGH,
-       *  sound: 'default',
-       * }
-       */
-      callChannel?: AndroidChannel;
       /**
        * The notification channel to be used for incoming calls for Android.
        * @example
@@ -123,38 +126,13 @@ export type StreamVideoConfig = {
        * The transformer to be used to transform the call title in the notification for ringing and ongoing calls for Android.
        */
       titleTransformer?: (memberName: string, incoming: boolean) => string;
+      enableOngoingCalls?: boolean;
       /**
-       * Functions to create the texts shown in the notification for non ringing calls in Android.
-       * @example
-       *  getTitle(type, createdUserName) {
-            if (type === 'call.live_started') {
-              return `Call went live, it was started by ${createdUserName}`;
-            } else if (type === 'call.missed') {
-              return `Missed call from ${createdUserName}`;
-            } else {
-              return `${createdUserName} is notifying you about a call`;
-            }
-          },
-          getBody(type, _createdUserName) {
-            if (type === 'call.missed') {
-              return 'Missed call!';
-            } else {
-              return 'Tap to open the call';
-            }
-          },
-       */
-      callNotificationTextGetters?: {
-        getTitle: (
-          type: NonRingingPushEvent,
-          createdUserName: string,
-        ) => string;
-        getBody: (type: NonRingingPushEvent, createdUserName: string) => string;
-      };
-      /**
-       * Whether to enable ongoing calls.
+       * When true, incoming call push notifications (call.ring) will not be displayed
+       * as a notification when the app is in the foreground.
        * @default false
        */
-      enableOngoingCalls?: boolean;
+      skipIncomingPushInForeground?: boolean;
     };
     /**
      * Whether to reject calls when the user is busy.
@@ -180,11 +158,6 @@ export type StreamVideoConfig = {
      * }
      */
     createStreamVideoClient: () => Promise<StreamVideoClient | undefined>;
-    /** Callback that is called when a non ringing push notification was tapped */
-    onTapNonRingingCallNotification?: (
-      call_cid: string,
-      type: NonRingingPushEvent,
-    ) => void;
   };
   foregroundService: {
     android: {

package/src/utils/internal/callingx/callingx.ts

@@ -2,7 +2,7 @@
  * Internal utils for callingx library usage from video-client.
  * See @./registerSDKGlobals.ts for more usage details.
  */
-import { Platform } from 'react-native';
+import { AppState, NativeModules, Platform } from 'react-native';
 import type { EndCallReason } from '@stream-io/react-native-callingx';
 import { getCallingxLibIfAvailable } from '../../push/libs/callingx';
 import { waitForAudioSessionActivation } from './audioSessionPromise';
@@ -12,8 +12,18 @@ import type {
   StreamVideoParticipant,
 } from '@stream-io/video-client';
 import { CallingState, videoLoggerSystem } from '@stream-io/video-client';
+import { StreamVideoRN } from '../../StreamVideoRN';
 const CallingxModule = getCallingxLibIfAvailable();
 
+async function isAppInForeground(): Promise<boolean> {
+  if (Platform.OS === 'android') {
+    const nativeModule = NativeModules.StreamVideoAppLifecycle;
+    const state = await nativeModule.getCurrentAppState();
+    return state === 'active';
+  }
+  return AppState.currentState !== 'background';
+}
+
 /**
  * Gets the call display name. To be used for display in native call screen.
  */
@@ -78,10 +88,11 @@ export async function registerOutgoingCall(call: Call) {
 
   try {
     logger.debug(`registerOutgoingCall: Registering outgoing call ${call.cid}`);
+    const callDisplayName = getCallDisplayNameFromCall(call);
     await CallingxModule.startCall(
       call.cid, // unique id for call
-      call.state.createdBy?.id ?? getCallDisplayNameFromCall(call), // handle for native call UI (prefer createdBy user id, fallback to call display name)
-      getCallDisplayNameFromCall(call), // display name for display in call screen
+      call.state.createdBy?.id ?? callDisplayName, // handle for native call UI (prefer createdBy user id, fallback to call display name)
+      callDisplayName, // display name for display in call screen
       call.state.settings?.video?.enabled ?? false, // is video call?
     );
   } catch (error) {
@@ -109,23 +120,26 @@ export async function joinCallingxCall(call: Call, activeCalls: Call[]) {
   const isOutcomingCall = call.ringing && call.isCreatedByMe;
   const isIncomingCall = call.ringing && !call.isCreatedByMe;
 
+  const startCallInCallingx = async () => {
+    logger.debug(`joinCallingxCall: Joining call ${call.cid}`);
+    const callDisplayName = getCallDisplayNameFromCall(call);
+    await CallingxModule.startCall(
+      call.cid, // unique id for call
+      call.state.createdBy?.id ?? callDisplayName, // handle for native call UI (prefer createdBy user id, fallback to call display name)
+      callDisplayName, // display name for display in call screen
+      call.state.settings?.video?.enabled ?? false, // is video call?
+    );
+    if (Platform.OS === 'ios') {
+      await waitForAudioSessionActivation();
+    }
+  };
+
   if (
     isOutcomingCall ||
     (!call.ringing && CallingxModule.isOngoingCallsEnabled)
   ) {
     try {
-      logger.debug(`joinCallingxCall: Joining call ${call.cid}`);
-      await CallingxModule.startCall(
-        call.cid, // unique id for call
-        call.state.createdBy?.id ?? getCallDisplayNameFromCall(call), // handle for native call UI (prefer createdBy user id, fallback to call display name)
-        getCallDisplayNameFromCall(call), // display name for display in call screen
-        call.state.settings?.video?.enabled ?? false, // is video call?
-      );
-
-      // Wait for audio session activation on iOS only
-      if (Platform.OS === 'ios') {
-        await waitForAudioSessionActivation();
-      }
+      await startCallInCallingx();
     } catch (error) {
       logger.error(
         `startCallingxCall: Error starting call in callingx: ${call.cid}`,
@@ -134,6 +148,19 @@ export async function joinCallingxCall(call: Call, activeCalls: Call[]) {
     }
   } else if (isIncomingCall) {
     logger.debug(`joinCallingxCall: Joining incoming call ${call.cid}`);
+    let skipIncomingPushInForeground = false;
+    if (Platform.OS === 'ios') {
+      skipIncomingPushInForeground =
+        StreamVideoRN.getConfig().push?.ios?.skipIncomingPushInForeground ??
+        false;
+    } else {
+      skipIncomingPushInForeground =
+        StreamVideoRN.getConfig().push?.android?.skipIncomingPushInForeground ??
+        false;
+    }
+    const shouldSkipDisplayIncoming = skipIncomingPushInForeground
+      ? await isAppInForeground()
+      : false;
     try {
       // Leave any existing active ringing calls before joining a new ringing call
       const activeCallsToLeave = activeCalls.filter(
@@ -150,25 +177,29 @@ export async function joinCallingxCall(call: Call, activeCalls: Call[]) {
           logger.error(`failed to leave active call ${activeCall.cid}`, e);
         });
       }
+      if (shouldSkipDisplayIncoming) {
+        await startCallInCallingx();
+      } else {
+        // Awaits native CallKit/Telecom registration before answering.
+        // Safe to call even if the call is already registered (e.g. from VoIP push) --
+        // iOS early-returns with no error, Android sends the registered broadcast.
+        const callDisplayName = getCallDisplayNameFromCall(call);
+        await CallingxModule.displayIncomingCall(
+          call.cid, // unique id for call
+          call.state.createdBy?.id ?? callDisplayName, // handle for native call UI (prefer createdBy user id, fallback to call display name)
+          callDisplayName, // display name for display in call screen
+          call.state.settings?.video?.enabled ?? false, // is video call?
+        );
 
-      // Awaits native CallKit/Telecom registration before answering.
-      // Safe to call even if the call is already registered (e.g. from VoIP push) --
-      // iOS early-returns with no error, Android sends the registered broadcast.
-      await CallingxModule.displayIncomingCall(
-        call.cid, // unique id for call
-        call.state.createdBy?.id ?? getCallDisplayNameFromCall(call), // handle for native call UI (prefer createdBy user id, fallback to call display name)
-        getCallDisplayNameFromCall(call), // display name for display in call screen
-        call.state.settings?.video?.enabled ?? false, // is video call?
-      );
-
-      await CallingxModule.answerIncomingCall(call.cid);
+        await CallingxModule.answerIncomingCall(call.cid);
 
-      if (Platform.OS === 'ios') {
-        await waitForAudioSessionActivation();
+        if (Platform.OS === 'ios') {
+          await waitForAudioSessionActivation();
+        }
       }
     } catch (error) {
       logger.error(
-        `Error displaying incoming call in callingx: ${call.cid}`,
+        `Error joining incoming call in callingx: ${call.cid} shouldSkipDisplayIncoming: ${shouldSkipDisplayIncoming}`,
         error,
       );
     }

package/src/utils/internal/registerSDKGlobals.ts

@@ -50,6 +50,8 @@ const streamRNVideoSDKGlobals: StreamRNVideoSDKGlobals = {
   callManager: {
     setup: ({ defaultDevice, isRingingTypeCall }) => {
       if (shouldBypassForCallKit({ isRingingTypeCall })) {
+        // Forward the sticky preference; callingx reads it on next CallKit activation.
+        CallingxModule?.setDefaultAudioDeviceEndpointType(defaultDevice);
         return;
       }
       StreamInCallManagerNativeModule.setDefaultAudioDeviceEndpointType(

package/src/utils/push/android.ts

@@ -4,20 +4,12 @@ import {
   videoLoggerSystem,
 } from '@stream-io/video-client';
 import { AppState, Platform } from 'react-native';
-import type {
-  NonRingingPushEvent,
-  StreamVideoConfig,
-} from '../StreamVideoRN/types';
+import type { StreamVideoConfig } from '../StreamVideoRN/types';
 import {
   type FirebaseMessagingTypes,
-  getExpoNotificationsLib,
-  getExpoNotificationsLibNoThrow,
   getFirebaseMessagingLib,
   getFirebaseMessagingLibNoThrow,
-  getNotifeeLibThrowIfNotInstalledForPush,
-  type NotifeeLib,
 } from './libs';
-import { pushNonRingingCallData$ } from './internal/rxSubjects';
 import { pushUnsubscriptionCallbacks } from './internal/constants';
 import { canListenToWS, shouldCallBeClosed } from './internal/utils';
 import { setPushLogoutCallback } from '../internal/pushLogoutCallback';
@@ -26,12 +18,6 @@ import { getCallingxLib } from './libs/callingx';
 
 type PushConfig = NonNullable<StreamVideoConfig['push']>;
 
-type onBackgroundEventFunctionParams = Parameters<
-  NotifeeLib['default']['onBackgroundEvent']
->[0];
-
-type Event = Parameters<onBackgroundEventFunctionParams>[0];
-
 let lastFirebaseToken = { token: '', userId: '' };
 
 /** Send token to stream  */
@@ -73,24 +59,6 @@ export async function initAndroidPushToken(
     logger.debug(`sending firebase token: ${token} for userId: ${userId}`);
     await client.addDevice(token, 'firebase', push_provider_name);
   };
-  if (pushConfig.isExpo) {
-    const expoNotificationsLib = pushConfig.onTapNonRingingCallNotification
-      ? getExpoNotificationsLib()
-      : getExpoNotificationsLibNoThrow();
-    if (expoNotificationsLib) {
-      logger.debug(`setting expo notification token listeners`);
-      const subscription = expoNotificationsLib.addPushTokenListener(
-        (devicePushToken) => {
-          setDeviceToken(devicePushToken.data);
-        },
-      );
-      setUnsubscribeListener(() => subscription.remove());
-      const devicePushToken =
-        await expoNotificationsLib.getDevicePushTokenAsync();
-      const token = devicePushToken.data;
-      await setDeviceToken(token);
-    }
-  }
 
   const messaging = pushConfig.isExpo
     ? getFirebaseMessagingLibNoThrow(true)
@@ -193,6 +161,11 @@ export const firebaseDataHandler = async (
                   'debug',
                 );
                 callingx.endCallWithReason(call_cid, endCallReason);
+                callFromPush.leave({ reject: false }).catch((error) => {
+                  logger.error(
+                    `Failed to leave already-ended ringing call ${call_cid}: ${error}`,
+                  );
+                });
                 resolve(undefined);
                 return;
               }
@@ -323,90 +296,11 @@ export const firebaseDataHandler = async (
         `Removing incoming call notification immediately with callCid: ${call_cid} as it should be closed`,
       );
       callingx.endCallWithReason(call_cid, endCallReason);
+      callFromPush.leave({ reject: false }).catch((error) => {
+        logger.error(
+          `Failed to leave already-ended ringing call ${call_cid}: ${error}`,
+        );
+      });
     }
-  } else {
-    const notifeeLib = getNotifeeLibThrowIfNotInstalledForPush();
-    const notifee = notifeeLib.default;
-    const settings = await notifee.getNotificationSettings();
-    if (settings.authorizationStatus !== 1) {
-      logger.debug(
-        `Notification permission not granted, unable to post ${data.type} notifications`,
-      );
-      return;
-    }
-
-    // the other types are call.live_started and call.notification
-    const callChannel = pushConfig.android?.callChannel;
-    const callNotificationTextGetters =
-      pushConfig.android?.callNotificationTextGetters;
-    if (!callChannel || !callNotificationTextGetters) {
-      logger.debug(
-        "Can't show call notification as either or both callChannel and callNotificationTextGetters is not provided",
-      );
-      return;
-    }
-    await notifee.createChannel(callChannel);
-    const channelId = callChannel.id;
-    const { getTitle, getBody } = callNotificationTextGetters;
-    const createdUserName = data.created_by_display_name as string;
-    // we can safely cast to string because the data is from "stream.video"
-    const type = data.type as NonRingingPushEvent;
-
-    const title = getTitle(type, createdUserName);
-    const body = getBody(type, createdUserName);
-
-    logger.debug(
-      `Displaying NonRingingPushEvent ${type} notification with title: ${title} body: ${body}`,
-    );
-    await notifee.displayNotification({
-      title,
-      body,
-      data,
-      android: {
-        sound: callChannel.sound,
-        smallIcon: pushConfig.android?.smallIcon,
-        vibrationPattern: callChannel.vibrationPattern,
-        channelId,
-        importance: 4, // high importance
-        pressAction: {
-          id: 'default',
-          launchActivity: 'default', // open the app when the notification is pressed
-        },
-        timeoutAfter: 60000, // 60 seconds, after which the notification will be dismissed automatically
-      },
-    });
-    const cid = data.call_cid as string;
-    pushNonRingingCallData$.next({ cid, type });
-  }
-};
-
-export const onAndroidNotifeeEvent = async ({ event }: { event: Event }) => {
-  if (Platform.OS !== 'android') return;
-  const { type, detail } = event;
-  const { notification } = detail;
-  const notificationId = notification?.id;
-  const data = notification?.data;
-  const pushConfig = StreamVideoRN.getConfig().push;
-  if (
-    !pushConfig ||
-    !data ||
-    !notificationId ||
-    data.sender !== 'stream.video'
-  ) {
-    return;
-  }
-
-  // we can safely cast to string because the data is from "stream.video"
-  const call_cid = data.call_cid as string;
-
-  const notifeeLib = getNotifeeLibThrowIfNotInstalledForPush();
-  if (type === notifeeLib.EventType.PRESS) {
-    videoLoggerSystem
-      .getLogger('onAndroidNotifeeEvent')
-      .debug(`onTapNonRingingCallNotification with callCId: ${call_cid}`);
-    pushConfig.onTapNonRingingCallNotification?.(
-      call_cid,
-      data.type as NonRingingPushEvent,
-    );
   }
 };

package/src/utils/push/index.ts

@@ -1,3 +1,2 @@
 export * from './android';
-export * from './ios';
 export * from './utils';

package/src/utils/push/internal/utils.ts

@@ -4,11 +4,7 @@ import {
   StreamVideoClient,
   videoLoggerSystem,
 } from '@stream-io/video-client';
-import type {
-  NonRingingPushEvent,
-  StreamVideoConfig,
-} from '../../StreamVideoRN/types';
-import { onNewCallNotification } from '../../internal/newNotificationCallbacks';
+import type { StreamVideoConfig } from '../../StreamVideoRN/types';
 import { pushUnsubscriptionCallbacks } from './constants';
 import { AppState } from 'react-native';
 import type { EndCallReason } from '@stream-io/react-native-callingx';
@@ -162,42 +158,6 @@ export const processCallFromPushInBackground = async (
   }
 };
 
-/**
- * This function is used process the call from push notifications due to non ringing calls
- * It does the following steps:
- * 1. Get the call from the client if present or create a new call
- * 2. Fetch the latest state of the call from the server
- * 3. Call all the callbacks to inform the app about the call
- */
-export const processNonIncomingCallFromPush = async (
-  client: StreamVideoClient,
-  call_cid: string,
-  nonRingingNotificationType: NonRingingPushEvent,
-) => {
-  let callFromPush: Call;
-  try {
-    const _callFromPush = client.state.calls.find((c) => c.cid === call_cid);
-    if (_callFromPush) {
-      callFromPush = _callFromPush;
-    } else {
-      // if not it means that WS is not alive when receiving the push notifications and we need to fetch the call
-      const [callType, callId] = call_cid.split(':');
-      callFromPush = client.call(callType as string, callId as string);
-      await callFromPush.get();
-    }
-  } catch (e) {
-    const nonRingingCallLogger = videoLoggerSystem.getLogger(
-      'processNonIncomingCallFromPush',
-    );
-    nonRingingCallLogger.error(
-      'failed to fetch call from push notification',
-      e,
-    );
-    return;
-  }
-  onNewCallNotification(callFromPush, nonRingingNotificationType);
-};
-
 /**
  * This function is used to clear all the push related WS subscriptions
  * note: events are subscribed in push for accept/decline through WS

package/src/utils/push/libs/callingx.ts

@@ -52,6 +52,14 @@ export function extractCallingExpOptions(
     if (pushConfig.ios.enableOngoingCalls !== undefined) {
       iosOptions.enableOngoingCalls = pushConfig.ios.enableOngoingCalls;
     }
+    if (pushConfig.ios.skipIncomingPushInForeground !== undefined) {
+      iosOptions.skipIncomingPushInForeground =
+        pushConfig.ios.skipIncomingPushInForeground;
+    }
+    if (pushConfig.ios.defaultDeviceEndpointType !== undefined) {
+      iosOptions.defaultDeviceEndpointType =
+        pushConfig.ios.defaultDeviceEndpointType;
+    }
 
     if (Object.keys(iosOptions).length > 0) {
       callingExpOptions.ios = iosOptions;
@@ -72,6 +80,10 @@ export function extractCallingExpOptions(
     if (pushConfig.android.enableOngoingCalls !== undefined) {
       androidOptions.enableOngoingCalls = pushConfig.android.enableOngoingCalls;
     }
+    if (pushConfig.android.skipIncomingPushInForeground !== undefined) {
+      androidOptions.skipIncomingPushInForeground =
+        pushConfig.android.skipIncomingPushInForeground;
+    }
   }
 
   if (foregroundServiceConfig.android.channel) {

package/src/utils/push/libs/index.ts

@@ -1,7 +1,4 @@
-export * from './expoNotifications';
 export * from './firebaseMessaging';
-export * from './iosPushNotification';
-export * from './notifee';
 export * from './callingx';
 
 /*

package/src/utils/push/utils.ts

@@ -1,8 +1,5 @@
-import type { Event } from '@notifee/react-native';
 import type { FirebaseMessagingTypes } from './libs/firebaseMessaging';
-import type { ExpoNotification } from './libs/expoNotifications';
 import type { NonRingingPushEvent } from '../StreamVideoRN/types';
-import type { PushNotificationiOSType } from './libs/iosPushNotification';
 
 export type StreamPushPayload =
   | {
@@ -17,37 +14,3 @@ export function isFirebaseStreamVideoMessage(
 ) {
   return message.data?.sender === 'stream.video';
 }
-
-export function isNotifeeStreamVideoEvent(event: Event) {
-  const { detail } = event;
-  const { notification } = detail;
-  return notification?.data?.sender === 'stream.video';
-}
-
-export function isExpoNotificationStreamVideoEvent(event: ExpoNotification) {
-  const trigger = event.request.trigger;
-  if (
-    trigger &&
-    typeof trigger === 'object' &&
-    'type' in trigger &&
-    trigger.type === 'push'
-  ) {
-    // iOS
-    const streamPayload = trigger.payload?.stream as StreamPushPayload;
-    // Android
-    const remoteMessageData = trigger.remoteMessage?.data;
-    return (
-      streamPayload?.sender === 'stream.video' ||
-      remoteMessageData?.sender === 'stream.video'
-    );
-  }
-  return false;
-}
-
-export function isPushNotificationiOSStreamVideoEvent(
-  notification: PushNotificationiOSType,
-) {
-  const data = notification.getData();
-  const streamPayload = data?.stream as StreamPushPayload;
-  return streamPayload?.sender === 'stream.video';
-}

package/src/version.ts

@@ -1 +1 @@
-export const version = '1.34.0';
+export const version = '1.36.0';