@umituz/react-native-sound 1.2.30 → 1.2.32

package/src/domain/entities/SoundState.ts

@@ -0,0 +1,83 @@
+/**
+ * Sound State Entity
+ */
+
+import { SoundSource } from '../value-objects/SoundSource';
+import { Volume } from '../value-objects/Volume';
+import { Rate } from '../value-objects/Rate';
+
+export interface SoundStateData {
+    isPlaying: boolean;
+    isBuffering: boolean;
+    positionMillis: number;
+    durationMillis: number;
+    volume: number;
+    rate: number;
+    isLooping: boolean;
+    error: string | null;
+    currentSource: SoundSource | null;
+    currentId: string | null;
+}
+
+export class SoundState {
+    constructor(private data: SoundStateData) {}
+
+    isPlaying(): boolean {
+        return this.data.isPlaying;
+    }
+
+    isBuffering(): boolean {
+        return this.data.isBuffering;
+    }
+
+    getPosition(): number {
+        return this.data.positionMillis;
+    }
+
+    getDuration(): number {
+        return this.data.durationMillis;
+    }
+
+    getVolume(): number {
+        return this.data.volume;
+    }
+
+    getRate(): number {
+        return this.data.rate;
+    }
+
+    isLooping(): boolean {
+        return this.data.isLooping;
+    }
+
+    getError(): string | null {
+        return this.data.error;
+    }
+
+    getCurrentSource(): SoundSource | null {
+        return this.data.currentSource;
+    }
+
+    getCurrentId(): string | null {
+        return this.data.currentId;
+    }
+
+    toData(): SoundStateData {
+        return { ...this.data };
+    }
+
+    static createEmpty(): SoundState {
+        return new SoundState({
+            isPlaying: false,
+            isBuffering: false,
+            positionMillis: 0,
+            durationMillis: 0,
+            volume: 1.0,
+            rate: 1.0,
+            isLooping: false,
+            error: null,
+            currentSource: null,
+            currentId: null,
+        });
+    }
+}

package/src/domain/errors/SoundError.ts

@@ -0,0 +1,44 @@
+/**
+ * Domain Errors for Sound Operations
+ */
+
+export enum SoundErrorCode {
+    INVALID_SOUND_ID = 'INVALID_SOUND_ID',
+    INVALID_SOUND_SOURCE = 'INVALID_SOUND_SOURCE',
+    PLAYBACK_FAILED = 'PLAYBACK_FAILED',
+    SOUND_NOT_LOADED = 'SOUND_NOT_LOADED',
+    INVALID_POSITION = 'INVALID_POSITION',
+    CACHE_ERROR = 'CACHE_ERROR',
+}
+
+export class SoundError extends Error {
+    constructor(
+        public readonly code: SoundErrorCode,
+        message: string,
+        public readonly originalError?: unknown
+    ) {
+        super(message);
+        this.name = 'SoundError';
+    }
+
+    static invalidSoundId(): SoundError {
+        return new SoundError(SoundErrorCode.INVALID_SOUND_ID, 'Sound id must be a non-empty string');
+    }
+
+    static invalidSoundSource(): SoundError {
+        return new SoundError(SoundErrorCode.INVALID_SOUND_SOURCE, 'Sound source cannot be null or undefined');
+    }
+
+    static playbackFailed(error: unknown): SoundError {
+        const message = error instanceof Error ? error.message : 'Unknown playback error';
+        return new SoundError(SoundErrorCode.PLAYBACK_FAILED, message, error);
+    }
+
+    static soundNotLoaded(): SoundError {
+        return new SoundError(SoundErrorCode.SOUND_NOT_LOADED, 'Sound is not loaded');
+    }
+
+    static invalidPosition(): SoundError {
+        return new SoundError(SoundErrorCode.INVALID_POSITION, 'Position must be a finite number');
+    }
+}

package/src/domain/value-objects/PlaybackPosition.ts

