edoctor-sendbird-calls 1.0.0

package/src/SendBirdCalls.ts

@@ -0,0 +1,472 @@
+import { NativeModules, Platform } from 'react-native';
+
+const RNSendBirdCalls = NativeModules.RNSendBirdCalls;
+const isIOS = Platform.OS === 'ios';
+
+// Types for better type safety
+interface AuthResult {
+  succeeded: boolean;
+  userId?: string;
+  nickname?: string;
+  errorCode?: string;
+  errorMessage?: string;
+}
+
+interface CallResult {
+  succeeded: boolean;
+  callId?: string;
+  caller?: string;
+  callee?: string;
+  errorCode?: string;
+  errorMessage?: string;
+}
+
+interface RecordingResult {
+  succeeded: boolean;
+  recordingId?: string;
+  filePath?: string;
+  errorCode?: string;
+  errorMessage?: string;
+}
+
+interface DeviceStatusResult {
+  succeeded: boolean;
+  isLocked?: boolean;
+  isInForeground?: boolean;
+  errorMessage?: string;
+}
+
+export default (function SendBirdCalls() {
+  // MARK: - Authentication
+  const authenticate = async (
+    userId: string,
+    accessToken: string
+  ): Promise<AuthResult | undefined> => {
+    try {
+      return await RNSendBirdCalls.authenticate(userId, accessToken ?? '');
+    } catch (error) {
+      console.log('error at authenticate', error);
+      return undefined;
+    }
+  };
+
+  const deAuthenticate = async (): Promise<AuthResult | undefined> => {
+    try {
+      return await RNSendBirdCalls.deAuthenticate();
+    } catch (error) {
+      console.log('error at deAuthenticate', error);
+      return undefined;
+    }
+  };
+
+  // MARK: - Initialization
+  const initSendBird = async (
+    appId: string
+  ): Promise<AuthResult | undefined> => {
+    try {
+      return await RNSendBirdCalls.initSendBird(appId);
+    } catch (error) {
+      console.log('error at initSendBird', error);
+      return undefined;
+    }
+  };
+
+  const shareStorage = (appId: string): void => {
+    try {
+      RNSendBirdCalls.shareStorage(appId);
+    } catch (error) {
+      console.log('error at shareStorage', error);
+    }
+  };
+
+  // MARK: - VoIP and Push Notifications
+  const voipRegistry = (): void => {
+    try {
+      if (isIOS) {
+        RNSendBirdCalls.voipRegistry();
+      }
+    } catch (error) {
+      console.log('error at voipRegistry', error);
+    }
+  };
+
+  const registerPushToken = async (
+    token: string
+  ): Promise<AuthResult | undefined> => {
+    try {
+      if (!isIOS) {
+        return await RNSendBirdCalls.registerPushToken(token);
+      }
+      return { succeeded: false, errorMessage: 'Not supported on iOS' };
+    } catch (error) {
+      console.log('error at registerPushToken', error);
+      return undefined;
+    }
+  };
+
+  const unregisterPushToken = async (
+    token: string
+  ): Promise<AuthResult | undefined> => {
+    try {
+      if (!isIOS) {
+        return await RNSendBirdCalls.unregisterPushToken(token);
+      }
+      return { succeeded: false, errorMessage: 'Not supported on iOS' };
+    } catch (error) {
+      console.log('error at unregisterPushToken', error);
+      return undefined;
+    }
+  };
+
+  // MARK: - Call Management
+  const dial = async (
+    calleeId: string,
+    isVideoCall: boolean,
+    isVideoEnable = true,
+    isAudioEnable = true,
+    appointmentScheduleId: string,
+    eClinicId: string
+  ): Promise<CallResult | undefined> => {
+    try {
+      return await RNSendBirdCalls.dial(
+        calleeId,
+        isVideoCall,
+        isVideoEnable,
+        isAudioEnable,
+        appointmentScheduleId,
+        eClinicId
+      );
+    } catch (error) {
+      console.log('error at dial', error);
+      return undefined;
+    }
+  };
+
+  const acceptCall = async (
+    callId: string,
+    isVideoEnable = true,
+    isAudioEnable = true
+  ): Promise<CallResult | undefined> => {
+    try {
+      return await RNSendBirdCalls.acceptCall(
+        callId,
+        isVideoEnable,
+        isAudioEnable
+      );
+    } catch (error) {
+      console.log('error at acceptCall', error);
+      return undefined;
+    }
+  };
+
+  const endCall = async (): Promise<CallResult | undefined> => {
+    try {
+      return await RNSendBirdCalls.endCall();
+    } catch (error) {
+      console.log('error at endCall', error);
+      return undefined;
+    }
+  };
+
+  const endAllCalls = async (): Promise<AuthResult | undefined> => {
+    try {
+      return await RNSendBirdCalls.endAllCalls();
+    } catch (error) {
+      console.log('error at endAllCalls', error);
+      return undefined;
+    }
+  };
+
+  const getOngoingCalls = async (): Promise<
+    Record<string, any>[] | undefined
+  > => {
+    try {
+      return await RNSendBirdCalls.getOngoingCalls();
+    } catch (error) {
+      console.log('error at getOngoingCalls', error);
+      return undefined;
+    }
+  };
+
+  // MARK: - Call Info (Fixed method name)
+  const getCallInfo = async (): Promise<CallResult | undefined> => {
+    try {
+      // Use getCallInfo for Android (as defined in native module)
+      if (!isIOS) {
+        return await RNSendBirdCalls.getCallInfo();
+      }
+      // For iOS, you might need to implement this method or use getOngoingCalls
+      const ongoingCalls: CallResult[] =
+        (await getOngoingCalls()) as CallResult[];
+      return ongoingCalls && ongoingCalls.length > 0
+        ? ongoingCalls[0]
+        : undefined;
+    } catch (error) {
+      console.log('error at getCallInfo', error);
+      return undefined;
+    }
+  };
+
+  const getCall = async (callId: string): Promise<CallResult | undefined> => {
+    try {
+      if (!isIOS) {
+        return await RNSendBirdCalls.getCall(callId);
+      }
+      return { succeeded: false, errorMessage: 'Not supported on iOS' };
+    } catch (error) {
+      console.log('error at getCall', error);
+      return undefined;
+    }
+  };
+
+  // MARK: - Audio/Video Controls
+  const muteMicrophone = async (): Promise<AuthResult | undefined> => {
+    try {
+      return await RNSendBirdCalls.muteMicrophone();
+    } catch (error) {
+      console.log('error at muteMicrophone', error);
+      return undefined;
+    }
+  };
+
+  const unmuteMicrophone = async (): Promise<AuthResult | undefined> => {
+    try {
+      return await RNSendBirdCalls.unmuteMicrophone();
+    } catch (error) {
+      console.log('error at unmuteMicrophone', error);
+      return undefined;
+    }
+  };
+
+  const startVideo = async (): Promise<AuthResult | undefined> => {
+    try {
+      return await RNSendBirdCalls.startVideo();
+    } catch (error) {
+      console.log('error at startVideo', error);
+      return undefined;
+    }
+  };
+
+  const stopVideo = async (): Promise<AuthResult | undefined> => {
+    try {
+      return await RNSendBirdCalls.stopVideo();
+    } catch (error) {
+      console.log('error at stopVideo', error);
+      return undefined;
+    }
+  };
+
+  const switchCamera = async (): Promise<AuthResult | undefined> => {
+    try {
+      return await RNSendBirdCalls.switchCamera();
+    } catch (error) {
+      console.log('error at switchCamera', error);
+      return undefined;
+    }
+  };
+
+  // MARK: - Recording
+  const startRecording = async (
+    fileName: string,
+    isRemote: boolean
+  ): Promise<RecordingResult | undefined> => {
+    try {
+      return await RNSendBirdCalls.startRecording(fileName, isRemote);
+    } catch (error) {
+      console.log('error at startRecording', error);
+      return undefined;
+    }
+  };
+
+  const stopRecording = async (
+    recordingId: string
+  ): Promise<AuthResult | undefined> => {
+    try {
+      return await RNSendBirdCalls.stopRecording(recordingId);
+    } catch (error) {
+      console.log('error at stopRecording', error);
+      return undefined;
+    }
+  };
+
+  // MARK: - Sound Configuration
+  const addDirectCallSound = (
+    soundType: 'DIALING' | 'RINGING' | 'RECONNECTING' | 'RECONNECTED',
+    filename: string
+  ): void => {
+    try {
+      RNSendBirdCalls.addDirectCallSound(soundType, filename);
+    } catch (error) {
+      console.log('error at addDirectCallSound', error);
+    }
+  };
+
+  const setDirectCallDialingSoundOnWhenSilentMode = async (
+    isEnabled: boolean
+  ): Promise<AuthResult | undefined> => {
+    try {
+      if (!isIOS) {
+        return await RNSendBirdCalls.setDirectCallDialingSoundOnWhenSilentMode(
+          isEnabled
+        );
+      } else {
+        RNSendBirdCalls.setDirectCallDialingSoundOnWhenSilentMode(isEnabled);
+        return { succeeded: true };
+      }
+    } catch (error) {
+      console.log('error at setDirectCallDialingSoundOnWhenSilentMode', error);
+      return undefined;
+    }
+  };
+
+  // MARK: - Android Specific Features
+  const getDeviceLocked = async (): Promise<DeviceStatusResult | undefined> => {
+    try {
+      if (!isIOS) {
+        return await RNSendBirdCalls.getDeviceLocked();
+      }
+      return { succeeded: false, errorMessage: 'Not supported on iOS' };
+    } catch (error) {
+      console.log('error at getDeviceLocked', error);
+      return undefined;
+    }
+  };
+
+  const isAppInForeground = async (): Promise<
+    DeviceStatusResult | undefined
+  > => {
+    try {
+      if (!isIOS) {
+        return await RNSendBirdCalls.isAppInForeground();
+      }
+      return { succeeded: false, errorMessage: 'Not supported on iOS' };
+    } catch (error) {
+      console.log('error at isAppInForeground', error);
+      return undefined;
+    }
+  };
+
+  const wakeAppIncomingCall = (params: Record<string, any> = {}): void => {
+    try {
+      if (!isIOS) {
+        RNSendBirdCalls.wakeAppIncomingCall(params);
+      }
+    } catch (error) {
+      console.log('error at wakeAppIncomingCall', error);
+    }
+  };
+
+  const navigateMainApp = (params: Record<string, any> = {}): void => {
+    try {
+      if (!isIOS) {
+        RNSendBirdCalls.navigateMainApp(params);
+      }
+    } catch (error) {
+      console.log('error at navigateMainApp', error);
+    }
+  };
+
+  const finishLockedScreenUI = (): void => {
+    try {
+      if (!isIOS) {
+        RNSendBirdCalls.finishLockedScreenUI();
+      }
+    } catch (error) {
+      console.log('error at finishLockedScreenUI', error);
+    }
+  };
+
+  const cancelComingCallNotification = (): void => {
+    try {
+      if (!isIOS) {
+        RNSendBirdCalls.cancelComingCallNotification();
+      }
+    } catch (error) {
+      console.log('error at cancelComingCallNotification', error);
+    }
+  };
+
+  // MARK: - Legacy Authentication Methods (Android specific)
+  const endIncomingCallNeedAuthentication = async (
+    callId: string
+  ): Promise<CallResult | undefined> => {
+    try {
+      if (!isIOS) {
+        return await RNSendBirdCalls.endIncomingCallNeedAuthentication(callId);
+      }
+      return { succeeded: false, errorMessage: 'Not supported on iOS' };
+    } catch (error) {
+      console.log('error at endIncomingCallNeedAuthentication', error);
+      return undefined;
+    }
+  };
+
+  const acceptIncomingCallNeedAuthentication = async (
+    callId: string,
+    isVideoEnable = true,
+    isAudioEnable = true
+  ): Promise<CallResult | undefined> => {
+    try {
+      if (!isIOS) {
+        return await RNSendBirdCalls.acceptIncomingCallNeedAuthentication(
+          callId,
+          isVideoEnable,
+          isAudioEnable
+        );
+      }
+      return { succeeded: false, errorMessage: 'Not supported on iOS' };
+    } catch (error) {
+      console.log('error at acceptIncomingCallNeedAuthentication', error);
+      return undefined;
+    }
+  };
+
+  return {
+    // Core functionality
+    authenticate,
+    deAuthenticate,
+    initSendBird,
+    shareStorage,
+
+    // VoIP and Push
+    voipRegistry,
+    registerPushToken,
+    unregisterPushToken,
+
+    // Call management
+    dial,
+    acceptCall,
+    endCall,
+    endAllCalls,
+    getOngoingCalls,
+    getCallInfo,
+    getCall,
+
+    // Audio/Video controls
+    muteMicrophone,
+    unmuteMicrophone,
+    startVideo,
+    stopVideo,
+    switchCamera,
+
+    // Recording
+    startRecording,
+    stopRecording,
+
+    // Sound configuration
+    addDirectCallSound,
+    setDirectCallDialingSoundOnWhenSilentMode,
+
+    // Android specific
+    getDeviceLocked,
+    isAppInForeground,
+    wakeAppIncomingCall,
+    navigateMainApp,
+    finishLockedScreenUI,
+    cancelComingCallNotification,
+
+    // Legacy methods
+    endIncomingCallNeedAuthentication,
+    acceptIncomingCallNeedAuthentication,
+  };
+})();

