@stream-io/react-native-callingx 0.1.0-beta.0

package/src/CallingxModule.ts

@@ -0,0 +1,321 @@
+import { Platform } from 'react-native';
+import NativeCallingModule from './spec/NativeCallingx';
+import {
+  checkCallPermissions,
+  requestCallPermissions,
+} from './utils/permissions';
+import type { PermissionsResult } from './utils/permissions';
+import {
+  HEADLESS_TASK_NAME,
+  registerHeadlessTask,
+  setHeadlessTask,
+} from './utils/headlessTask';
+import type { ManagableTask } from './utils/headlessTask';
+import { EventManager } from './EventManager';
+import type { EventListener } from './EventManager';
+import {
+  type ICallingxModule,
+  type InfoDisplayOptions,
+  type TextTransformer,
+  type EndCallReason,
+  type EventData,
+  type EventName,
+  type EventParams,
+  type CallingExpOptions,
+  type VoipEventName,
+  type VoipEventParams,
+  type VoipEventData,
+} from './types';
+import {
+  androidEndCallReasonMap,
+  defaultAndroidOptions,
+  defaultiOSOptions,
+  defaultTextTransformer,
+  iosEndCallReasonMap,
+} from './utils/constants';
+import { isVoipEvent } from './utils/utils';
+
+class CallingxModule implements ICallingxModule {
+  private _isNotificationsAllowed = false;
+  private _isSetup = false;
+  private _isOngoingCallsEnabled = false;
+  private _isHeadlessTaskRegistered = false;
+
+  private titleTransformer: TextTransformer = (text: string) => text;
+  private subtitleTransformer: TextTransformer | undefined = undefined;
+
+  private eventManager: EventManager<EventName, EventParams> =
+    new EventManager();
+  private voipEventManager: EventManager<VoipEventName, VoipEventParams> =
+    new EventManager();
+
+  get isNotificationsAllowed(): boolean {
+    if (Platform.OS !== 'android') {
+      return true;
+    }
+
+    return (
+      this._isNotificationsAllowed && NativeCallingModule.canPostNotifications()
+    );
+  }
+
+  get isOngoingCallsEnabled(): boolean {
+    return this._isOngoingCallsEnabled;
+  }
+
+  get isSetup(): boolean {
+    return this._isSetup;
+  }
+
+  setup(options: CallingExpOptions): void {
+    if (this._isSetup) {
+      return;
+    }
+
+    this._isOngoingCallsEnabled = options.enableOngoingCalls ?? false;
+    this.setShouldRejectCallWhenBusy(options.shouldRejectCallWhenBusy ?? false);
+
+    if (Platform.OS === 'ios') {
+      NativeCallingModule.setupiOS({ ...defaultiOSOptions, ...options.ios });
+    }
+
+    if (Platform.OS === 'android') {
+      const {
+        titleTransformer,
+        subtitleTransformer,
+        incomingChannel,
+        ongoingChannel,
+      } = options.android ?? {};
+
+      this.titleTransformer = titleTransformer ?? defaultTextTransformer;
+      this.subtitleTransformer = subtitleTransformer;
+
+      const notificationsConfig = {
+        incomingChannel: {
+          ...defaultAndroidOptions.incomingChannel,
+          ...(incomingChannel ?? {}),
+        },
+        ongoingChannel: {
+          ...defaultAndroidOptions.ongoingChannel,
+          ...(ongoingChannel ?? {}),
+        },
+      };
+
+      if (
+        notificationsConfig.incomingChannel.id ===
+        notificationsConfig.ongoingChannel.id
+      ) {
+        throw new Error('Incoming and outgoing channel IDs cannot be the same');
+      }
+
+      NativeCallingModule.setupAndroid(notificationsConfig);
+
+      registerHeadlessTask();
+    }
+
+    this._isSetup = true;
+  }
+
+  setShouldRejectCallWhenBusy(shouldReject: boolean): void {
+    NativeCallingModule.setShouldRejectCallWhenBusy(shouldReject);
+  }
+
+  async requestPermissions(): Promise<PermissionsResult> {
+    const result: {
+      recordAudio: boolean;
+      postNotifications: boolean;
+    } = await requestCallPermissions();
+
+    this._isNotificationsAllowed = result.postNotifications;
+    return result;
+  }
+
+  async checkPermissions(): Promise<PermissionsResult> {
+    const result: {
+      recordAudio: boolean;
+      postNotifications: boolean;
+    } = await checkCallPermissions();
+
+    this._isNotificationsAllowed = result.postNotifications;
+    return result;
+  }
+
+  getInitialEvents(): EventData[] {
+    return NativeCallingModule.getInitialEvents() as EventData[];
+  }
+
+  getInitialVoipEvents(): VoipEventData[] {
+    return NativeCallingModule.getInitialVoipEvents() as VoipEventData[];
+  }
+
+  //activates call that was registered with the telecom stack
+  setCurrentCallActive(callId: string): Promise<void> {
+    return NativeCallingModule.setCurrentCallActive(callId);
+  }
+
+  displayIncomingCall(
+    callId: string,
+    phoneNumber: string,
+    callerName: string,
+    hasVideo: boolean,
+  ): Promise<void> {
+    const displayOptions: InfoDisplayOptions = {
+      displayTitle: this.titleTransformer(callerName, true),
+      displaySubtitle: this.subtitleTransformer?.(phoneNumber, true),
+    };
+    return NativeCallingModule.displayIncomingCall(
+      callId,
+      phoneNumber,
+      callerName,
+      hasVideo,
+      displayOptions,
+    );
+  }
+
+  answerIncomingCall(callId: string): Promise<void> {
+    return NativeCallingModule.answerIncomingCall(callId);
+  }
+
+  //registers call with the telecom stack
+  startCall(
+    callId: string,
+    phoneNumber: string,
+    callerName: string,
+    hasVideo: boolean,
+  ): Promise<void> {
+    const displayOptions: InfoDisplayOptions = {
+      displayTitle: this.titleTransformer(callerName, false),
+      displaySubtitle: this.subtitleTransformer?.(phoneNumber, false),
+    };
+    return NativeCallingModule.startCall(
+      callId,
+      phoneNumber,
+      callerName,
+      hasVideo,
+      displayOptions,
+    );
+  }
+
+  updateDisplay(
+    callId: string,
+    phoneNumber: string,
+    callerName: string,
+  ): Promise<void> {
+    const displayOptions: InfoDisplayOptions = {
+      displayTitle: this.titleTransformer(callerName, false), //adjust incoming or outgoing call
+      displaySubtitle: this.subtitleTransformer?.(phoneNumber, false), //adjust incoming or outgoing call
+    };
+    return NativeCallingModule.updateDisplay(
+      callId,
+      phoneNumber,
+      callerName,
+      displayOptions,
+    );
+  }
+
+  endCallWithReason(callId: string, reason: EndCallReason): Promise<void> {
+    const reasons =
+      Platform.OS === 'ios' ? iosEndCallReasonMap : androidEndCallReasonMap;
+
+    if (Platform.OS === 'ios' && reason === 'local') {
+      return NativeCallingModule.endCall(callId);
+    }
+
+    return NativeCallingModule.endCallWithReason(callId, reasons[reason]);
+  }
+
+  isCallRegistered(callId: string): boolean {
+    return NativeCallingModule.isCallRegistered(callId);
+  }
+
+  hasRegisteredCall(): boolean {
+    return NativeCallingModule.hasRegisteredCall();
+  }
+
+  setMutedCall(callId: string, isMuted: boolean): Promise<void> {
+    return NativeCallingModule.setMutedCall(callId, isMuted);
+  }
+
+  setOnHoldCall(callId: string, isOnHold: boolean): Promise<void> {
+    return NativeCallingModule.setOnHoldCall(callId, isOnHold);
+  }
+
+  registerBackgroundTask(taskProvider: ManagableTask): void {
+    const stopTask = () => {
+      this._isHeadlessTaskRegistered = false;
+      NativeCallingModule.stopBackgroundTask(HEADLESS_TASK_NAME);
+    };
+
+    setHeadlessTask((taskData: any) => taskProvider(taskData, stopTask));
+
+    this._isHeadlessTaskRegistered = true;
+    NativeCallingModule.registerBackgroundTaskAvailable();
+  }
+
+  async startBackgroundTask(taskProvider?: ManagableTask): Promise<void> {
+    // If taskProvider is provided, register it first
+    if (taskProvider) {
+      this.registerBackgroundTask(taskProvider);
+    }
+
+    // Check if task is registered
+    if (!this._isHeadlessTaskRegistered) {
+      throw new Error(
+        'Background task not registered. Call registerBackgroundTask first.',
+      );
+    }
+
+    // Check if service is started (Android only)
+    if (Platform.OS === 'android') {
+      const isServiceStarted = await NativeCallingModule.isServiceStarted();
+      if (!isServiceStarted) {
+        throw new Error(
+          'Service is not started. Call displayIncomingCall or startCall first.',
+        );
+      }
+    }
+
+    return NativeCallingModule.startBackgroundTask(HEADLESS_TASK_NAME, 0);
+  }
+
+  stopBackgroundTask(): Promise<void> {
+    this._isHeadlessTaskRegistered = false;
+    return NativeCallingModule.stopBackgroundTask(HEADLESS_TASK_NAME);
+  }
+
+  registerVoipToken(): void {
+    NativeCallingModule.registerVoipToken();
+  }
+
+  addEventListener<T extends EventName | VoipEventName>(
+    eventName: T,
+    callback: EventListener<
+      T extends EventName
+        ? EventParams[T]
+        : T extends VoipEventName
+          ? VoipEventParams[T]
+          : never
+    >,
+  ): { remove: () => void } {
+    type ManagerType = EventManager<EventName | VoipEventName, any>;
+
+    const manager: ManagerType = (
+      isVoipEvent(eventName) ? this.voipEventManager : this.eventManager
+    ) as ManagerType;
+
+    manager.addListener(eventName, callback as any);
+
+    return {
+      remove: () => {
+        manager.removeListener(eventName, callback as any);
+      },
+    };
+  }
+
+  log(message: string, level: 'debug' | 'info' | 'warn' | 'error'): void {
+    NativeCallingModule.log(message, level);
+  }
+}
+
+const module = new CallingxModule();
+export default module;