@@ -0,0 +1,30 @@
+/**
+ * Playback Position Value Object
+ */
+
+import { SoundError } from '../errors/SoundError';
+
+export class PlaybackPosition {
+    private readonly value: number;
+    private readonly duration?: number;
+
+    constructor(value: number, duration?: number) {
+        if (!Number.isFinite(value)) {
+            throw SoundError.invalidPosition();
+        }
+        this.value = duration ? this.clamp(value, duration) : value;
+        this.duration = duration;
+    }
+
+    private clamp(value: number, max: number): number {
+        return Math.max(0, Math.min(max, value));
+    }
+
+    getValue(): number {
+        return this.value;
+    }
+
+    getDuration(): number | undefined {
+        return this.duration;
+    }
+}

package/src/domain/value-objects/Rate.ts

@@ -0,0 +1,26 @@
+/**
+ * Rate Value Object
+ */
+
+export class Rate {
+    private readonly MIN = 0.5;
+    private readonly MAX = 2.0;
+    private readonly value: number;
+
+    constructor(value: number) {
+        this.value = this.clamp(value);
+    }
+
+    private clamp(value: number): number {
+        if (!Number.isFinite(value)) return 1.0;
+        return Math.max(this.MIN, Math.min(this.MAX, value));
+    }
+
+    getValue(): number {
+        return this.value;
+    }
+
+    equals(other: Rate): boolean {
+        return this.value === other.value;
+    }
+}

package/src/domain/value-objects/SoundId.ts

@@ -0,0 +1,22 @@
+/**
+ * Sound ID Value Object
+ */
+
+export class SoundId {
+    private readonly value: string;
+
+    constructor(value: string) {
+        if (typeof value !== 'string' || value.trim().length === 0) {
+            throw new Error('Sound id must be a non-empty string');
+        }
+        this.value = value.trim();
+    }
+
+    toString(): string {
+        return this.value;
+    }
+
+    equals(other: SoundId): boolean {
+        return this.value === other.value;
+    }
+}

package/src/domain/value-objects/SoundSource.ts

@@ -0,0 +1,30 @@
+/**
+ * Sound Source Value Object
+ */
+
+import { SoundError } from '../errors/SoundError';
+
+export type SoundSourceValue = number | { uri: string; headers?: Record<string, string> };
+
+export class SoundSource {
+    private readonly value: SoundSourceValue;
+
+    constructor(value: SoundSourceValue | null | undefined) {
+        if (value === null || value === undefined) {
+            throw SoundError.invalidSoundSource();
+        }
+        this.value = value;
+    }
+
+    getValue(): SoundSourceValue {
+        return this.value;
+    }
+
+    isLocal(): boolean {
+        return typeof this.value === 'number';
+    }
+
+    isRemote(): boolean {
+        return typeof this.value === 'object' && 'uri' in this.value;
+    }
+}

package/src/domain/value-objects/Volume.ts

@@ -0,0 +1,26 @@
+/**
+ * Volume Value Object
+ */
+
+export class Volume {
+    private readonly MIN = 0;
+    private readonly MAX = 1;
+    private readonly value: number;
+
+    constructor(value: number) {
+        this.value = this.clamp(value);
+    }
+
+    private clamp(value: number): number {
+        if (!Number.isFinite(value)) return 1.0;
+        return Math.max(this.MIN, Math.min(this.MAX, value));
+    }
+
+    getValue(): number {
+        return this.value;
+    }
+
+    equals(other: Volume): boolean {
+        return this.value === other.value;
+    }
+}

package/src/index.ts

@@ -1,11 +1,41 @@
-export type { SoundSource, PlaybackOptions, SoundState } from './types';
+/**
+ * @umituz/react-native-sound
+ * DDD-based audio management for React Native
+ */
+
+// Public API
+export { useSound } from './presentation/hooks/useSound';
+export { useSoundStore } from './presentation/store';
+
+// Types
+export type { PlaybackOptions, SoundState, SoundSource } from './types';
+
+// Utilities (backward compatibility)
 export {
-    isPlaybackStatusSuccess,
-    isSoundSourceValid,
     clampVolume,
     clampRate,
     validateSoundId,
+    isSoundSourceValid,
+    isPlaybackStatusSuccess,
 } from './utils';