package/src/SendBirdCallsEvents.ts

@@ -0,0 +1,141 @@
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+
+import type {
+  CallbackRingingType,
+  CallbackCallDidAcceptType,
+  CallbackConnectedType,
+  CallbackCallEndedType,
+  CallbackReconnectingType,
+  CallbackReconnectedType,
+} from './index.type';
+
+const RNSendBirdCalls = NativeModules.RNSendBirdCalls;
+
+export default (function SendBirdCallsEvents() {
+  const eventNames: Record<string, string> = {
+    onRinging: 'onRinging',
+    onCallDidAccept: 'onCallDidAccept',
+    onConnected: 'onConnected',
+    onEnded: 'onEnded',
+    onReconnected: 'onReconnected',
+    onReconnecting: 'onReconnecting',
+    onRemoteAudioSettingsChanged: 'onRemoteAudioSettingsChanged',
+    onRemoteVideoSettingsChanged: 'onRemoteVideoSettingsChanged',
+    onRecordingSucceeded: 'onRecordingSucceeded',
+    onRecordingFailed: 'onRecordingFailed',
+  };
+
+  // Use appropriate event emitter based on platform
+  const eventEmitter =
+    Platform.OS === 'ios'
+      ? new NativeEventEmitter(RNSendBirdCalls)
+      : new NativeEventEmitter();
+
+  const numberOfEvents: Record<string, number> = Object.values(
+    eventNames
+  ).reduce((acc, name) => ({ ...acc, [name]: 0 }), {});
+
+  const createListener = (
+    eventName: string,
+    callback: any
+  ): { remove: () => void } => {
+    // Initialize counter if it doesn't exist
+    if (numberOfEvents[eventName] === undefined) {
+      numberOfEvents[eventName] = 0;
+    }
+
+    if (numberOfEvents[eventName] === 0) {
+      RNSendBirdCalls.setNativeEvent(eventName);
+    }
+    numberOfEvents[eventName] += 1;
+
+    const subscription = eventEmitter.addListener(eventName, callback);
+
+    return {
+      remove: () => {
+        if (numberOfEvents[eventName] === 1) {
+          RNSendBirdCalls.removeNativeEvent(eventName);
+        }
+        if (
+          numberOfEvents[eventName] !== undefined &&
+          numberOfEvents[eventName] > 0
+        ) {
+          numberOfEvents[eventName] -= 1;
+        }
+        subscription.remove();
+      },
+    };
+  };
+
+  const listenerRinging = (callback: CallbackRingingType) => {
+    const eventName = eventNames.onRinging!;
+    return createListener(eventName, callback);
+  };
+
+  const listenerCallDidAccept = (callback: CallbackCallDidAcceptType) => {
+    const eventName = eventNames.onCallDidAccept!;
+    return createListener(eventName, callback);
+  };
+
+  const listenerConnected = (callback: CallbackConnectedType) => {
+    const eventName = eventNames.onConnected!;
+    return createListener(eventName, callback);
+  };
+
+  const listenerEnded = (callback: CallbackCallEndedType) => {
+    const eventName = eventNames.onEnded!;
+    return createListener(eventName, callback);
+  };
+
+  const listenerReconnecting = (callback: CallbackReconnectingType) => {
+    const eventName = eventNames.onReconnecting!;
+    return createListener(eventName, callback);
+  };
+
+  const listenerReconnected = (callback: CallbackReconnectedType) => {
+    const eventName = eventNames.onReconnected!;
+    return createListener(eventName, callback);
+  };
+
+  const listenerRemoteAudioSettingsChanged = (callback: () => void) => {
+    const eventName = eventNames.onRemoteAudioSettingsChanged!;
+    return createListener(eventName, callback);
+  };
+
+  const listenerRemoteVideoSettingsChanged = (callback: () => void) => {
+    const eventName = eventNames.onRemoteVideoSettingsChanged!;
+    return createListener(eventName, callback);
+  };
+
+  const listenerRecordingSucceeded = (callback: () => void) => {
+    const eventName = eventNames.onRecordingSucceeded!;
+    return createListener(eventName, callback);
+  };
+
+  const listenerRecordingFailed = (callback: () => void) => {
+    const eventName = eventNames.onRecordingFailed!;
+    return createListener(eventName, callback);
+  };
+
+  const resetListener = () => {
+    Object.keys(numberOfEvents).forEach((key) => {
+      numberOfEvents[key] = 0;
+      RNSendBirdCalls.removeNativeEvent(key);
+    });
+    RNSendBirdCalls.removeAllEvents();
+  };
+
+  return {
+    listenerRinging,
+    listenerCallDidAccept,
+    listenerConnected,
+    listenerEnded,
+    listenerReconnected,
+    listenerReconnecting,
+    listenerRemoteAudioSettingsChanged,
+    listenerRemoteVideoSettingsChanged,
+    listenerRecordingSucceeded,
+    listenerRecordingFailed,
+    resetListener,
+  };
+})();

