@sendbird/uikit-react-native 3.10.3 → 3.11.1

package/src/platform/createPlayerService.expo.tsx

@@ -1,148 +1,281 @@
+import type * as ExpoAudio from 'expo-audio';
 import type * as ExpoAV from 'expo-av';
 
 import { Logger, matchesOneOf } from '@sendbird/uikit-utils';
 
-import expoPermissionGranted from '../utils/expoPermissionGranted';
+import expoBackwardUtils from '../utils/expoBackwardUtils';
+import type { ExpoAudioModule } from '../utils/expoBackwardUtils';
 import type { PlayerServiceInterface, Unsubscribe } from './types';
 
 type Modules = {
-  avModule: typeof ExpoAV;
+  avModule: ExpoAudioModule;
 };
 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';
+interface AudioPlayerAdapter {
+  requestPermission(): Promise<boolean>;
+  play(uri: string): Promise<void>;
+  pause(): Promise<void>;
+  stop(): Promise<void>;
+  reset(): Promise<void>;
+  seek(time: number): Promise<void>;
+  addPlaybackListener(callback: PlaybackListener): Unsubscribe;
+  addStateListener(callback: StateListener): Unsubscribe;
+  readonly state: PlayerServiceInterface['state'];
+  uri?: string;
+}
+
+abstract class BaseAudioPlayerAdapter implements AudioPlayerAdapter {
+  uri?: string;
+  state: PlayerServiceInterface['state'] = 'idle';
+
+  protected readonly playbackSubscribers = new Set<PlaybackListener>();
+  protected readonly stateSubscribers = new Set<StateListener>();
 
-    private readonly playbackSubscribers = new Set<PlaybackListener>();
-    private readonly stateSubscribers = new Set<StateListener>();
+  protected setState = (state: PlayerServiceInterface['state']) => {
+    this.state = state;
+    this.stateSubscribers.forEach((callback) => {
+      callback(state);
+    });
+  };
 
-    private setState = (state: PlayerServiceInterface['state']) => {
-      this.state = state;
-      this.stateSubscribers.forEach((callback) => {
-        callback(state);
-      });
+  public requestPermission = async (): Promise<boolean> => {
+    return true;
+  };
+
+  public addPlaybackListener = (callback: PlaybackListener): Unsubscribe => {
+    this.playbackSubscribers.add(callback);
+    return () => {
+      this.playbackSubscribers.delete(callback);
     };
+  };
 
-    private setListener = () => {
-      sound.setProgressUpdateIntervalAsync(100).catch((error) => {
-        Logger.warn('[PlayerService.Expo] Failed to set progress update interval', error);
-      });
-      sound.setOnPlaybackStatusUpdate((status) => {
-        if (status.isLoaded) {
-          if (status.didJustFinish) {
-            this.stop().catch((error) => {
-              Logger.warn('[PlayerService.Expo] Failed to stop in OnPlaybackStatusUpdate', error);
-            });
-          }
-          if (status.isPlaying) {
-            this.playbackSubscribers.forEach((callback) => {
-              callback({
-                currentTime: status.positionMillis,
-                duration: status.durationMillis ?? 0,
-                stopped: status.didJustFinish,
-              });
+  public addStateListener = (callback: StateListener): Unsubscribe => {
+    this.stateSubscribers.add(callback);
+    return () => {
+      this.stateSubscribers.delete(callback);
+    };
+  };
+
+  abstract play(uri: string): Promise<void>;
+  abstract pause(): Promise<void>;
+  abstract stop(): Promise<void>;
+  abstract reset(): Promise<void>;
+  abstract seek(time: number): Promise<void>;
+}
+
+class LegacyExpoAVPlayerAdapter extends BaseAudioPlayerAdapter {
+  private readonly sound: ExpoAV.Audio.Sound;
+
+  constructor(avModule: typeof ExpoAV) {
+    super();
+    this.sound = new avModule.Audio.Sound();
+  }
+
+  private setListener = () => {
+    this.sound.setProgressUpdateIntervalAsync(100).catch((error) => {
+      Logger.warn('[PlayerService.Expo] Failed to set progress update interval', error);
+    });
+    this.sound.setOnPlaybackStatusUpdate((status) => {
+      if (status.isLoaded) {
+        if (status.didJustFinish) {
+          this.stop().catch((error) => {
+            Logger.warn('[PlayerService.Expo] Failed to stop in OnPlaybackStatusUpdate', error);
+          });
+        }
+        if (status.isPlaying) {
+          this.playbackSubscribers.forEach((callback) => {
+            callback({
+              currentTime: status.positionMillis,
+              duration: status.durationMillis ?? 0,
+              stopped: status.didJustFinish,
             });
-          }
+          });
         }
-      });
-    };
+      }
+    });
+  };
 
-    private removeListener = () => {
-      sound.setOnPlaybackStatusUpdate(null);
-    };
+  private removeListener = () => {
+    this.sound.setOnPlaybackStatusUpdate(null);
+  };
+
+  private prepare = async (uri: string) => {
+    this.setState('preparing');
+    await this.sound.loadAsync({ uri }, { shouldPlay: false }, true);
+    this.uri = uri;
+  };
 
-    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 play = async (uri: string): Promise<void> => {
+    if (matchesOneOf(this.state, ['idle', 'stopped'])) {
+      try {
+        await this.prepare(uri);
+        this.setListener();
+        await this.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 this.sound.playAsync();
+        this.setState('playing');
+      } catch (e) {
+        this.removeListener();
+        throw e;
+      }
+    }
+  };
 
-    public addPlaybackListener = (callback: PlaybackListener): Unsubscribe => {
-      this.playbackSubscribers.add(callback);
-      return () => {
-        this.playbackSubscribers.delete(callback);
-      };
-    };
+  public pause = async (): Promise<void> => {
+    if (matchesOneOf(this.state, ['playing'])) {
+      await this.sound.pauseAsync();
+      this.removeListener();
+      this.setState('paused');
+    }
+  };
 
-    public addStateListener = (callback: (state: PlayerServiceInterface['state']) => void): Unsubscribe => {
-      this.stateSubscribers.add(callback);
-      return () => {
-        this.stateSubscribers.delete(callback);
-      };
-    };
+  public stop = async (): Promise<void> => {
+    if (matchesOneOf(this.state, ['playing', 'paused'])) {
+      await this.sound.stopAsync();
+      await this.sound.unloadAsync();
+      this.removeListener();
+      this.setState('stopped');
+    }
+  };
 
-    private prepare = async (uri: string) => {
-      this.setState('preparing');
-      await sound.loadAsync({ uri }, { shouldPlay: false }, true);
-      this.uri = uri;
-    };
+  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 this.sound.playFromPositionAsync(time);
+    }
+  };
+}
+
+class ExpoAudioPlayerAdapter extends BaseAudioPlayerAdapter {
+  private readonly audioModule: typeof ExpoAudio;
+  private player: ExpoAudio.AudioPlayer | null = null;
+
+  constructor(audioModule: typeof ExpoAudio) {
+    super();
+    this.audioModule = audioModule;
+  }
 
-    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;
+  private setListener = () => {
+    if (!this.player) return;
+
+    this.player.addListener('playbackStatusUpdate', (status) => {
+      if (status.isLoaded) {
+        if (status.didJustFinish) {
+          this.stop().catch((error) => {
+            Logger.warn('[PlayerService.Expo] Failed to stop in playbackStatusUpdate', error);
+          });
         }
-      } else if (matchesOneOf(this.state, ['paused']) && this.uri === uri) {
-        try {
-          this.setListener();
-          await sound.playAsync();
-          this.setState('playing');
-        } catch (e) {
-          this.removeListener();
-          throw e;
+        if (status.playing) {
+          this.playbackSubscribers.forEach((callback) => {
+            callback({
+              currentTime: status.currentTime,
+              duration: status.duration ?? 0,
+              stopped: status.didJustFinish,
+            });
+          });
         }
       }
-    };
+    });
+  };
+
+  private removeListener = () => {
+    if (this.player) {
+      this.player.remove();
+    }
+  };
+
+  private prepare = async (uri: string) => {
+    this.setState('preparing');
+    this.player = this.audioModule.createAudioPlayer(uri, { updateInterval: 100 });
+    this.uri = uri;
+  };
 
-    public pause = async (): Promise<void> => {
-      if (matchesOneOf(this.state, ['playing'])) {
-        await sound.pauseAsync();
+  public play = async (uri: string): Promise<void> => {
+    if (matchesOneOf(this.state, ['idle', 'stopped'])) {
+      try {
+        await this.prepare(uri);
+        this.setListener();
+        this.player?.play();
+        this.setState('playing');
+      } catch (e) {
+        this.setState('idle');
+        this.uri = undefined;
         this.removeListener();
-        this.setState('paused');
+        throw e;
       }
-    };
-
-    public stop = async (): Promise<void> => {
-      if (matchesOneOf(this.state, ['playing', 'paused'])) {
-        await sound.stopAsync();
-        await sound.unloadAsync();
+    } else if (matchesOneOf(this.state, ['paused']) && this.uri === uri) {
+      try {
+        this.setListener();
+        this.player?.play();
+        this.setState('playing');
+      } catch (e) {
         this.removeListener();
-        this.setState('stopped');
+        throw e;
       }
-    };
+    }
+  };
 
-    public reset = async (): Promise<void> => {
-      await this.stop();
-      this.setState('idle');
-      this.uri = undefined;
-      this.playbackSubscribers.clear();
-      this.stateSubscribers.clear();
-    };
+  public pause = async (): Promise<void> => {
+    if (matchesOneOf(this.state, ['playing'])) {
+      this.player?.pause();
+      this.removeListener();
+      this.setState('paused');
+    }
+  };
 
-    public seek = async (time: number): Promise<void> => {
-      if (matchesOneOf(this.state, ['playing', 'paused'])) {
-        await sound.playFromPositionAsync(time);
-      }
-    };
+  public stop = async (): Promise<void> => {
+    if (matchesOneOf(this.state, ['playing', 'paused'])) {
+      this.player?.pause();
+      this.removeListener();
+      this.setState('stopped');
+    }
+  };
+
+  public reset = async (): Promise<void> => {
+    await this.stop();
+    this.player?.remove();
+    this.player = null;
+    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']) && this.player) {
+      this.player.currentTime = time;
+    }
+  };
+}
+
+const createExpoPlayerService = ({ avModule }: Modules): PlayerServiceInterface => {
+  if (expoBackwardUtils.expoAV.isLegacyAVModule(avModule)) {
+    Logger.warn(
+      '[PlayerService.Expo] expo-av is deprecated and will be removed in Expo 54. Please migrate to expo-audio.',
+    );
   }
 
-  return new VoicePlayer();
+  return expoBackwardUtils.expoAV.isAudioModule(avModule)
+    ? new ExpoAudioPlayerAdapter(avModule)
+    : new LegacyExpoAVPlayerAdapter(avModule);
 };
 
 export default createExpoPlayerService;