-export { audioManager } from './AudioManager';
-export { useSound } from './useSound';
-export { useSoundStore } from './store';
+
+// Domain exports (for advanced usage)
+export { SoundError } from './domain/errors/SoundError';
+export { SoundId } from './domain/value-objects/SoundId';
+export { SoundSource as SoundSourceVO } from './domain/value-objects/SoundSource';
+export { Volume } from './domain/value-objects/Volume';
+export { Rate } from './domain/value-objects/Rate';
+export { PlaybackPosition } from './domain/value-objects/PlaybackPosition';
+export { SoundState as SoundStateEntity } from './domain/entities/SoundState';
+
+// Infrastructure exports (for testing/customization)
+export { Logger } from './infrastructure/Logger';
+export { AudioConfig } from './infrastructure/AudioConfig';
+export { ExpoAudioService } from './infrastructure/ExpoAudioService';
+export { SoundCache } from './infrastructure/SoundCache';
+
+// Application exports (for testing/customization)
+export { SoundServiceFacade } from './application/SoundServiceFacade';
+export type { IAudioService, PlaybackStatus } from './application/interfaces/IAudioService';
+export type { ISoundCache, CachedSound } from './application/interfaces/ISoundCache';
+export { SoundPresenter } from './application/presenters/SoundPresenter';

package/src/infrastructure/AudioConfig.ts

@@ -0,0 +1,25 @@
+/**
+ * Audio Configuration Service
+ */
+
+import { Audio, InterruptionModeIOS, InterruptionModeAndroid } from 'expo-av';
+import type { Audio as AudioType } from 'expo-av';
+import { Logger } from './Logger';
+
+export class AudioConfig {
+    static async configure(): Promise<void> {
+        try {
+            await Audio.setAudioModeAsync({
+                playsInSilentModeIOS: true,
+                staysActiveInBackground: false,
+                shouldDuckAndroid: true,
+                playThroughEarpieceAndroid: false,
+                interruptionModeIOS: InterruptionModeIOS.DuckOthers,
+                interruptionModeAndroid: InterruptionModeAndroid.DuckOthers,
+            });
+            Logger.debug('Audio configured successfully');
+        } catch (error) {
+            Logger.warn('Failed to configure audio session', error);
+        }
+    }
+}

package/src/infrastructure/ExpoAudioService.ts

@@ -0,0 +1,88 @@
+/**
+ * Expo Audio Service Implementation
+ */
+
+import { Audio } from 'expo-av';
+import type { IAudioService, PlaybackOptions, PlaybackStatus } from '../application/interfaces/IAudioService';
+import { SoundSourceValue } from '../domain/value-objects/SoundSource';
+import { Logger } from './Logger';
+
+export class ExpoAudioService implements IAudioService {
+    async createSound(
+        source: SoundSourceValue,
+        options: PlaybackOptions,
+        onStatusUpdate: (status: PlaybackStatus) => void
+    ): Promise<{ sound: Audio.Sound }> {
+        const { sound } = await Audio.Sound.createAsync(
+            source,
+            {
+                shouldPlay: options.shouldPlay,
+                isLooping: options.isLooping,
+                volume: options.volume,
+                rate: options.rate,
+                positionMillis: options.positionMillis,
+            },
+            (status) => onStatusUpdate(this.mapStatus(status))
+        );
+        Logger.debug('Sound created');
+        return { sound };
+    }
+
+    async play(sound: unknown): Promise<void> {
+        await (sound as Audio.Sound).playAsync();
+    }
+
+    async pause(sound: unknown): Promise<void> {
+        await (sound as Audio.Sound).pauseAsync();
+    }
+
+    async stop(sound: unknown): Promise<void> {
+        await (sound as Audio.Sound).stopAsync();
+    }
+
+    async unload(sound: unknown): Promise<void> {
+        await (sound as Audio.Sound).unloadAsync();
+    }
+
+    async setVolume(sound: unknown, volume: number): Promise<void> {
+        await (sound as Audio.Sound).setVolumeAsync(volume);
+    }
+
+    async setRate(sound: unknown, rate: number): Promise<void> {
+        await (sound as Audio.Sound).setRateAsync(rate, false);
+    }
+
+    async setPosition(sound: unknown, positionMillis: number): Promise<void> {
+        await (sound as Audio.Sound).setStatusAsync({ positionMillis });
+    }
+
+    async getStatus(sound: unknown): Promise<PlaybackStatus | null> {
+        const status = await (sound as Audio.Sound).getStatusAsync();
+        return status.isLoaded ? this.mapStatus(status) : null;
+    }
+
+    private mapStatus(status: { isLoaded: boolean } & any): PlaybackStatus {
+        if (!status.isLoaded) {
+            return {
+                isLoaded: false,
+                isPlaying: false,
+                isBuffering: false,
+                positionMillis: 0,
+                durationMillis: 0,
+                isLooping: false,
+                didJustFinish: false,
+            };
+        }
+        return {
+            isLoaded: true,
+            isPlaying: status.isPlaying,
+            isBuffering: status.isBuffering,
+            positionMillis: status.positionMillis,
+            durationMillis: status.durationMillis || 0,
+            rate: status.rate,
+            isLooping: status.isLooping,
+            didJustFinish: status.didJustFinish,
+            error: status.error,
+        };
+    }
+}

