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

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

@@ -1,9 +1,10 @@
-import { Platform } from 'react-native';
+import { AppState, NativeModules, Platform } from 'react-native';
+import { getCallKeepLib, getVoipPushNotificationLib } from '../libs';
+import { voipPushNotificationCallCId$ } from './rxSubjects';
 import { pushUnsubscriptionCallbacks } from './constants';
-import { canListenToWS, shouldCallBeClosed } from './utils';
+import { canAddPushWSSubscriptionsRef, shouldCallBeEnded } from './utils';
 import { StreamVideoConfig } from '../../StreamVideoRN/types';
 import { videoLoggerSystem } from '@stream-io/video-client';
-import { getCallingxLib } from '../libs/callingx';
 
 export const onVoipNotificationReceived = async (
   notification: any,
@@ -31,51 +32,71 @@ export const onVoipNotificationReceived = async (
         "version": "v2"
       }
     } */
-  const logger = videoLoggerSystem.getLogger('setupIosVoipPushEvents');
-
   const sender = notification?.stream?.sender;
   const type = notification?.stream?.type;
   // do not process any other notifications other than stream.video or ringing
   if (sender !== 'stream.video' && type !== 'call.ring') {
     return;
   }
-
   const call_cid = notification?.stream?.call_cid;
   if (!call_cid || Platform.OS !== 'ios' || !pushConfig.ios.pushProviderName) {
     return;
   }
-
-  const callingx = getCallingxLib();
-  if (callingx.isCallRegistered(call_cid)) {
-    //same call_cid is registered, so we skipping the notification
-    logger.debug(
-      `the same call_cid ${call_cid} is registered, skipping the call.ring notification`,
-    );
-    return;
-  }
-
+  const logger = videoLoggerSystem.getLogger('setupIosVoipPushEvents');
   const client = await pushConfig.createStreamVideoClient();
+
   if (!client) {
     logger.debug(
       'client not found, not processing call.ring voip push notification',
     );
     return;
   }
-
+  const shouldRejectCallWhenBusy = client['rejectCallWhenBusy'] ?? false;
+  if (shouldRejectCallWhenBusy) {
+    // inform the iOS native module that we should reject call when busy
+    NativeModules.StreamVideoReactNative.setShouldRejectCallWhenBusy(
+      shouldRejectCallWhenBusy,
+    );
+  }
   const callFromPush = await client.onRingingCall(call_cid);
-
+  let uuid = '';
+  try {
+    uuid =
+      await NativeModules?.StreamVideoReactNative?.getIncomingCallUUid(
+        call_cid,
+      );
+  } catch (error) {
+    logger.error('Error in getting call uuid from native module', error);
+  }
+  if (!uuid) {
+    logger.error(
+      `Not processing call.ring push notification, as no uuid found for call_cid: ${call_cid}`,
+    );
+    return;
+  }
+  const created_by_id = notification?.stream?.created_by_id;
+  const receiver_id = notification?.stream?.receiver_id;
   function closeCallIfNecessary() {
-    const mustEndCall = shouldCallBeClosed(callFromPush, notification?.stream);
+    const { mustEndCall, callkeepReason } = shouldCallBeEnded(
+      callFromPush,
+      created_by_id,
+      receiver_id,
+    );
     if (mustEndCall) {
-      logger.debug(`callkeep.reportEndCallWithUUID for call_cid: ${call_cid}`);
-      //TODO: think about sending appropriate reason for end call
-      callingx.endCallWithReason(call_cid, 'local');
+      const callkeep = getCallKeepLib();
+      logger.debug(
+        `callkeep.reportEndCallWithUUID for uuid: ${uuid}, call_cid: ${call_cid}, reason: ${callkeepReason}`,
+      );
+      callkeep.reportEndCallWithUUID(uuid, callkeepReason);
+      const voipPushNotification = getVoipPushNotificationLib();
+      voipPushNotification.onVoipNotificationCompleted(uuid);
       return true;
     }
     return false;
   }