package/src/EventManager.ts

@@ -0,0 +1,61 @@
+import type { EventSubscription } from 'react-native';
+import NativeCallingModule from './spec/NativeCallingx';
+import type {
+  EventData,
+  EventName,
+  VoipEventData,
+  VoipEventName,
+} from './types';
+import { isVoipEvent } from './utils/utils';
+
+type EventListener<T> = (params: T) => void;
+
+class EventManager<Name extends EventName | VoipEventName, Params> {
+  private listenersCount: number = 0;
+  private eventListeners: Map<Name, EventListener<Params>[]> = new Map();
+  private subscription: EventSubscription | null = null;
+
+  addListener<T extends Name>(
+    eventName: T,
+    callback: EventListener<Params>,
+  ): void {
+    const listeners = this.eventListeners.get(eventName) || [];
+    listeners.push(callback as EventListener<Params>);
+    this.eventListeners.set(eventName, listeners);
+    this.listenersCount++;
+
+    if (this.subscription === null) {
+      const eventHandler = (event: EventData | VoipEventData) => {
+        const eventListeners =
+          this.eventListeners.get(event.eventName as Name) || [];
+        eventListeners.forEach((listener) => listener(event.params as Params));
+      };
+
+      if (isVoipEvent(eventName)) {
+        this.subscription = NativeCallingModule.onNewVoipEvent(eventHandler);
+      } else {
+        this.subscription = NativeCallingModule.onNewEvent(eventHandler);
+      }
+    }
+  }
+
+  removeListener<T extends Name>(
+    eventName: T,
+    callback: EventListener<Params>,
+  ): void {
+    const listeners = this.eventListeners.get(eventName) || [];
+    const updatedListeners = listeners.filter((c) => c !== callback);
+    this.eventListeners.set(eventName, updatedListeners);
+
+    if (updatedListeners.length !== listeners.length) {
+      this.listenersCount--;
+    }
+
+    if (this.listenersCount === 0) {
+      this.subscription?.remove();
+      this.subscription = null;
+    }
+  }
+}
+
+export { EventManager, type EventListener };