package/src/infrastructure/Logger.ts

@@ -0,0 +1,23 @@
+/**
+ * Logging Service
+ */
+
+export class Logger {
+    static debug(message: string, ...args: unknown[]): void {
+        if (__DEV__) {
+            console.log(`[Sound] ${message}`, ...args);
+        }
+    }
+
+    static warn(message: string, ...args: unknown[]): void {
+        if (__DEV__) {
+            console.warn(`[Sound] ${message}`, ...args);
+        }
+    }
+
+    static error(message: string, error?: unknown): void {
+        if (__DEV__) {
+            console.error(`[Sound] ${message}`, error);
+        }
+    }
+}

package/src/infrastructure/SoundCache.ts

@@ -0,0 +1,70 @@
+/**
+ * Sound Cache Implementation
+ */
+
+import { ISoundCache, CachedSound } from '../application/interfaces/ISoundCache';
+import { IAudioService } from '../application/interfaces/IAudioService';
+import { Logger } from './Logger';
+
+export class SoundCache implements ISoundCache {
+    private cache = new Map<string, CachedSound>();
+    private readonly maxCacheSize = 3;
+    private readonly cacheExpireMs = 5 * 60 * 1000;
+
+    constructor(private readonly audioService: IAudioService) {}
+
+    get(id: string): CachedSound | undefined {
+        return this.cache.get(id);
+    }
+
+    set(id: string, cached: CachedSound): void {
+        this.cleanExpired();
+        this.enforceLimit();
+        this.cache.set(id, cached);
+        Logger.debug(`Cached: ${id}`);
+    }
+
+    delete(id: string): void {
+        const cached = this.cache.get(id);
+        if (cached) {
+            this.audioService.unload(cached.sound).catch((error) => {
+                Logger.warn(`Failed to unload cache: ${id}`, error);
+            });
+        }
+        this.cache.delete(id);
+    }
+
+    has(id: string): boolean {
+        return this.cache.has(id);
+    }
+
+    clear(): void {
+        for (const cached of this.cache.values()) {
+            this.audioService.unload(cached.sound).catch((error) => {
+                Logger.warn('Failed to unload during cache clear', error);
+            });
+        }
+        this.cache.clear();
+        Logger.debug('Cache cleared');
+    }
+
+    cleanExpired(): void {
+        const now = Date.now();
+        for (const [id, cached] of this.cache) {
+            if (now - cached.loadedAt > this.cacheExpireMs) {
+                this.delete(id);
+                Logger.debug(`Expired cache removed: ${id}`);
+            }
+        }
+    }
+
+    enforceLimit(): void {
+        if (this.cache.size >= this.maxCacheSize) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey) {
+                this.delete(firstKey);
+                Logger.debug(`Cache limit enforced, removed: ${firstKey}`);
+            }
+        }
+    }
+}

package/src/presentation/hooks/useSound.ts

