@sendbird/uikit-react-native 3.10.3 → 3.11.1

package/src/platform/createRecorderService.native.tsx

@@ -1,5 +1,6 @@
 import { Platform } from 'react-native';
-import * as RNAudioRecorder from 'react-native-audio-recorder-player';
+import type * as LegacyModule from 'react-native-audio-recorder-player';
+import type * as NitroSoundOrLegacyV4Module from 'react-native-nitro-sound';
 import * as Permissions from 'react-native-permissions';
 import { Permission } from 'react-native-permissions/src/types';
 
@@ -9,168 +10,289 @@ import VoiceMessageConfig from '../libs/VoiceMessageConfig';
 import nativePermissionGranted from '../utils/nativePermissionGranted';
 import type { RecorderServiceInterface, Unsubscribe } from './types';
 
+export type AudioRecorderModule = typeof LegacyModule | typeof NitroSoundOrLegacyV4Module;
+
 type RecordingListener = Parameters<RecorderServiceInterface['addRecordingListener']>[number];
 type StateListener = Parameters<RecorderServiceInterface['addStateListener']>[number];
 type Modules = {
-  audioRecorderModule: typeof RNAudioRecorder;
+  audioRecorderModule: AudioRecorderModule;
   permissionModule: typeof Permissions;
 };
