@umituz/react-native-sound 1.2.30 → 1.2.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-sound",
-  "version": "1.2.30",
+  "version": "1.2.32",
   "description": "Universal sound playback and caching library for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -35,10 +35,6 @@
   "devDependencies": {
     "@gorhom/bottom-sheet": "^5.2.8",
     "@react-native-async-storage/async-storage": "^2.2.0",
-    "@react-navigation/bottom-tabs": "^7.15.5",
-    "@react-navigation/elements": "^2.9.10",
-    "@react-navigation/native": "^7.1.33",
-    "@react-navigation/stack": "^7.8.5",
     "@tanstack/react-query": "^5.90.21",
     "@types/node": "^25.5.0",
     "@types/react": "~19.1.10",

package/src/application/SoundServiceFacade.ts

@@ -0,0 +1,112 @@
+/**
+ * Sound Service Facade - Simplified Interface
+ */
+
+import { AudioConfig } from '../infrastructure/AudioConfig';
+import { ExpoAudioService } from '../infrastructure/ExpoAudioService';
+import { SoundCache } from '../infrastructure/SoundCache';
+import { SoundPresenter } from './presenters/SoundPresenter';
+import { PlaySoundUseCase } from './use-cases/PlaySoundUseCase';
+import { PauseSoundUseCase } from './use-cases/PauseSoundUseCase';
+import { ResumeSoundUseCase } from './use-cases/ResumeSoundUseCase';
+import { StopSoundUseCase } from './use-cases/StopSoundUseCase';
+import { SeekSoundUseCase } from './use-cases/SeekSoundUseCase';
+import { SetVolumeUseCase } from './use-cases/SetVolumeUseCase';
+import { SetRateUseCase } from './use-cases/SetRateUseCase';
+import { PreloadSoundUseCase } from './use-cases/PreloadSoundUseCase';
+import { ClearCacheUseCase } from './use-cases/ClearCacheUseCase';
+
+export class SoundServiceFacade {
+    private static instance: SoundServiceFacade | null = null;
+
+    private readonly audioService = new ExpoAudioService();
+    private readonly cache = new SoundCache(this.audioService);
+    private readonly presenter: SoundPresenter;
+
+    private readonly playUseCase: PlaySoundUseCase;
+    private readonly pauseUseCase: PauseSoundUseCase;
+    private readonly resumeUseCase: ResumeSoundUseCase;
+    private readonly stopUseCase: StopSoundUseCase;
+    private readonly seekUseCase: SeekSoundUseCase;
+    private readonly setVolumeUseCase: SetVolumeUseCase;
+    private readonly setRateUseCase: SetRateUseCase;
+    private readonly preloadUseCase: PreloadSoundUseCase;
+    private readonly clearCacheUseCase: ClearCacheUseCase;
+
+    private constructor(store: SoundPresenter['store']) {
+        AudioConfig.configure().catch(() => {});
+
+        this.presenter = new SoundPresenter(store);
+
+        this.playUseCase = new PlaySoundUseCase(this.audioService, this.cache, this.presenter);
+        this.pauseUseCase = new PauseSoundUseCase(this.audioService, this.presenter);
+        this.resumeUseCase = new ResumeSoundUseCase(this.audioService, this.presenter);
+        this.stopUseCase = new StopSoundUseCase(this.audioService, this.presenter);
+        this.seekUseCase = new SeekSoundUseCase(this.audioService);
+        this.setVolumeUseCase = new SetVolumeUseCase(this.audioService, this.presenter);
+        this.setRateUseCase = new SetRateUseCase(this.audioService, this.presenter);
+        this.preloadUseCase = new PreloadSoundUseCase(this.audioService, this.cache);
+        this.clearCacheUseCase = new ClearCacheUseCase(this.cache);
+    }
+
+    static create(store: SoundPresenter['store']): SoundServiceFacade {
+        if (!this.instance) {
+            this.instance = new SoundServiceFacade(store);
+        }
+        return this.instance;
+    }
+
+    async play(id: string, source: any, options?: any): Promise<void> {
+        await this.playUseCase.execute({ id, source, ...options });
+    }
+
+    async pause(): Promise<void> {
+        const sound = this.playUseCase.getCurrentSound();
+        await this.pauseUseCase.execute({ sound });
+    }
+
+    async resume(): Promise<void> {
+        const sound = this.playUseCase.getCurrentSound();
+        await this.resumeUseCase.execute({ sound });
+    }
+
+    async stop(): Promise<void> {
+        const sound = this.playUseCase.getCurrentSound();
+        await this.stopUseCase.execute({ sound });
+    }
+
+    async seek(positionMillis: number): Promise<void> {
+        const sound = this.playUseCase.getCurrentSound();
+        await this.seekUseCase.execute({ sound, positionMillis });
+    }
+
+    async setVolume(volume: number): Promise<void> {
+        const sound = this.playUseCase.getCurrentSound();
+        await this.setVolumeUseCase.execute({ sound, volume });
+    }
+
+    async setRate(rate: number): Promise<void> {
+        const sound = this.playUseCase.getCurrentSound();
+        await this.setRateUseCase.execute({ sound, rate });
+    }
+
+    async preload(id: string, source: any, options?: any): Promise<void> {
+        await this.preloadUseCase.execute({ id, source, ...options });
+    }
+
+    async unload(): Promise<void> {
+        await this.playUseCase.unload();
+    }
+
+    clearCache(): void {
+        this.clearCacheUseCase.execute();
+    }
+
+    isCached(id: string): boolean {
+        return this.cache.has(id);
+    }
+
+    getCurrentId(): string | null {
+        return this.playUseCase.getCurrentId();
+    }
+}

package/src/application/interfaces/IAudioService.ts

@@ -0,0 +1,42 @@
+/**
+ * Audio Service Interface
+ */
+
+import type { AVPlaybackStatus } from 'expo-av';
+import { SoundSourceValue } from '../../domain/value-objects/SoundSource';
+
+export interface PlaybackStatus {
+    isLoaded: boolean;
+    isPlaying: boolean;
+    isBuffering: boolean;
+    positionMillis: number;
+    durationMillis: number;
+    rate?: number;
+    isLooping: boolean;
+    didJustFinish: boolean;
+    error?: string;
+}
+
+export interface PlaybackOptions {
+    shouldPlay: boolean;
+    isLooping: boolean;
+    volume: number;
+    rate: number;
+    positionMillis?: number;
+}
+
+export interface IAudioService {
+    createSound(
+        source: SoundSourceValue,
+        options: PlaybackOptions,
+        onStatusUpdate: (status: PlaybackStatus) => void
+    ): Promise<{ sound: unknown }>;
+    play(sound: unknown): Promise<void>;
+    pause(sound: unknown): Promise<void>;
+    stop(sound: unknown): Promise<void>;
+    unload(sound: unknown): Promise<void>;
+    setVolume(sound: unknown, volume: number): Promise<void>;
+    setRate(sound: unknown, rate: number): Promise<void>;
+    setPosition(sound: unknown, positionMillis: number): Promise<void>;
+    getStatus(sound: unknown): Promise<PlaybackStatus | null>;
+}

package/src/application/interfaces/ISoundCache.ts

@@ -0,0 +1,21 @@
+/**
+ * Sound Cache Interface
+ */
+
+import { SoundSourceValue } from '../../domain/value-objects/SoundSource';
+
+export interface CachedSound {
+    sound: unknown;
+    source: SoundSourceValue;
+    loadedAt: number;
+}
+
+export interface ISoundCache {
+    get(id: string): CachedSound | undefined;
+    set(id: string, cached: CachedSound): void;
+    delete(id: string): void;
+    has(id: string): boolean;
+    clear(): void;
+    cleanExpired(): void;
+    enforceLimit(): void;
+}

package/src/application/presenters/SoundPresenter.ts

@@ -0,0 +1,78 @@
+/**
+ * Sound Presenter - Manages Store Updates
+ */
+
+import { PlaybackStatus } from '../interfaces/IAudioService';
+import { SoundSourceValue } from '../../domain/value-objects/SoundSource';
+import { Logger } from '../../infrastructure/Logger';
+
+export interface SoundStore {
+    setPlaying: (isPlaying: boolean) => void;
+    setBuffering: (isBuffering: boolean) => void;
+    setProgress: (position: number, duration: number) => void;
+    setError: (error: string | null) => void;
+    setCurrent: (id: string | null, source: SoundSourceValue | null) => void;
+    setVolumeState: (volume: number) => void;
+    setRateState: (rate: number) => void;
+    setLooping: (isLooping: boolean) => void;
+    reset: () => void;
+}
+
+export class SoundPresenter {
+    constructor(private readonly store: SoundStore) {}
+
+    onPlaybackUpdate(status: PlaybackStatus): void {
+        if (!status.isLoaded && status.error) {
+            this.store.setError(status.error);
+            this.store.setPlaying(false);
+            return;
+        }
+
+        if (status.isLoaded) {
+            this.store.setPlaying(status.isPlaying);
+            this.store.setBuffering(status.isBuffering);
+            this.store.setProgress(status.positionMillis, status.durationMillis);
+
+            if (status.rate !== undefined) {
+                this.store.setRateState(status.rate);
+            }
+
+            if (status.didJustFinish && !status.isLooping) {
+                this.store.setPlaying(false);
+                this.store.setProgress(status.durationMillis, status.durationMillis);
+            }
+        }
+    }
+
+    onPlaybackStart(id: string, source: SoundSourceValue, options: { volume: number; rate: number; isLooping: boolean }): void {
+        this.store.setCurrent(id, source);
+        this.store.setError(null);
+        this.store.setVolumeState(options.volume);
+        this.store.setRateState(options.rate);
+        this.store.setLooping(options.isLooping);
+        Logger.debug(`Playback started: ${id}`);
+    }
+
+    onPlaybackError(error: string): void {
+        this.store.setError(error);
+        Logger.error('Playback error', error);
+    }
+
+    onPlaybackStop(): void {
+        this.store.setPlaying(false);
+        Logger.debug('Playback stopped');
+    }
+
+    onVolumeChange(volume: number): void {
+        this.store.setVolumeState(volume);
+    }
+
+    onRateChange(rate: number): void {
+        this.store.setRateState(rate);
+    }
+
+    onReset(): void {
+        this.store.reset();
+        Logger.debug('State reset');
+    }
+}

package/src/application/use-cases/BaseUseCase.ts

@@ -0,0 +1,36 @@
+/**
+ * Base Use Case - Common Error Handling
+ */
+
+import { SoundError } from '../../domain/errors/SoundError';
+import { Logger } from '../../infrastructure/Logger';
+
+export abstract class BaseUseCase<TInput, TOutput> {
+    async execute(input: TInput): Promise<TOutput> {
+        try {
+            return await this.executeImpl(input);
+        } catch (error) {
+            if (error instanceof SoundError) {
+                throw error;
+            }
+            throw SoundError.playbackFailed(error);
+        }
+    }
+
+    protected abstract executeImpl(input: TInput): Promise<TOutput>;
+}
+
+export abstract class BaseVoidUseCase<TInput> {
+    async execute(input: TInput): Promise<void> {
+        try {
+            await this.executeImpl(input);
+        } catch (error) {
+            if (error instanceof SoundError) {
+                throw error;
+            }
+            throw SoundError.playbackFailed(error);
+        }
+    }
+
+    protected abstract executeImpl(input: TInput): Promise<void>;
+}

package/src/application/use-cases/ClearCacheUseCase.ts

@@ -0,0 +1,16 @@
+/**
+ * Clear Cache Use Case
+ */
+
+import { BaseVoidUseCase } from './BaseUseCase';
+import type { ISoundCache } from '../interfaces/ISoundCache';
+
+export class ClearCacheUseCase extends BaseVoidUseCase<void> {
+    constructor(private readonly cache: ISoundCache) {
+        super();
+    }
+
+    protected async executeImpl(): Promise<void> {
+        this.cache.clear();
+    }
+}

package/src/application/use-cases/PauseSoundUseCase.ts

@@ -0,0 +1,26 @@
+/**
+ * Pause Sound Use Case
+ */
+
+import { BaseVoidUseCase } from './BaseUseCase';
+import type { IAudioService } from '../interfaces/IAudioService';
+import { SoundPresenter } from '../presenters/SoundPresenter';
+
+interface PauseSoundInput {
+    sound: unknown;
+}
+
+export class PauseSoundUseCase extends BaseVoidUseCase<PauseSoundInput> {
+    constructor(
+        private readonly audioService: IAudioService,
+        private readonly presenter: SoundPresenter
+    ) {
+        super();
+    }
+
+    protected async executeImpl(input: PauseSoundInput): Promise<void> {
+        if (!input.sound) return;
+        await this.audioService.pause(input.sound);
+        this.presenter.onPlaybackStop();
+    }
+}

package/src/application/use-cases/PlaySoundUseCase.ts

@@ -0,0 +1,106 @@
+/**
+ * Play Sound Use Case
+ */
+
+import { BaseVoidUseCase } from './BaseUseCase';
+import { SoundId } from '../../domain/value-objects/SoundId';
+import { SoundSource } from '../../domain/value-objects/SoundSource';
+import { Volume } from '../../domain/value-objects/Volume';
+import { Rate } from '../../domain/value-objects/Rate';
+import type { IAudioService } from '../interfaces/IAudioService';
+import type { ISoundCache } from '../interfaces/ISoundCache';
+import { SoundPresenter } from '../presenters/SoundPresenter';
+
+interface PlaySoundInput {
+    id: string;
+    source: number | { uri: string; headers?: Record<string, string> };
+    volume?: number;
+    rate?: number;
+    isLooping?: boolean;
+    positionMillis?: number;
+}
+
+export class PlaySoundUseCase extends BaseVoidUseCase<PlaySoundInput> {
+    private currentSound: unknown | null = null;
+    private currentId: string | null = null;
+
+    constructor(
+        private readonly audioService: IAudioService,
+        private readonly cache: ISoundCache,
+        private readonly presenter: SoundPresenter
+    ) {
+        super();
+    }
+
+    protected async executeImpl(input: PlaySoundInput): Promise<void> {
+        const soundId = new SoundId(input.id);
+        const soundSource = new SoundSource(input.source);
+        const volume = new Volume(input.volume ?? 1.0);
+        const rate = new Rate(input.rate ?? 1.0);
+
+        // Toggle if same sound
+        if (this.currentId === soundId.toString() && this.currentSound) {
+            const status = await this.audioService.getStatus(this.currentSound);
+            if (status?.isPlaying) {
+                await this.audioService.pause(this.currentSound);
+                this.presenter.onPlaybackStop();
+                return;
+            }
+        }
+
+        // Unload current
+        if (this.currentSound) {
+            await this.audioService.unload(this.currentSound);
+        }
+
+        // Try cache first
+        const cached = this.cache.get(soundId.toString());
+        if (cached) {
+            this.currentSound = cached.sound;
+            this.cache.delete(soundId.toString());
+        } else {
+            const { sound } = await this.audioService.createSound(
+                soundSource.getValue(),
+                {
+                    shouldPlay: true,
+                    isLooping: input.isLooping ?? false,
+                    volume: volume.getValue(),
+                    rate: rate.getValue(),
+                    positionMillis: input.positionMillis,
+                },
+                (status) => this.presenter.onPlaybackUpdate(status)
+            );
+            this.currentSound = sound;
+        }
+
+        await this.audioService.play(this.currentSound);
+        this.currentId = soundId.toString();
+
+        this.presenter.onPlaybackStart(
+            soundId.toString(),
+            soundSource.getValue(),
+            {
+                volume: volume.getValue(),
+                rate: rate.getValue(),
+                isLooping: input.isLooping ?? false,
+            }
+        );
+    }
+
+    getCurrentSound(): unknown | null {
+        return this.currentSound;
+    }
+
+    getCurrentId(): string | null {
+        return this.currentId;
+    }
+
+    async unload(): Promise<void> {
+        if (this.currentSound) {
+            await this.audioService.unload(this.currentSound);
+        }
+        this.currentSound = null;
+        this.currentId = null;
+        this.presenter.onReset();
+    }
+}

package/src/application/use-cases/PreloadSoundUseCase.ts

@@ -0,0 +1,56 @@
+/**
+ * Preload Sound Use Case
+ */
+
+import { BaseVoidUseCase } from './BaseUseCase';
+import { SoundId } from '../../domain/value-objects/SoundId';
+import { SoundSource } from '../../domain/value-objects/SoundSource';
+import { Volume } from '../../domain/value-objects/Volume';
+import { Rate } from '../../domain/value-objects/Rate';
+import type { IAudioService } from '../interfaces/IAudioService';
+import type { ISoundCache } from '../interfaces/ISoundCache';
+
+interface PreloadSoundInput {
+    id: string;
+    source: number | { uri: string; headers?: Record<string, string> };
+    volume?: number;
+    rate?: number;
+    isLooping?: boolean;
+}
+
+export class PreloadSoundUseCase extends BaseVoidUseCase<PreloadSoundInput> {
+    constructor(
+        private readonly audioService: IAudioService,
+        private readonly cache: ISoundCache
+    ) {
+        super();
+    }
+
+    protected async executeImpl(input: PreloadSoundInput): Promise<void> {
+        const soundId = new SoundId(input.id);
+        const soundSource = new SoundSource(input.source);
+        const volume = new Volume(input.volume ?? 1.0);
+        const rate = new Rate(input.rate ?? 1.0);
+
+        if (this.cache.has(soundId.toString())) {
+            return;
+        }
+
+        const { sound } = await this.audioService.createSound(
+            soundSource.getValue(),
+            {
+                shouldPlay: false,
+                isLooping: input.isLooping ?? false,
+                volume: volume.getValue(),
+                rate: rate.getValue(),
+            },
+            () => {}
+        );
+
+        this.cache.set(soundId.toString(), {
+            sound,
+            source: soundSource.getValue(),
+            loadedAt: Date.now(),
+        });
+    }
+}

package/src/application/use-cases/ResumeSoundUseCase.ts

@@ -0,0 +1,25 @@
+/**
+ * Resume Sound Use Case
+ */
+
+import { BaseVoidUseCase } from './BaseUseCase';
+import type { IAudioService } from '../interfaces/IAudioService';
+import { SoundPresenter } from '../presenters/SoundPresenter';
+
+interface ResumeSoundInput {
+    sound: unknown;
+}
+
+export class ResumeSoundUseCase extends BaseVoidUseCase<ResumeSoundInput> {
+    constructor(
+        private readonly audioService: IAudioService,
+        private readonly presenter: SoundPresenter
+    ) {
+        super();
+    }
+
+    protected async executeImpl(input: ResumeSoundInput): Promise<void> {
+        if (!input.sound) return;
+        await this.audioService.play(input.sound);
+    }
+}

package/src/application/use-cases/SeekSoundUseCase.ts

@@ -0,0 +1,26 @@
+/**
+ * Seek Sound Use Case
+ */
+
+import { BaseVoidUseCase } from './BaseUseCase';
+import { PlaybackPosition } from '../../domain/value-objects/PlaybackPosition';
+import type { IAudioService } from '../interfaces/IAudioService';
+
+interface SeekSoundInput {
+    sound: unknown;
+    positionMillis: number;
+    durationMillis?: number;
+}
+
+export class SeekSoundUseCase extends BaseVoidUseCase<SeekSoundInput> {
+    constructor(private readonly audioService: IAudioService) {
+        super();
+    }
+
+    protected async executeImpl(input: SeekSoundInput): Promise<void> {
+        if (!input.sound) return;
+
+        const position = new PlaybackPosition(input.positionMillis, input.durationMillis);
+        await this.audioService.setPosition(input.sound, position.getValue());
+    }
+}

package/src/application/use-cases/SetRateUseCase.ts

@@ -0,0 +1,30 @@
+/**
+ * Set Rate Use Case
+ */
+
+import { BaseVoidUseCase } from './BaseUseCase';
+import { Rate } from '../../domain/value-objects/Rate';
+import type { IAudioService } from '../interfaces/IAudioService';
+import { SoundPresenter } from '../presenters/SoundPresenter';
+
+interface SetRateInput {
+    sound: unknown;
+    rate: number;
+}
+
+export class SetRateUseCase extends BaseVoidUseCase<SetRateInput> {
+    constructor(
+        private readonly audioService: IAudioService,
+        private readonly presenter: SoundPresenter
+    ) {
+        super();
+    }
+
+    protected async executeImpl(input: SetRateInput): Promise<void> {
+        if (!input.sound) return;
+
+        const rate = new Rate(input.rate);
+        await this.audioService.setRate(input.sound, rate.getValue());
+        this.presenter.onRateChange(rate.getValue());
+    }
+}

package/src/application/use-cases/SetVolumeUseCase.ts

@@ -0,0 +1,30 @@
+/**
+ * Set Volume Use Case
+ */
+
+import { BaseVoidUseCase } from './BaseUseCase';
+import { Volume } from '../../domain/value-objects/Volume';
+import type { IAudioService } from '../interfaces/IAudioService';
+import { SoundPresenter } from '../presenters/SoundPresenter';
+
+interface SetVolumeInput {
+    sound: unknown;
+    volume: number;
+}
+
+export class SetVolumeUseCase extends BaseVoidUseCase<SetVolumeInput> {
+    constructor(
+        private readonly audioService: IAudioService,
+        private readonly presenter: SoundPresenter
+    ) {
+        super();
+    }
+
+    protected async executeImpl(input: SetVolumeInput): Promise<void> {
+        if (!input.sound) return;
+
+        const volume = new Volume(input.volume);
+        await this.audioService.setVolume(input.sound, volume.getValue());
+        this.presenter.onVolumeChange(volume.getValue());
+    }
+}

package/src/application/use-cases/StopSoundUseCase.ts

@@ -0,0 +1,27 @@
+/**
+ * Stop Sound Use Case
+ */
+
+import { BaseVoidUseCase } from './BaseUseCase';
+import type { IAudioService } from '../interfaces/IAudioService';
+import { SoundPresenter } from '../presenters/SoundPresenter';
+
+interface StopSoundInput {
+    sound: unknown;
+}
+
+export class StopSoundUseCase extends BaseVoidUseCase<StopSoundInput> {
+    constructor(
+        private readonly audioService: IAudioService,
+        private readonly presenter: SoundPresenter
+    ) {
+        super();
+    }
+
+    protected async executeImpl(input: StopSoundInput): Promise<void> {
+        if (!input.sound) return;
+        await this.audioService.stop(input.sound);
+        this.presenter.onPlaybackStop();
+        this.presenter.onReset();
+    }
+}