@@ -0,0 +1,47 @@
+/**
+ * useSound Hook - Presentation Layer
+ */
+
+import { useSoundStore } from '../store';
+import { SoundServiceFacade } from '../../application/SoundServiceFacade';
+
+let facade: SoundServiceFacade | null = null;
+
+const getFacade = (): SoundServiceFacade => {
+    if (!facade) {
+        facade = SoundServiceFacade.create(useSoundStore.getState());
+    }
+    return facade;
+};
+
+export const useSound = () => {
+    const state = useSoundStore();
+
+    const facade = getFacade();
+
+    return {
+        // State
+        isPlaying: state.isPlaying,
+        isBuffering: state.isBuffering,
+        isLooping: state.isLooping,
+        position: state.positionMillis,
+        duration: state.durationMillis,
+        currentId: state.currentId,
+        error: state.error,
+        volume: state.volume,
+        rate: state.rate,
+
+        // Actions
+        play: (id: string, source: any, options?: any) => facade.play(id, source, options),
+        pause: () => facade.pause(),
+        resume: () => facade.resume(),
+        stop: () => facade.stop(),
+        seek: (positionMillis: number) => facade.seek(positionMillis),
+        setVolume: (volume: number) => facade.setVolume(volume),
+        setRate: (rate: number) => facade.setRate(rate),
+        preload: (id: string, source: any, options?: any) => facade.preload(id, source, options),
+        unload: () => facade.unload(),
+        clearCache: () => facade.clearCache(),
+        isCached: (id: string) => facade.isCached(id),
+    };
+};

package/src/{store.ts → presentation/store.ts}

@@ -1,19 +1,34 @@
+/**
+ * Sound Store - State Management
+ */
+
 import { createStore } from '@umituz/react-native-design-system/storage';
-import type { SoundState, SoundSource } from './types';
+
+interface SoundState {
+    isPlaying: boolean;
+    isBuffering: boolean;
+    positionMillis: number;
+    durationMillis: number;
+    volume: number;
+    rate: number;
+    isLooping: boolean;
+    error: string | null;
+    currentId: string | null;
+}
 
 interface SoundActions {
     setPlaying: (isPlaying: boolean) => void;
     setBuffering: (isBuffering: boolean) => void;
     setProgress: (position: number, duration: number) => void;
     setError: (error: string | null) => void;
-    setCurrent: (id: string | null, source: SoundSource | null) => void;
+    setCurrent: (id: string | null, source: any) => void;
     setVolumeState: (volume: number) => void;
     setRateState: (rate: number) => void;
     setLooping: (isLooping: boolean) => void;
     reset: () => void;
 }
 
-const initialSoundState: SoundState = {
+const initialState: SoundState = {
     isPlaying: false,
     isBuffering: false,
     positionMillis: 0,
@@ -22,24 +37,22 @@ const initialSoundState: SoundState = {
     rate: 1.0,
     isLooping: false,
     error: null,
-    currentSource: null,
     currentId: null,
 };
 
 export const useSoundStore = createStore<SoundState, SoundActions>({
     name: 'sound-store',
-    initialState: initialSoundState,
+    initialState,
     persist: false,
     actions: (set) => ({
         setPlaying: (isPlaying) => set({ isPlaying }),
         setBuffering: (isBuffering) => set({ isBuffering }),
-        setProgress: (position, duration) =>
-            set({ positionMillis: position, durationMillis: duration }),
+        setProgress: (position, duration) => set({ positionMillis: position, durationMillis: duration }),
         setError: (error) => set({ error }),
-        setCurrent: (id, source) => set({ currentId: id, currentSource: source }),
+        setCurrent: (currentId) => set({ currentId }),
         setVolumeState: (volume) => set({ volume }),
         setRateState: (rate) => set({ rate }),
         setLooping: (isLooping) => set({ isLooping }),
-        reset: () => set(initialSoundState),
+        reset: () => set(initialState),
     }),
 });

package/src/types.ts

@@ -1,10 +1,9 @@
 /**
- * @umituz/react-native-sound Types
+ * Public Types
  */
 
-import { AVPlaybackStatus } from 'expo-av';
-
-export type SoundSource = number | { uri: string; headers?: Record<string, string> } | null;
+export type { SoundSourceValue } from './domain/value-objects/SoundSource';
+export type { SoundStateData } from './domain/entities/SoundState';
 
 export interface PlaybackOptions {
     isLooping?: boolean;
@@ -22,6 +21,8 @@ export interface SoundState {
     rate: number;
     isLooping: boolean;
     error: string | null;
-    currentSource: SoundSource | null;
+    currentSource: any;
     currentId: string | null;
 }
+
+export type SoundSource = number | { uri: string; headers?: Record<string, string> } | null;