-const createNativeRecorderService = ({ audioRecorderModule, permissionModule }: Modules): RecorderServiceInterface => {
-  const module = new audioRecorderModule.default();
-
-  class VoiceRecorder implements RecorderServiceInterface {
-    public uri: RecorderServiceInterface['uri'] = undefined;
-    public state: RecorderServiceInterface['state'] = 'idle';
-    public options: RecorderServiceInterface['options'] = {
-      minDuration: VoiceMessageConfig.DEFAULT.RECORDER.MIN_DURATION,
-      maxDuration: VoiceMessageConfig.DEFAULT.RECORDER.MAX_DURATION,
-      extension: VoiceMessageConfig.DEFAULT.RECORDER.EXTENSION,
-    };
 
-    // NOTE: In Android, even when startRecorder() is awaited, if stop() is executed immediately afterward, an error occurs
-    private _recordStartedAt = 0;
-    private _getRecorderStopSafeBuffer = () => {
-      const minWaitingTime = 500;
-      const elapsedTime = Date.now() - this._recordStartedAt;
-      if (elapsedTime > minWaitingTime) return 0;
-      else return minWaitingTime - elapsedTime;
-    };
+interface RecordBackData {
+  currentPosition: number;
+  duration?: number;
+}
 
-    private readonly recordingSubscribers = new Set<RecordingListener>();
-    private readonly stateSubscribers = new Set<StateListener>();
-    private readonly audioSettings = {
-      sampleRate: VoiceMessageConfig.DEFAULT.RECORDER.SAMPLE_RATE,
-      bitRate: VoiceMessageConfig.DEFAULT.RECORDER.BIT_RATE,
-      audioChannels: VoiceMessageConfig.DEFAULT.RECORDER.CHANNELS,
-      // encoding: mpeg4_aac
-    };
-    private readonly audioOptions = Platform.select({
+interface RecorderModuleAdapter {
+  setSubscriptionDuration(duration: number): Promise<void> | void;
+  addRecordBackListener(callback: (data: RecordBackData) => void): void;
+  convertRecordPath(uri: string): string;
+  startRecorder(uri: string): Promise<void>;
+  stopRecorder(): Promise<void>;
+}
+
+class AudioRecorderPlayerAdapter implements RecorderModuleAdapter {
+  private module: InstanceType<typeof LegacyModule.default>;
+  private readonly audioOptions;
+
+  constructor(audioRecorderModule: typeof LegacyModule) {
+    this.module = new audioRecorderModule.default();
+
+    this.audioOptions = Platform.select({
       android: {
-        AudioEncodingBitRateAndroid: this.audioSettings.bitRate,
-        AudioChannelsAndroid: this.audioSettings.audioChannels,
-        AudioSamplingRateAndroid: this.audioSettings.sampleRate,
+        AudioEncodingBitRateAndroid: VoiceMessageConfig.DEFAULT.RECORDER.BIT_RATE,
+        AudioChannelsAndroid: VoiceMessageConfig.DEFAULT.RECORDER.CHANNELS,
+        AudioSamplingRateAndroid: VoiceMessageConfig.DEFAULT.RECORDER.SAMPLE_RATE,
         AudioEncoderAndroid: audioRecorderModule.AudioEncoderAndroidType.AAC,
         OutputFormatAndroid: audioRecorderModule.OutputFormatAndroidType.MPEG_4,
         AudioSourceAndroid: audioRecorderModule.AudioSourceAndroidType.VOICE_RECOGNITION,
       },
       ios: {
-        AVEncoderBitRateKeyIOS: this.audioSettings.bitRate,
-        AVNumberOfChannelsKeyIOS: this.audioSettings.audioChannels,
-        AVSampleRateKeyIOS: this.audioSettings.sampleRate,
+        AVEncoderBitRateKeyIOS: VoiceMessageConfig.DEFAULT.RECORDER.BIT_RATE,
+        AVNumberOfChannelsKeyIOS: VoiceMessageConfig.DEFAULT.RECORDER.CHANNELS,
+        AVSampleRateKeyIOS: VoiceMessageConfig.DEFAULT.RECORDER.SAMPLE_RATE,
         AVFormatIDKeyIOS: audioRecorderModule.AVEncodingOption.mp4, // same with aac
         AVEncoderAudioQualityKeyIOS: audioRecorderModule.AVEncoderAudioQualityIOSType.high,
       },
       default: {},
     });
+  }
 
-    constructor() {
-      module.setSubscriptionDuration(0.1).catch((error) => {
-        Logger.warn('[RecorderService.Native] Failed to set subscription duration', error);
-      });
-      module.addRecordBackListener((data) => {
-        const completed = data.currentPosition >= this.options.maxDuration;
+  async setSubscriptionDuration(duration: number): Promise<void> {
+    await this.module.setSubscriptionDuration(duration);
+  }
 
-        if (completed) {
-          this.stop().catch((error) => {
-            Logger.warn('[RecorderService.Native] Failed to stop in RecordBackListener', error);
-          });
-        }
-        if (this.state === 'recording') {
-          this.recordingSubscribers.forEach((callback) => {
-            callback({ currentTime: data.currentPosition, completed });
-          });
-        }
-      });
+  addRecordBackListener(callback: (data: RecordBackData) => void): void {
+    this.module.addRecordBackListener(callback);
+  }
+
+  convertRecordPath(uri: string): string {
+    return Platform.OS === 'ios' ? uri.split('/').pop() || uri : uri;
+  }
+
+  async startRecorder(uri: string): Promise<void> {
+    await this.module.startRecorder(uri, this.audioOptions as Parameters<typeof this.module.startRecorder>[1]);
+  }
+
+  async stopRecorder(): Promise<void> {
+    await this.module.stopRecorder();
+  }
+}
+
+class NitroSoundOrLegacyV4Adapter implements RecorderModuleAdapter {
+  private module;
+  private readonly audioOptions;
+
+  constructor(audioRecorderModule: typeof NitroSoundOrLegacyV4Module) {
+    this.module = audioRecorderModule.default;
+    this.audioOptions = Platform.select({
+      android: {
+        AudioEncodingBitRateAndroid: VoiceMessageConfig.DEFAULT.RECORDER.BIT_RATE,
+        AudioChannelsAndroid: VoiceMessageConfig.DEFAULT.RECORDER.CHANNELS,
+        AudioSamplingRateAndroid: VoiceMessageConfig.DEFAULT.RECORDER.SAMPLE_RATE,
+        AudioEncoderAndroid: audioRecorderModule.AudioEncoderAndroidType.AAC,
+        OutputFormatAndroid: audioRecorderModule.OutputFormatAndroidType.MPEG_4,
+        AudioSourceAndroid: audioRecorderModule.AudioSourceAndroidType.VOICE_RECOGNITION,
+      },
+      ios: {
+        AVEncoderBitRateKeyIOS: VoiceMessageConfig.DEFAULT.RECORDER.BIT_RATE,
+        AVNumberOfChannelsKeyIOS: VoiceMessageConfig.DEFAULT.RECORDER.CHANNELS,
+        AVSampleRateKeyIOS: VoiceMessageConfig.DEFAULT.RECORDER.SAMPLE_RATE,
+        AVFormatIDKeyIOS: 'mp4', // same with aac
+        AVEncoderAudioQualityKeyIOS: audioRecorderModule.AVEncoderAudioQualityIOSType.high,
+      },
+      default: {},
+    });
+  }
+
+  setSubscriptionDuration(duration: number): void {
+    try {
+      this.module.setSubscriptionDuration(duration);
+    } catch (error) {
+      Logger.warn('[RecorderService.Native] Failed to set subscription duration', error);
     }
+  }
 
-    private setState = (state: RecorderServiceInterface['state']) => {
-      this.state = state;
-      this.stateSubscribers.forEach((callback) => {
-        callback(state);
-      });
-    };
+  addRecordBackListener(callback: (data: RecordBackData) => void): void {
+    this.module.addRecordBackListener(callback);
+  }
+
+  convertRecordPath(uri: string): string {
+    return uri;
+  }
+
+  async startRecorder(uri: string): Promise<void> {
+    await this.module.startRecorder(uri, this.audioOptions as Parameters<typeof this.module.startRecorder>[1]);
+  }
+
+  async stopRecorder(): Promise<void> {
+    await this.module.stopRecorder();
+  }
+}
 
-    public requestPermission = async (): Promise<boolean> => {
-      const permission: Permission[] | undefined = Platform.select({
-        android: [permissionModule.PERMISSIONS.ANDROID.RECORD_AUDIO],
-        ios: [permissionModule.PERMISSIONS.IOS.MICROPHONE],
-        windows: [permissionModule.PERMISSIONS.WINDOWS.MICROPHONE],
-        default: undefined,
+class VoiceRecorder implements RecorderServiceInterface {
+  public uri: RecorderServiceInterface['uri'] = undefined;
+  public state: RecorderServiceInterface['state'] = 'idle';
+  public options: RecorderServiceInterface['options'] = {
+    minDuration: VoiceMessageConfig.DEFAULT.RECORDER.MIN_DURATION,
+    maxDuration: VoiceMessageConfig.DEFAULT.RECORDER.MAX_DURATION,
+    extension: VoiceMessageConfig.DEFAULT.RECORDER.EXTENSION,
+  };
+
+  private _recordStartedAt = 0;
+  private _stopping = false;
+  private readonly recordingSubscribers = new Set<RecordingListener>();
+  private readonly stateSubscribers = new Set<StateListener>();
+
+  constructor(private readonly adapter: RecorderModuleAdapter, private readonly permissionModule: typeof Permissions) {
+    this.initialize();
+  }
+
+  private initialize(): void {
+    const setDurationResult = this.adapter.setSubscriptionDuration(0.1);
+    if (setDurationResult instanceof Promise) {
+      setDurationResult.catch((error) => {
+        Logger.warn('[RecorderService.Native] Failed to set subscription duration', error);
       });
+    }
+
+    this.adapter.addRecordBackListener((data) => {
+      const completed = data.currentPosition >= this.options.maxDuration;
 
-      if (Platform.OS === 'android' && Platform.Version <= 28) {
-        permission?.push(permissionModule.PERMISSIONS.ANDROID.WRITE_EXTERNAL_STORAGE);
+      if (completed) {
+        this.stop().catch((error) => {
+          Logger.warn('[RecorderService.Native] Failed to stop in RecordBackListener', error);
+        });
+      }
+      if (this.state === 'recording') {
+        this.recordingSubscribers.forEach((callback) => {
+          callback({ currentTime: data.currentPosition, completed });
+        });
       }
+    });
+  }
 
-      if (permission) {
-        const status = await permissionModule.checkMultiple(permission);
-        if (nativePermissionGranted(status)) {
-          return true;
-        } else {
-          const status = await permissionModule.requestMultiple(permission);
-          return nativePermissionGranted(status);
-        }
-      } else {
+  private setState = (state: RecorderServiceInterface['state']): void => {
+    this.state = state;
+    this.stateSubscribers.forEach((callback) => {
+      callback(state);
+    });
+  };
+
+  private getRecorderStopSafeBuffer = (): number => {
+    const minWaitingTime = 500;
+    const elapsedTime = Date.now() - this._recordStartedAt;
+    if (elapsedTime > minWaitingTime) return 0;
+    else return minWaitingTime - elapsedTime;
+  };
+
+  public requestPermission = async (): Promise<boolean> => {
+    const permission: Permission[] | undefined = Platform.select({
+      android: [this.permissionModule.PERMISSIONS.ANDROID.RECORD_AUDIO],
+      ios: [this.permissionModule.PERMISSIONS.IOS.MICROPHONE],
+      windows: [this.permissionModule.PERMISSIONS.WINDOWS.MICROPHONE],
+      default: undefined,
+    });
+
+    if (Platform.OS === 'android' && Platform.Version <= 28) {
+      permission?.push(this.permissionModule.PERMISSIONS.ANDROID.WRITE_EXTERNAL_STORAGE);
+    }
+
+    if (permission) {
+      const status = await this.permissionModule.checkMultiple(permission);
+      if (nativePermissionGranted(status)) {
         return true;
+      } else {
+        const status = await this.permissionModule.requestMultiple(permission);
+        return nativePermissionGranted(status);
       }
-    };
+    } else {
+      return true;
+    }
+  };
 
-    public addRecordingListener = (callback: RecordingListener): Unsubscribe => {
-      this.recordingSubscribers.add(callback);
-      return () => {
-        this.recordingSubscribers.delete(callback);
-      };
+  public addRecordingListener = (callback: RecordingListener): Unsubscribe => {
+    this.recordingSubscribers.add(callback);
+    return () => {
+      this.recordingSubscribers.delete(callback);
     };
+  };
 
-    public addStateListener = (callback: StateListener): Unsubscribe => {
-      this.stateSubscribers.add(callback);
-      return () => {
-        this.stateSubscribers.delete(callback);
-      };
+  public addStateListener = (callback: StateListener): Unsubscribe => {
+    this.stateSubscribers.add(callback);
+    return () => {
+      this.stateSubscribers.delete(callback);
     };
+  };
+
+  public record = async (uri: string): Promise<void> => {
+    if (matchesOneOf(this.state, ['idle', 'completed'])) {
+      try {
+        this.setState('preparing');
+        await this.adapter.startRecorder(uri);
 
-    public record = async (uri: string): Promise<void> => {
-      if (matchesOneOf(this.state, ['idle', 'completed'])) {
-        try {
-          this.setState('preparing');
-          await module.startRecorder(uri, {
-            ...this.audioOptions,
-          });
-
-          if (Platform.OS === 'android') {
-            this._recordStartedAt = Date.now();
-          }
-
-          this.uri = uri;
-          this.setState('recording');
-        } catch (e) {
-          this.setState('idle');
-          throw e;
+        if (Platform.OS === 'android') {
+          this._recordStartedAt = Date.now();
         }
+
+        this.uri = uri;
+        this.setState('recording');
+      } catch (e) {
+        this.setState('idle');
+        throw e;
       }
-    };
+    }
+  };
 
-    public stop = async (): Promise<void> => {
-      if (matchesOneOf(this.state, ['recording'])) {
+  public stop = async (): Promise<void> => {
+    if (matchesOneOf(this.state, ['recording']) && !this._stopping) {
+      this._stopping = true;
+      try {
         if (Platform.OS === 'android') {
-          const buffer = this._getRecorderStopSafeBuffer();
+          const buffer = this.getRecorderStopSafeBuffer();
           if (buffer > 0) await sleep(buffer);
         }
 
-        await module.stopRecorder();
+        await this.adapter.stopRecorder();
         this.setState('completed');
+      } catch (error) {
+        Logger.error('[RecorderService.Native] Failed to stop recorder', error);
+        throw error;
+      } finally {
+        this._stopping = false;
       }
-    };
+    }
+  };
 
-    public reset = async (): Promise<void> => {
-      await this.stop();
-      this.uri = undefined;
-      this.recordingSubscribers.clear();
-      this.setState('idle');
-    };
-  }
+  public reset = async (): Promise<void> => {
+    await this.stop();
+    this.uri = undefined;
+    this.recordingSubscribers.clear();
+    this.setState('idle');
+  };
+
+  public convertRecordPath = (uri: string): string => {
+    return this.adapter.convertRecordPath(uri);
+  };
+}
+
+const createNativeRecorderService = (modules: Modules): RecorderServiceInterface => {
+  const adapter = isNitroSoundOrLegacyV4Module(modules.audioRecorderModule)
+    ? new NitroSoundOrLegacyV4Adapter(modules.audioRecorderModule)
+    : new AudioRecorderPlayerAdapter(modules.audioRecorderModule as typeof LegacyModule);
 
-  return new VoiceRecorder();
+  return new VoiceRecorder(adapter, modules.permissionModule);
 };
 
+function isNitroSoundOrLegacyV4Module(module: AudioRecorderModule): module is typeof NitroSoundOrLegacyV4Module {
+  const isNitroSound = 'createSound' in module && typeof module.createSound === 'function';
+  const isLegacyV4 =
+    'default' in module && 'getHybridObject' in module.default && typeof module.default.getHybridObject === 'function';
+  if (isLegacyV4) {
+    Logger.warn('react-native-audio-recorder-player is deprecated. Please use react-native-nitro-sound instead.');
+  }
+  return isNitroSound || isLegacyV4;
+}
+
 export default createNativeRecorderService;

package/src/platform/types.ts

@@ -215,4 +215,9 @@ export interface RecorderServiceInterface {
    *   [*] to [idle]
    * */
   reset(): Promise<void>;
+
+  /**
+   * Get the record path processed for the specific platform and adapter.
+   * */
+  convertRecordPath(uri: string): string;
 }

package/src/utils/expoBackwardUtils.ts

@@ -1,6 +1,9 @@
+import type * as ExpoAudio from 'expo-audio';
+import type * as ExpoAV from 'expo-av';
 import type * as ExpoDocumentPicker from 'expo-document-picker';
 import type * as ExpoFs from 'expo-file-system';
 import type * as ExpoImagePicker from 'expo-image-picker';
+import type * as ExpoVideo from 'expo-video';
 
 import type { FilePickerResponse } from '../platform/types';
 import normalizeFile from './normalizeFile';
@@ -55,6 +58,29 @@ const expoBackwardUtils = {
       }
     },
   },
+  expoAV: {
+    isLegacyAVModule(module: ExpoAudioModule | ExpoVideoModule): module is typeof ExpoAV {
+      try {
+        return 'Video' in module && 'Audio' in module && typeof module.Video === 'function';
+      } catch {
+        return false;
+      }
+    },
+    isAudioModule(module: ExpoAudioModule): module is typeof ExpoAudio {
+      try {
+        return 'useAudioRecorder' in module && typeof module.useAudioRecorder === 'function';
+      } catch {
+        return false;
+      }
+    },
+    isVideoModule(module: ExpoVideoModule): module is typeof ExpoVideo {
+      try {
+        return 'VideoView' in module && 'useVideoPlayer' in module && typeof module.useVideoPlayer === 'function';
+      } catch {
+        return false;
+      }
+    },
+  },
   toFileSize(info: ExpoFs.FileInfo) {
     if ('size' in info) {
       return info.size;
@@ -64,4 +90,7 @@ const expoBackwardUtils = {
   },
 };
 
+export type ExpoAudioModule = typeof ExpoAV | typeof ExpoAudio;
+export type ExpoVideoModule = typeof ExpoAV | typeof ExpoVideo;
+
 export default expoBackwardUtils;

package/src/utils/expoPermissionGranted.ts

@@ -9,7 +9,9 @@ export interface ExpoPermissionResponse {
 export interface ExpoMediaLibraryPermissionResponse extends ExpoPermissionResponse {
   accessPrivileges?: 'all' | 'limited' | 'none';
 }
-export interface ExpoPushPermissionResponse extends ExpoPermissionResponse, NotificationPermissionsStatus {}
+export interface ExpoPushPermissionResponse
+  extends Omit<ExpoPermissionResponse, 'status'>,
+    NotificationPermissionsStatus {}
 
 const expoPermissionGranted = (
   stats: Array<ExpoMediaLibraryPermissionResponse | ExpoPushPermissionResponse | ExpoPermissionResponse>,

package/src/version.ts

@@ -1,2 +1,2 @@
-const VERSION = '3.10.3';
+const VERSION = '3.11.1';
 export default VERSION;