-
   const closed = closeCallIfNecessary();
+  const canListenToWS = () =>
+    canAddPushWSSubscriptionsRef.current && AppState.currentState !== 'active';
   if (!closed && canListenToWS()) {
     const unsubscribe = callFromPush.on('all', (event) => {
       const _canListenToWS = canListenToWS();
@@ -100,10 +121,10 @@ export const onVoipNotificationReceived = async (
     pushUnsubscriptionCallbacks.get(call_cid)?.forEach((cb) => cb());
     pushUnsubscriptionCallbacks.set(call_cid, [unsubscribe]);
   }
-
   // send the info to this subject, it is listened by callkeep events
   // callkeep events will then accept/reject the call
   logger.debug(
-    `call_cid:${call_cid} received and processed from call.ring push notification`,
+    `call_cid:${call_cid} uuid:${uuid} received and processed from call.ring push notification`,
   );
+  voipPushNotificationCallCId$.next(call_cid);
 };

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

@@ -40,3 +40,32 @@ export const pushAndroidBackgroundDeliveredIncomingCallCId$ =
 export const pushRejectedIncomingCallCId$ = new BehaviorSubject<
   string | undefined
 >(undefined);
+
+/**
+ * This rxjs subject is used to store the call cid of the incoming call from ios voip pushkit notification
+ */
+export const voipPushNotificationCallCId$ = new BehaviorSubject<
+  string | undefined
+>(undefined);
+
+/** The pair of cid of a call and its corresponding uuid created in the native side */
+type CallkeepMap = {
+  uuid: string;
+  cid: string;
+};
+
+/*
+ * This rxjs subject should only used to store the CallkeepMap
+ * for the incoming call when on foreground
+ * or in other words, when we get didDisplayIncomingCall from callkeep lib
+ */
+export const voipCallkeepCallOnForegroundMap$ = new BehaviorSubject<
+  CallkeepMap | undefined
+>(undefined);
+
+/*
+ * This rxjs subject should only used to store the CallkeepMap when it was accepted in the native dialer
+ */
+export const voipCallkeepAcceptedCallOnNativeDialerMap$ = new BehaviorSubject<
+  CallkeepMap | undefined
+>(undefined);

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

@@ -10,7 +10,6 @@ import type {
 } from '../../StreamVideoRN/types';
 import { onNewCallNotification } from '../../internal/newNotificationCallbacks';
 import { pushUnsubscriptionCallbacks } from './constants';
-import { AppState } from 'react-native';
 
 type PushConfig = NonNullable<StreamVideoConfig['push']>;
 
@@ -123,16 +122,6 @@ export const processCallFromPush = async (
         .debug(
           `joining call from push notification with callCid: ${callFromPush.cid}`,
         );
-
-      if (callFromPush.state.callingState === CallingState.JOINED) {
-        videoLoggerSystem
-          .getLogger('processCallFromPush')
-          .debug(
-            `call already joined from push notification with callCid: ${callFromPush.cid}`,
-          );
-        return;
-      }
-
       await callFromPush.join();
     } else if (action === 'decline') {
       const canReject =
@@ -202,17 +191,3 @@ export const clearPushWSEventSubscriptions = (call_cid: string) => {
 export const canAddPushWSSubscriptionsRef: CanAddPushWSSubscriptionsRef = {
   current: true,
 };
-
-export const canListenToWS = () =>
-  canAddPushWSSubscriptionsRef.current && AppState.currentState !== 'active';
-
-export const shouldCallBeClosed = (
-  call: Call,
-  pushData: { [key: string]: string | object },
-) => {
-  const created_by_id = pushData?.created_by_id as string;
-  const receiver_id = pushData?.receiver_id as string;
-
-  const { mustEndCall } = shouldCallBeEnded(call, created_by_id, receiver_id);
-  return mustEndCall;
-};

package/src/utils/push/ios.ts

@@ -62,7 +62,12 @@ export const oniOSExpoNotificationEvent = (event: ExpoNotification) => {
   }
 };
 
-export const oniOSNotifeeEvent = ({ event }: { event: Event }) => {
+export const oniOSNotifeeEvent = ({
+  event,
+}: {
+  event: Event;
+  isBackground: boolean;
+}) => {
   if (Platform.OS !== 'ios') return;
   const pushConfig = StreamVideoRN.getConfig().push;
   const { type, detail } = event;

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

@@ -0,0 +1,16 @@
+export type RNCallKeepType = typeof import('react-native-callkeep').default;
+
+let callkeep: RNCallKeepType | undefined;
+
+try {
+  callkeep = require('react-native-callkeep').default;
+} catch {}
+
+export function getCallKeepLib() {
+  if (!callkeep) {
+    throw Error(
+      'react-native-callkeep library is not installed. Please see https://github.com/react-native-webrtc/react-native-callkeep#Installation for installation instructions',
+    );
+  }
+  return callkeep;
+}

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

@@ -1,8 +1,9 @@
 export * from './expoNotifications';
 export * from './firebaseMessaging';
 export * from './iosPushNotification';
+export * from './voipPushNotification';
+export * from './callkeep';
 export * from './notifee';
-export * from './callingx';
 
 /*
     NOTE: must keep each libs in different files

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

@@ -1,4 +1,6 @@
+import { PermissionsAndroid } from 'react-native';
 import { lib, type Type } from './lib';
+import { videoLoggerSystem } from '@stream-io/video-client';
 
 export type NotifeeLib = Type;
 
@@ -34,9 +36,34 @@ export function getNotifeeLibThrowIfNotInstalledForPush() {
 }
 
 export function getNotifeeLibNoThrowForKeepCallAlive() {
+  if (!lib) {
+    const logger = videoLoggerSystem.getLogger('getNotifeeLibNoThrow');
+    logger.info(
+      `${'@notifee/react-native library not installed. It is required to keep call alive in the background for Android. '}${INSTALLATION_INSTRUCTION}`,
+    );
+  }
   return lib;
 }
 
+export async function getKeepCallAliveForegroundServiceTypes() {
+  const types: AndroidForegroundServiceType[] = [
+    AndroidForegroundServiceType.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK,
+  ];
+  const hasCameraPermission = await PermissionsAndroid.check(
+    PermissionsAndroid.PERMISSIONS.CAMERA!,
+  );
+  if (hasCameraPermission) {
+    types.push(AndroidForegroundServiceType.FOREGROUND_SERVICE_TYPE_CAMERA);
+  }
+  const hasMicrophonePermission = await PermissionsAndroid.check(
+    PermissionsAndroid.PERMISSIONS.RECORD_AUDIO!,
+  );
+  if (hasMicrophonePermission) {
+    types.push(AndroidForegroundServiceType.FOREGROUND_SERVICE_TYPE_MICROPHONE);
+  }
+  return types;
+}
+
 export function getIncomingCallForegroundServiceTypes() {
   const types: AndroidForegroundServiceType[] = [
     AndroidForegroundServiceType.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE,

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

@@ -0,0 +1,17 @@
+export type VoipPushNotificationType =
+  typeof import('react-native-voip-push-notification').default;
+
+let voipPushNotification: VoipPushNotificationType | undefined;
+
+try {
+  voipPushNotification = require('react-native-voip-push-notification').default;
+} catch {}
+
+export function getVoipPushNotificationLib() {
+  if (!voipPushNotification) {
+    throw Error(
+      "react-native-voip-push-notification library is not installed. Please install it using 'yarn add react-native-voip-push-notification' or 'npm i react-native-voip-push-notification --save'",
+    );
+  }
+  return voipPushNotification;
+}

package/src/utils/push/setupIosCallKeepEvents.ts

@@ -0,0 +1,252 @@
+import {
+  pushAcceptedIncomingCallCId$,
+  voipCallkeepAcceptedCallOnNativeDialerMap$,
+  voipCallkeepCallOnForegroundMap$,
+  voipPushNotificationCallCId$,
+} from './internal/rxSubjects';
+import { RxUtils, videoLoggerSystem } from '@stream-io/video-client';
+import { getCallKeepLib, getVoipPushNotificationLib } from './libs';
+import type { StreamVideoConfig } from '../StreamVideoRN/types';
+import {
+  clearPushWSEventSubscriptions,
+  processCallFromPushInBackground,
+} from './internal/utils';
+import { AppState, NativeModules, Platform } from 'react-native';
+import { RTCAudioSession } from '@stream-io/react-native-webrtc';
+import { setPushLogoutCallback } from '../internal/pushLogoutCallback';
+
+type PushConfig = NonNullable<StreamVideoConfig['push']>;
+
+/**
+ * This hook is used to listen to callkeep events and do the necessary actions
+ */
+export function setupIosCallKeepEvents(
+  pushConfig: NonNullable<StreamVideoConfig['push']>,
+) {
+  if (Platform.OS !== 'ios' || !pushConfig.ios.pushProviderName) {
+    return;
+  }
+  if (!pushConfig.android.incomingCallChannel) {
+    // TODO: remove this check and find a better way once we have telecom integration for android
+    videoLoggerSystem
+      .getLogger('setupIosCallKeepEvents')
+      .debug(
+        'android incomingCallChannel is not defined, so skipping the setupIosCallKeepEvents',
+      );
+    return;
+  }
+  const logger = videoLoggerSystem.getLogger('setupIosCallKeepEvents');
+  const callkeep = getCallKeepLib();
+
+  async function getCallCid(callUUID: string): Promise<string | undefined> {
+    try {
+      const call_cid =
+        await NativeModules.StreamVideoReactNative.getIncomingCallCid(callUUID);
+      // in a case that voipPushNotificationCallCId$ is empty (this should not happen as voipPushNotificationCallCId$ is updated in push reception)]
+      // update it with this call_cid
+      const voipPushNotificationCallCId = RxUtils.getCurrentValue(
+        voipPushNotificationCallCId$,
+      );
+      if (!voipPushNotificationCallCId) {
+        logger.debug(
+          `voipPushNotificationCallCId$ is empty, updating it with the call_cid: ${call_cid} for callUUID: ${callUUID}`,
+        );
+        voipPushNotificationCallCId$.next(call_cid);
+      }
+      return call_cid;
+    } catch {
+      logger.debug(
+        `Error in getting call cid from native module for callUUID: ${callUUID} - probably the call was already processed, so ignoring this callkeep event`,
+      );
+    }
+    return undefined;
+  }
+
+  function answerCall(callUUID: string) {
+    getCallCid(callUUID).then((call_cid) => {
+      logger.debug(`answerCall event with call_cid: ${call_cid}`);
+      iosCallkeepAcceptCall(call_cid, callUUID);
+    });
+  }
+
+  function endCall(callUUID: string) {
+    getCallCid(callUUID).then((call_cid) => {
+      logger.debug(`endCall event with call_cid: ${call_cid}`);
+      iosCallkeepRejectCall(call_cid, callUUID, pushConfig!);
+    });
+  }
+
+  /**
+   * CallKeep / CallKit audio-session events -> WebRTC (iOS)
+   *
+   * iOS CallKit is the authority that *activates* and *deactivates* the underlying `AVAudioSession`
+   * when a call is answered/ended from the system UI (lock screen, Call UI, Bluetooth, etc).
+   *
+   * WebRTC on iOS wraps `AVAudioSession` with `RTCAudioSession` and its AudioDeviceModule relies on
+   * being notified of those lifecycle transitions to correctly start/stop audio I/O and keep its
+   * internal activation state consistent (e.g. activation count, playout/recording start).
+   *
+   * If these callbacks don’t reach WebRTC, answering via the native dialer UI can result in:
+   * - no microphone capture / one-way audio
+   * - silent playout until the app forces an audio reconfiguration
+   * - flaky audio routing (speaker/earpiece/Bluetooth) across subsequent calls
+   *
+   * We forward CallKeep’s `didActivateAudioSession` / `didDeactivateAudioSession` events to WebRTC’s
+   * `RTCAudioSession.audioSessionDidActivate()` / `audioSessionDidDeactivate()` methods.
+   */
+  function didActivateAudioSession() {
+    logger.debug('didActivateAudioSession');
+    RTCAudioSession.audioSessionDidActivate();
+  }
+
+  function didDeactivateAudioSession() {
+    logger.debug('didDeactivateAudioSession');
+    RTCAudioSession.audioSessionDidDeactivate();
+  }
+
+  function didDisplayIncomingCall(callUUID: string, payload: object) {
+    const voipPushNotification = getVoipPushNotificationLib();
+    // @ts-expect-error - call_cid is not part of RNCallKeepEventPayload
+    const call_cid = payload?.call_cid as string | undefined;
+    logger.debug(
+      `didDisplayIncomingCall event with callUUID: ${callUUID} call_cid: ${call_cid}`,
+    );
+    if (call_cid) {
+      if (AppState.currentState === 'background') {
+        processCallFromPushInBackground(
+          pushConfig!,
+          call_cid,
+          'backgroundDelivered',
+        );
+      }
+      voipCallkeepCallOnForegroundMap$.next({
+        uuid: callUUID,
+        cid: call_cid,
+      });
+    }
+    voipPushNotification.onVoipNotificationCompleted(callUUID);
+  }
+
+  const { remove: removeAnswerCall } = callkeep.addEventListener(
+    'answerCall',
+    ({ callUUID }) => {
+      answerCall(callUUID);
+    },
+  );
+  const { remove: removeEndCall } = callkeep.addEventListener(
+    'endCall',
+    ({ callUUID }) => {
+      endCall(callUUID);
+    },
+  );
+
+  const { remove: removeDisplayIncomingCall } = callkeep.addEventListener(
+    'didDisplayIncomingCall',
+    ({ callUUID, payload }) => {
+      didDisplayIncomingCall(callUUID, payload);
+    },
+  );
+
+  const { remove: removeDidActivateAudioSession } = callkeep.addEventListener(
+    'didActivateAudioSession',
+    () => {
+      didActivateAudioSession();
+    },
+  );
+
+  const { remove: removeDidDeactivateAudioSession } = callkeep.addEventListener(
+    'didDeactivateAudioSession',
+    () => {
+      didDeactivateAudioSession();
+    },
+  );
+
+  const { remove: removeDidLoadWithEvents } = callkeep.addEventListener(
+    'didLoadWithEvents',
+    (events) => {
+      if (!events || !Array.isArray(events) || events.length < 1) {
+        return;
+      }
+
+      events.forEach((event) => {
+        const { name, data } = event;
+        if (name === 'RNCallKeepDidDisplayIncomingCall') {
+          didDisplayIncomingCall(data.callUUID, data.payload);
+        } else if (name === 'RNCallKeepPerformAnswerCallAction') {
+          answerCall(data.callUUID);
+        } else if (name === 'RNCallKeepPerformEndCallAction') {
+          endCall(data.callUUID);
+        } else if (name === 'RNCallKeepDidActivateAudioSession') {
+          didActivateAudioSession();
+        } else if (name === 'RNCallKeepDidDeactivateAudioSession') {
+          didDeactivateAudioSession();
+        }
+      });
+    },
+  );
+
+  setPushLogoutCallback(async () => {
+    removeAnswerCall();
+    removeEndCall();
+    removeDisplayIncomingCall();
+    removeDidActivateAudioSession();
+    removeDidDeactivateAudioSession();
+    removeDidLoadWithEvents();
+  });
+}
+
+const iosCallkeepAcceptCall = (
+  call_cid: string | undefined,
+  callUUIDFromCallkeep: string,
+) => {
+  if (!shouldProcessCallFromCallkeep(call_cid, callUUIDFromCallkeep)) {
+    return;
+  }
+  clearPushWSEventSubscriptions(call_cid);
+  // to call end callkeep later if ended in app and not through callkeep
+  voipCallkeepAcceptedCallOnNativeDialerMap$.next({
+    uuid: callUUIDFromCallkeep,
+    cid: call_cid,
+  });
+  // to process the call in the app
+  pushAcceptedIncomingCallCId$.next(call_cid);
+  // no need to keep these references anymore
+  voipCallkeepCallOnForegroundMap$.next(undefined);
+};
+
+const iosCallkeepRejectCall = async (
+  call_cid: string | undefined,
+  callUUIDFromCallkeep: string,
+  pushConfig: PushConfig,
+) => {
+  if (!shouldProcessCallFromCallkeep(call_cid, callUUIDFromCallkeep)) {
+    return;
+  }
+  clearPushWSEventSubscriptions(call_cid);
+  // remove the references if the call_cid matches
+  const voipPushNotificationCallCId = RxUtils.getCurrentValue(
+    voipPushNotificationCallCId$,
+  );
+  if (voipPushNotificationCallCId === call_cid) {
+    voipCallkeepAcceptedCallOnNativeDialerMap$.next(undefined);
+    voipCallkeepCallOnForegroundMap$.next(undefined);
+    voipPushNotificationCallCId$.next(undefined);
+  }
+
+  await processCallFromPushInBackground(pushConfig, call_cid, 'decline');
+  await NativeModules.StreamVideoReactNative?.removeIncomingCall(call_cid);
+};
+
+/**
+ * Helper function to determine if the answer/end call event from callkeep must be processed
+ * Just checks if we have a valid call_cid and acts as a type guard for call_cid
+ */
+const shouldProcessCallFromCallkeep = (
+  call_cid: string | undefined,
+  callUUIDFromCallkeep: string,
+): call_cid is string => {
+  if (!call_cid || !callUUIDFromCallkeep) {
+    return false;
+  }
+  return true;
+};

package/src/utils/push/setupIosVoipPushEvents.ts

@@ -1,11 +1,10 @@
-// import { getVoipPushNotificationLib } from './libs';
+import { getVoipPushNotificationLib } from './libs';
 
 import { Platform } from 'react-native';
 import { onVoipNotificationReceived } from './internal/ios';
 import { setPushLogoutCallback } from '../internal/pushLogoutCallback';
 import { StreamVideoConfig } from '../StreamVideoRN/types';
 import { videoLoggerSystem } from '@stream-io/video-client';
-import { getCallingxLib } from './libs';
 
 export function setupIosVoipPushEvents(
   pushConfig: NonNullable<StreamVideoConfig['push']>,
@@ -21,19 +20,16 @@ export function setupIosVoipPushEvents(
     );
     return;
   }
+  const voipPushNotification = getVoipPushNotificationLib();
 
-  const callingx = getCallingxLib();
-  const voipNotificationReceivedListener = callingx.addEventListener(
-    'voipNotificationReceived',
-    (params) => {
-      onVoipNotificationReceived(params, pushConfig);
-    },
-  );
-
+  logger.debug('notification event listener added');
+  voipPushNotification.addEventListener('notification', (notification) => {
+    onVoipNotificationReceived(notification, pushConfig);
+  });
   setPushLogoutCallback(async () => {
     videoLoggerSystem
       .getLogger('setPushLogoutCallback')
       .debug('notification event listener removed');
-    voipNotificationReceivedListener.remove();
+    voipPushNotification.removeEventListener('notification');
   });
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = '1.29.0-beta.1';
+export const version = '1.29.0';

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

@@ -1,83 +0,0 @@
-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
-        }
-    }
-}
-