@sendbird/uikit-react-native 3.1.2 → 3.3.0

package/src/localization/StringSet.type.ts

@@ -240,6 +240,7 @@ export interface StringSet {
     PERMISSION_APP_NAME: string;
     PERMISSION_CAMERA: string;
     PERMISSION_DEVICE_STORAGE: string;
+    PERMISSION_MICROPHONE: string;
 
     USER_NO_NAME: string;
     CHANNEL_NO_MEMBERS: string;
@@ -249,6 +250,7 @@ export interface StringSet {
       parentMessage: SendbirdUserMessage | SendbirdFileMessage,
       currentUserId?: string,
     ) => string;
+    MESSAGE_UNAVAILABLE: string;
 
     USER_BAR_ME_POSTFIX: string;
     USER_BAR_OPERATOR: string;
@@ -291,6 +293,10 @@ export interface StringSet {
     /** Channel > Message > Failed **/
     CHANNEL_MESSAGE_FAILED_RETRY: string;
     CHANNEL_MESSAGE_FAILED_REMOVE: string;
+
+    /** Voice message **/
+    VOICE_MESSAGE: string;
+    VOICE_MESSAGE_INPUT_CANCEL: string;
   };
   FILE_VIEWER: {
     TITLE: (message: SendbirdFileMessage) => string;
@@ -331,6 +337,8 @@ export interface StringSet {
     RESEND_MSG_ERROR: string;
     DELETE_MSG_ERROR: string;
     SEND_MSG_ERROR: string;
+    USER_MUTED_ERROR: string;
+    CHANNEL_FROZEN_ERROR: string;
     UPDATE_MSG_ERROR: string;
     TURN_ON_NOTIFICATIONS_ERROR: string;
     TURN_OFF_NOTIFICATIONS_ERROR: string;

package/src/localization/createBaseStringSet.ts

@@ -3,16 +3,16 @@ import type { Locale } from 'date-fns';
 import type { PartialDeep } from '@sendbird/uikit-utils';
 import {
   getDateSeparatorFormat,
-  getFileTypeFromMessage,
-  getGroupChannelLastMessage,
   getGroupChannelPreviewTime,
   getGroupChannelTitle,
   getMessagePreviewBody,
   getMessagePreviewTime,
   getMessagePreviewTitle,
   getMessageTimeFormat,
+  getMessageType,
   getOpenChannelParticipants,
   getOpenChannelTitle,
+  isVoiceMessage,
 } from '@sendbird/uikit-utils';
 
 import { UNKNOWN_USER_ID } from '../constants';
@@ -33,6 +33,7 @@ type StringSetCreateOptions = {
 export const createBaseStringSet = ({ dateLocale, overrides }: StringSetCreateOptions): StringSet => {
   const USER_NO_NAME = overrides?.LABELS?.USER_NO_NAME ?? '(No name)';
   const CHANNEL_NO_MEMBERS = overrides?.LABELS?.CHANNEL_NO_MEMBERS ?? '(No members)';
+
   return {
     OPEN_CHANNEL: {
       HEADER_TITLE: (channel) => getOpenChannelTitle(channel),
@@ -191,7 +192,11 @@ export const createBaseStringSet = ({ dateLocale, overrides }: StringSetCreateOp
       CHANNEL_PREVIEW_TITLE: (currentUserId, channel) =>
         getGroupChannelTitle(currentUserId, channel, USER_NO_NAME, CHANNEL_NO_MEMBERS),
       CHANNEL_PREVIEW_TITLE_CAPTION: (channel, locale) => getGroupChannelPreviewTime(channel, locale ?? dateLocale),
-      CHANNEL_PREVIEW_BODY: (channel) => getGroupChannelLastMessage(channel),
+      CHANNEL_PREVIEW_BODY: (channel) => {
+        if (!channel.lastMessage) return '';
+        if (isVoiceMessage(channel.lastMessage)) return 'Voice message';
+        return getMessagePreviewBody(channel.lastMessage);
+      },
       TYPE_SELECTOR_HEADER_TITLE: 'Channel type',
       TYPE_SELECTOR_GROUP: 'Group',
       TYPE_SELECTOR_SUPER_GROUP: 'Super group',
@@ -232,7 +237,10 @@ export const createBaseStringSet = ({ dateLocale, overrides }: StringSetCreateOp
       HEADER_INPUT_PLACEHOLDER: 'Search',
       HEADER_RIGHT: 'Search',
       SEARCH_RESULT_ITEM_TITLE: (message) => getMessagePreviewTitle(message),
-      SEARCH_RESULT_ITEM_BODY: (message) => getMessagePreviewBody(message),
+      SEARCH_RESULT_ITEM_BODY: (message) => {
+        if (isVoiceMessage(message)) return 'Voice message';
+        return getMessagePreviewBody(message);
+      },
       SEARCH_RESULT_ITEM_TITLE_CAPTION: (message, locale) => {
         return getMessagePreviewTime(message.createdAt, locale ?? dateLocale);
       },
@@ -241,6 +249,7 @@ export const createBaseStringSet = ({ dateLocale, overrides }: StringSetCreateOp
       PERMISSION_APP_NAME: 'Application',
       PERMISSION_CAMERA: 'camera',
       PERMISSION_DEVICE_STORAGE: 'device storage',
+      PERMISSION_MICROPHONE: 'microphone',
       USER_NO_NAME,
       CHANNEL_NO_MEMBERS,
       TYPING_INDICATOR_TYPINGS: (users, NO_NAME = USER_NO_NAME) => {
@@ -255,6 +264,7 @@ export const createBaseStringSet = ({ dateLocale, overrides }: StringSetCreateOp
         const receiverNickname = parent.sender.nickname || USER_NO_NAME;
         return `${reply.sender.userId !== currentUserId ? senderNickname : 'You'} replied to ${receiverNickname}`;
       },
+      MESSAGE_UNAVAILABLE: 'Message unavailable',
 
       USER_BAR_ME_POSTFIX: ' (You)',
       USER_BAR_OPERATOR: 'Operator',
@@ -288,22 +298,26 @@ export const createBaseStringSet = ({ dateLocale, overrides }: StringSetCreateOp
       CHANNEL_INPUT_REPLY_PREVIEW_TITLE: (user) => `Reply to ${user.nickname || USER_NO_NAME}`,
       CHANNEL_INPUT_REPLY_PREVIEW_BODY: (message) => {
         if (message.isFileMessage()) {
-          const fileType = getFileTypeFromMessage(message);
-          switch (fileType) {
-            case 'image':
+          const messageType = getMessageType(message);
+          switch (messageType) {
+            case 'file.image':
               return message.type.toLowerCase().includes('gif') ? 'GIF' : 'Photo';
-            case 'video':
+            case 'file.video':
               return 'Video';
-            case 'audio':
+            case 'file.audio':
               return 'Audio';
+            case 'file.voice':
+              return 'Voice message';
             default:
               return message.name;
           }
         } else if (message.isUserMessage()) {
           return message.message;
         }
-        return 'Unknown message type.';
+        return 'Unknown message';
       },
+      VOICE_MESSAGE: 'Voice message',
+      VOICE_MESSAGE_INPUT_CANCEL: 'Cancel',
       ...overrides?.LABELS,
     },
     FILE_VIEWER: {
@@ -329,7 +343,7 @@ export const createBaseStringSet = ({ dateLocale, overrides }: StringSetCreateOp
       ALERT_DEFAULT_OK: 'OK',
       ALERT_PERMISSIONS_TITLE: 'Allow access?',
       ALERT_PERMISSIONS_MESSAGE: (permission, appName = 'Application') => {
-        return `${appName} need permission to access your ${permission}.`;
+        return `${appName} needs permission to access your ${permission}.`;
       },
       ALERT_PERMISSIONS_OK: 'Go to settings',
       PROMPT_DEFAULT_OK: 'Submit',
@@ -348,6 +362,8 @@ export const createBaseStringSet = ({ dateLocale, overrides }: StringSetCreateOp
       DELETE_MSG_ERROR: "Couldn't delete message.",
       RESEND_MSG_ERROR: "Couldn't send message.",
       SEND_MSG_ERROR: "Couldn't send message.",
+      USER_MUTED_ERROR: "You're muted by the operator.",
+      CHANNEL_FROZEN_ERROR: 'Channel is frozen.',
       UPDATE_MSG_ERROR: "Couldn't edit message.",
       TURN_ON_NOTIFICATIONS_ERROR: "Couldn't turn on notifications.",
       TURN_OFF_NOTIFICATIONS_ERROR: "Couldn't turn off notifications.",

package/src/platform/createFileService.expo.ts

@@ -142,6 +142,16 @@ const createExpoFileService = ({
       }
       return response.uri;
     }
+    createRecordFilePath(customExtension = 'm4a'): { recordFilePath: string; uri: string } {
+      const basePath = fsModule.cacheDirectory;
+      if (!basePath) throw new Error('Cannot determine directory');
+
+      const filename = `record-${Date.now()}.${customExtension}`;
+      return {
+        uri: `${basePath}/${filename}`,
+        recordFilePath: `${basePath}/${filename}`,
+      };
+    }
   }
 
   return new ExpoFileServiceInterface();

package/src/platform/createFileService.native.ts

@@ -241,6 +241,25 @@ const createNativeFileService = ({
         } as const,
       };
     };
+
+    createRecordFilePath(customExtension = 'm4a'): { recordFilePath: string; uri: string } {
+      const filename = `record-${Date.now()}.${customExtension}`;
+      const path = `${fsModule.Dirs.CacheDir}/${filename}`;
+      return Platform.select({
+        ios: {
+          uri: path,
+          recordFilePath: filename,
+        },
+        android: {
+          uri: path.startsWith('file://') ? path : 'file://' + path,
+          recordFilePath: path,
+        },
+        default: {
+          uri: path,
+          recordFilePath: path,
+        },
+      });
+    }
   }
 
   return new NativeFileService();

package/src/platform/createPlayerService.expo.tsx

@@ -0,0 +1,142 @@
+import type * as ExpoAV from 'expo-av';
+
+import { matchesOneOf } from '@sendbird/uikit-utils';
+
+import expoPermissionGranted from '../utils/expoPermissionGranted';
+import type { PlayerServiceInterface, Unsubscribe } from './types';
+
+type Modules = {
+  avModule: typeof ExpoAV;
+};
+type PlaybackListener = Parameters<PlayerServiceInterface['addPlaybackListener']>[number];
+type StateListener = Parameters<PlayerServiceInterface['addStateListener']>[number];
+const createExpoPlayerService = ({ avModule }: Modules): PlayerServiceInterface => {
+  const sound = new avModule.Audio.Sound();
+
+  class VoicePlayer implements PlayerServiceInterface {
+    uri?: string;
+    state: PlayerServiceInterface['state'] = 'idle';
+
+    private readonly playbackSubscribers = new Set<PlaybackListener>();
+    private readonly stateSubscribers = new Set<StateListener>();
+
+    private setState = (state: PlayerServiceInterface['state']) => {
+      this.state = state;
+      this.stateSubscribers.forEach((callback) => {
+        callback(state);
+      });
+    };
+
+    private setListener = () => {
+      sound.setProgressUpdateIntervalAsync(100);
+      sound.setOnPlaybackStatusUpdate((status) => {
+        if (status.isLoaded) {
+          if (status.didJustFinish) this.stop();
+          if (status.isPlaying) {
+            this.playbackSubscribers.forEach((callback) => {
+              callback({
+                currentTime: status.positionMillis,
+                duration: status.durationMillis ?? 0,
+                stopped: status.didJustFinish,
+              });
+            });
+          }
+        }
+      });
+    };
+
+    private removeListener = () => {
+      sound.setOnPlaybackStatusUpdate(null);
+    };
+
+    public requestPermission = async (): Promise<boolean> => {
+      const status = await avModule.Audio.getPermissionsAsync();
+      if (expoPermissionGranted([status])) {
+        return true;
+      } else {
+        const status = await avModule.Audio.requestPermissionsAsync();
+        return expoPermissionGranted([status]);
+      }
+    };
+
+    public addPlaybackListener = (callback: PlaybackListener): Unsubscribe => {
+      this.playbackSubscribers.add(callback);
+      return () => {
+        this.playbackSubscribers.delete(callback);
+      };
+    };
+
+    public addStateListener = (callback: (state: PlayerServiceInterface['state']) => void): Unsubscribe => {
+      this.stateSubscribers.add(callback);
+      return () => {
+        this.stateSubscribers.delete(callback);
+      };
+    };
+
+    private prepare = async (uri: string) => {
+      this.setState('preparing');
+      await sound.loadAsync({ uri }, { shouldPlay: false }, true);
+      this.uri = uri;
+    };
+
+    public play = async (uri: string): Promise<void> => {
+      if (matchesOneOf(this.state, ['idle', 'stopped'])) {
+        try {
+          await this.prepare(uri);
+          this.setListener();
+          await sound.playAsync();
+          this.setState('playing');
+        } catch (e) {
+          this.setState('idle');
+          this.uri = undefined;
+          this.removeListener();
+          throw e;
+        }
+      } else if (matchesOneOf(this.state, ['paused']) && this.uri === uri) {
+        try {
+          this.setListener();
+          await sound.playAsync();
+          this.setState('playing');
+        } catch (e) {
+          this.removeListener();
+          throw e;
+        }
+      }
+    };
+
+    public pause = async (): Promise<void> => {
+      if (matchesOneOf(this.state, ['playing'])) {
+        await sound.pauseAsync();
+        this.removeListener();
+        this.setState('paused');
+      }
+    };
+
+    public stop = async (): Promise<void> => {
+      if (matchesOneOf(this.state, ['playing', 'paused'])) {
+        await sound.stopAsync();
+        await sound.unloadAsync();
+        this.removeListener();
+        this.setState('stopped');
+      }
+    };
+
+    public reset = async (): Promise<void> => {
+      await this.stop();
+      this.setState('idle');
+      this.uri = undefined;
+      this.playbackSubscribers.clear();
+      this.stateSubscribers.clear();
+    };
+
+    public seek = async (time: number): Promise<void> => {
+      if (matchesOneOf(this.state, ['playing', 'paused'])) {
+        await sound.playFromPositionAsync(time);
+      }
+    };
+  }
+
+  return new VoicePlayer();
+};
+
+export default createExpoPlayerService;

package/src/platform/createPlayerService.native.tsx

@@ -0,0 +1,148 @@
+import { Platform } from 'react-native';
+import type * as RNAudioRecorder from 'react-native-audio-recorder-player';
+import * as Permissions from 'react-native-permissions';
+
+import { matchesOneOf, sleep } from '@sendbird/uikit-utils';
+
+import type { PlayerServiceInterface, Unsubscribe } from './types';
+
+type Modules = {
+  audioRecorderModule: typeof RNAudioRecorder;
+  permissionModule: typeof Permissions;
+};
+type PlaybackListener = Parameters<PlayerServiceInterface['addPlaybackListener']>[number];
+type StateListener = Parameters<PlayerServiceInterface['addStateListener']>[number];
+const createNativePlayerService = ({ audioRecorderModule, permissionModule }: Modules): PlayerServiceInterface => {
+  const module = new audioRecorderModule.default();
+
+  class VoicePlayer implements PlayerServiceInterface {
+    uri?: string;
+    state: PlayerServiceInterface['state'] = 'idle';
+
+    private readonly playbackSubscribers = new Set<PlaybackListener>();
+    private readonly stateSubscribers = new Set<StateListener>();
+
+    constructor() {
+      module.setSubscriptionDuration(0.1);
+    }
+
+    private setState = (state: PlayerServiceInterface['state']) => {
+      this.state = state;
+      this.stateSubscribers.forEach((callback) => {
+        callback(state);
+      });
+    };
+
+    private setListener = () => {
+      module.addPlayBackListener((data) => {
+        const stopped = data.currentPosition >= data.duration;
+
+        if (stopped) this.stop();
+        if (this.state === 'playing') {
+          this.playbackSubscribers.forEach((callback) => {
+            callback({ currentTime: data.currentPosition, duration: data.duration, stopped });
+          });
+        }
+      });
+    };
+
+    private removeListener = () => {
+      module.removePlayBackListener();
+    };
+
+    public requestPermission = async (): Promise<boolean> => {
+      if (Platform.OS === 'android') {
+        const { READ_MEDIA_AUDIO, READ_EXTERNAL_STORAGE } = permissionModule.PERMISSIONS.ANDROID;
+        const permission = Platform.Version > 32 ? READ_MEDIA_AUDIO : READ_EXTERNAL_STORAGE;
+
+        const status = await permissionModule.check(permission);
+        if (status === 'granted') {
+          return true;
+        } else {
+          const status = await permissionModule.request(permission);
+          return status === 'granted';
+        }
+      } else {
+        return true;
+      }
+    };
+
+    public addPlaybackListener = (callback: PlaybackListener): Unsubscribe => {
+      this.playbackSubscribers.add(callback);
+      return () => {
+        this.playbackSubscribers.delete(callback);
+      };
+    };
+
+    public addStateListener = (callback: (state: PlayerServiceInterface['state']) => void): Unsubscribe => {
+      this.stateSubscribers.add(callback);
+      return () => {
+        this.stateSubscribers.delete(callback);
+      };
+    };
+
+    public play = async (uri: string): Promise<void> => {
+      if (matchesOneOf(this.state, ['idle', 'stopped'])) {
+        try {
+          this.setState('preparing');
+          this.uri = uri;
+          this.setListener();
+
+          // FIXME: Workaround, `module.startPlayer()` caused a significant frame-drop and prevented the 'preparing' UI transition.
+          await sleep(0);
+          await module.startPlayer(uri);
+
+          this.setState('playing');
+        } catch (e) {
+          this.setState('idle');
+          this.uri = undefined;
+          this.removeListener();
+          throw e;
+        }
+      } else if (matchesOneOf(this.state, ['paused']) && this.uri === uri) {
+        try {
+          this.setListener();
+          await module.resumePlayer();
+          this.setState('playing');
+        } catch (e) {
+          this.removeListener();
+          throw e;
+        }
+      }
+    };
+
+    public pause = async (): Promise<void> => {
+      if (matchesOneOf(this.state, ['playing'])) {
+        await module.pausePlayer();
+        this.removeListener();
+        this.setState('paused');
+      }
+    };
+
+    public stop = async (): Promise<void> => {
+      if (matchesOneOf(this.state, ['preparing', 'playing', 'paused'])) {
+        await module.stopPlayer();
+        this.removeListener();
+        this.setState('stopped');
+      }
+    };
+
+    public reset = async (): Promise<void> => {
+      await this.stop();
+      this.setState('idle');
+      this.uri = undefined;
+      this.playbackSubscribers.clear();
+      this.stateSubscribers.clear();
+    };
+
+    public seek = async (time: number): Promise<void> => {
+      if (matchesOneOf(this.state, ['playing', 'paused'])) {
+        await module.seekToPlayer(time);
+      }
+    };
+  }
+
+  return new VoicePlayer();
+};
+
+export default createNativePlayerService;

package/src/platform/createRecorderService.expo.tsx

@@ -0,0 +1,160 @@
+import * as ExpoAV from 'expo-av';
+import type { RecordingOptions } from 'expo-av/build/Audio/Recording.types';
+import { Platform } from 'react-native';
+
+import { matchesOneOf, sleep } from '@sendbird/uikit-utils';
+
+import VoiceMessageConfig from '../libs/VoiceMessageConfig';
+import expoPermissionGranted from '../utils/expoPermissionGranted';
+import type { RecorderServiceInterface, Unsubscribe } from './types';
+
+type RecordingListener = Parameters<RecorderServiceInterface['addRecordingListener']>[number];
+type StateListener = Parameters<RecorderServiceInterface['addStateListener']>[number];
+type Modules = {
+  avModule: typeof ExpoAV;
+};
+const createExpoRecorderService = ({ avModule }: Modules): RecorderServiceInterface => {
+  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;
+    };
+
+    private _recorder = new avModule.Audio.Recording();
+    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,
+      numberOfChannels: VoiceMessageConfig.DEFAULT.RECORDER.CHANNELS,
+      // encoding: mpeg4_aac
+    };
+    private readonly _audioOptions: RecordingOptions = {
+      android: {
+        ...this._audioSettings,
+        extension: `.${this.options.extension}`,
+        audioEncoder: avModule.Audio.AndroidAudioEncoder.AAC,
+        outputFormat: avModule.Audio.AndroidOutputFormat.MPEG_4,
+      },
+      ios: {
+        ...this._audioSettings,
+        extension: `.${this.options.extension}`,
+        outputFormat: avModule.Audio.IOSOutputFormat.MPEG4AAC,
+        audioQuality: avModule.Audio.IOSAudioQuality.HIGH,
+      },
+      web: {},
+    };
+
+    private prepare = async () => {
+      this.setState('preparing');
+      if (Platform.OS === 'ios') {
+        await avModule.Audio.setAudioModeAsync({ allowsRecordingIOS: true, playsInSilentModeIOS: true });
+      }
+
+      if (this._recorder._isDoneRecording) {
+        this._recorder = new avModule.Audio.Recording();
+      }
+      this._recorder.setProgressUpdateInterval(100);
+      this._recorder.setOnRecordingStatusUpdate((status) => {
+        const completed = status.durationMillis >= this.options.maxDuration;
+        if (completed) this.stop();
+        if (status.isRecording) {
+          this._recordingSubscribers.forEach((callback) => {
+            callback({ currentTime: status.durationMillis, completed: completed });
+          });
+        }
+      });
+      await this._recorder.prepareToRecordAsync(this._audioOptions);
+    };
+
+    private setState = (state: RecorderServiceInterface['state']) => {
+      this.state = state;
+      this._stateSubscribers.forEach((callback) => {
+        callback(state);
+      });
+    };
+
+    public requestPermission = async (): Promise<boolean> => {
+      const status = await avModule.Audio.getPermissionsAsync();
+      if (expoPermissionGranted([status])) {
+        return true;
+      } else {
+        const status = await avModule.Audio.requestPermissionsAsync();
+        return expoPermissionGranted([status]);
+      }
+    };
+
+    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 record = async (): Promise<void> => {
+      if (matchesOneOf(this.state, ['idle', 'completed'])) {
+        try {
+          await this.prepare();
+          await this._recorder.startAsync();
+
+          if (Platform.OS === 'android') {
+            this._recordStartedAt = Date.now();
+          }
+
+          const uri = this._recorder.getURI();
+          if (uri) this.uri = uri;
+          this.setState('recording');
+        } catch (e) {
+          this.setState('idle');
+          throw e;
+        }
+      }
+    };
+
+    public stop = async (): Promise<void> => {
+      if (matchesOneOf(this.state, ['recording'])) {
+        if (Platform.OS === 'android') {
+          const buffer = this._getRecorderStopSafeBuffer();
+          if (buffer > 0) await sleep(buffer);
+        }
+
+        await this._recorder.stopAndUnloadAsync();
+        if (Platform.OS === 'ios') {
+          await avModule.Audio.setAudioModeAsync({ allowsRecordingIOS: false, playsInSilentModeIOS: false });
+        }
+        this.setState('completed');
+      }
+    };
+
+    public reset = async (): Promise<void> => {
+      await this.stop();
+      this.uri = undefined;
+      this._recordingSubscribers.clear();
+      this._recorder = new avModule.Audio.Recording();
+      this.setState('idle');
+    };
+  }
+
+  return new VoiceRecorder();
+};
+
+export default createExpoRecorderService;