package/src/SendBirdCallsVideo.tsx

@@ -0,0 +1,44 @@
+import { requireNativeComponent, type ViewStyle } from 'react-native';
+
+// Define the native component interface
+interface NativeVideoProps {
+  callId: string;
+  local: boolean;
+  scaleFit: boolean;
+  style?: ViewStyle;
+}
+
+// Require the native component
+const RNVSendBirdCallsVideo = requireNativeComponent<NativeVideoProps>('RNVSendBirdCallsVideo');
+
+// Props interface for the React component
+interface SendBirdCallsVideoProps {
+  callId: string;
+  local: boolean;
+  scaleFit?: boolean;
+  style?: ViewStyle;
+}
+
+/**
+ * SendBird Calls Video Component
+ * 
+ * @param callId - The ID of the active call
+ * @param local - true for local video (self), false for remote video (other person)
+ * @param scaleFit - true to scale video to fit container, false to fill container
+ * @param style - Custom styles for the video view
+ */
+export default function SendBirdCallsVideo({
+  callId,
+  local,
+  scaleFit = true,
+  style
+}: SendBirdCallsVideoProps) {
+  return (
+    <RNVSendBirdCallsVideo 
+      callId={callId}
+      local={local}
+      scaleFit={scaleFit}
+      style={style}
+    />
+  );
+}