package/src/index.ts

@@ -0,0 +1,2 @@
+export { default as CallingxModule } from './CallingxModule';
+export * from './types';

package/src/spec/NativeCallingx.ts

@@ -0,0 +1,176 @@
+import { TurboModuleRegistry, type TurboModule } from 'react-native';
+
+// @ts-expect-error - CodegenTypes is not properly typed
+import type { EventEmitter } from 'react-native/Libraries/Types/CodegenTypes';
+
+export interface Spec extends TurboModule {
+  setupiOS(options: {
+    supportsVideo: boolean;
+    maximumCallsPerCallGroup: number;
+    maximumCallGroups: number;
+    handleType: string;
+    sound: string | null;
+    imageName: string | null;
+    callsHistory: boolean;
+    displayCallTimeout: number;
+  }): void;
+
+  setupAndroid(options: {
+    incomingChannel: {
+      id: string;
+      name: string;
+      sound: string;
+      vibration: boolean;
+    };
+    ongoingChannel: {
+      id: string;
+      name: string;
+    };
+  }): void;
+
+  setShouldRejectCallWhenBusy(shouldReject: boolean): void;
+
+  canPostNotifications(): boolean;
+
+  getInitialEvents(): Array<{
+    eventName: string;
+    params: {
+      callId: string;
+      cause?: string;
+      muted?: boolean;
+      hold?: boolean;
+      source?: string;
+    };
+  }>;
+
+  getInitialVoipEvents(): Array<{
+    eventName: string;
+    params: {
+      token?: string;
+      aps?: {
+        'thread-id': string;
+        'mutable-content': number;
+        alert: {
+          title: string;
+        };
+        category: string;
+        sound: string;
+      };
+      stream?: {
+        sender: string;
+        created_by_id: string;
+        body: string;
+        title: string;
+        call_display_name: string;
+        created_by_display_name: string;
+        version: string;
+        type: string;
+        receiver_id: string;
+        call_cid: string;
+        video: string;
+      };
+    };
+  }>;
+
+  setCurrentCallActive(callId: string): Promise<void>;
+
+  displayIncomingCall(
+    callId: string,
+    phoneNumber: string,
+    callerName: string,
+    hasVideo: boolean,
+    displayOptions?: {
+      displayTitle?: string;
+      displaySubtitle?: string;
+    },
+  ): Promise<void>;
+
+  //use when need to answer an incoming call withing app UI
+  answerIncomingCall(callId: string): Promise<void>;
+
+  startCall(
+    callId: string,
+    phoneNumber: string,
+    callerName: string,
+    hasVideo: boolean,
+    displayOptions?: {
+      displayTitle?: string;
+      displaySubtitle?: string;
+    },
+  ): Promise<void>;
+
+  updateDisplay(
+    callId: string,
+    phoneNumber: string,
+    callerName: string,
+    displayOptions?: {
+      displayTitle?: string;
+      displaySubtitle?: string;
+    },
+  ): Promise<void>;
+
+  isCallRegistered(callId: string): boolean;
+
+  hasRegisteredCall(): boolean;
+
+  endCallWithReason(callId: string, reason: number): Promise<void>;
+
+  endCall(callId: string): Promise<void>;
+
+  setMutedCall(callId: string, isMuted: boolean): Promise<void>;
+
+  setOnHoldCall(callId: string, isOnHold: boolean): Promise<void>;
+
+  registerBackgroundTaskAvailable(): void;
+
+  isServiceStarted(): Promise<boolean>;
+
+  startBackgroundTask(taskName: string, timeout: number): Promise<void>;
+
+  stopBackgroundTask(taskName: string): Promise<void>;
+
+  registerVoipToken(): void;
+
+  readonly onNewEvent: EventEmitter<{
+    eventName: string;
+    params: {
+      callId: string;
+      cause?: string;
+      muted?: boolean;
+      hold?: boolean;
+    };
+  }>;
+
+  readonly onNewVoipEvent: EventEmitter<{
+    eventName: string;
+    params: {
+      token: string;
+      aps: {
+        'thread-id': string;
+        'mutable-content': number;
+        alert: {
+          title: string;
+        };
+        category: string;
+        sound: string;
+      };
+      stream: {
+        sender: string;
+        created_by_id: string;
+        body: string;
+        title: string;
+        call_display_name: string;
+        created_by_display_name: string;
+        version: string;
+        type: string;
+        receiver_id: string;
+        call_cid: string;
+        video: string;
+      };
+    };
+  }>;
+
+  log(message: string, level: 'debug' | 'info' | 'warn' | 'error'): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('Callingx');