package/src/index.tsx

@@ -0,0 +1,11 @@
+// Main SendBird Calls functionality
+export { default as SendBirdCalls } from './SendBirdCalls';
+
+// Event handling
+export { default as SendBirdCallsEvents } from './SendBirdCallsEvents';
+
+// Video component
+export { default as SendBirdCallsVideo } from './SendBirdCallsVideo';
+
+// Type definitions
+export * from './index.type';

package/src/index.type.ts

@@ -0,0 +1,20 @@
+type CallbackRingingDataType = Record<string, any>
+export type CallbackRingingType = (data: CallbackRingingDataType) => void
+
+type CallbackCallDidAcceptDataType = Record<string, any>
+export type CallbackCallDidAcceptType = (data:CallbackCallDidAcceptDataType) => void
+
+type CallbackConnectedDataType = Record<string, any>
+export type CallbackConnectedType = (data: CallbackConnectedDataType) => void
+
+type CallbackCallEndedDataType = Record<string, any>
+export type CallbackCallEndedType = (data: CallbackCallEndedDataType) => void
+
+type CallbackReconnectingDataType = Record<string, any>
+export type CallbackReconnectingType = (data: CallbackReconnectingDataType) => void
+
+type CallbackReconnectedDataType = Record<string, any>
+export type CallbackReconnectedType = (data: CallbackReconnectedDataType) => void
+
+
+