expo-gliph-player 1.0.0 → 1.3.4

package/README.md

@@ -1,10 +1,10 @@
 # 🎵 expo-gliph-player
 
-[![npm version](https://shields.io)](https://npmjs.com)
-[![License: MIT](https://shields.io)](https://opensource.org)
-
-**Fixed version of react-native-gliph-player with full Expo compatibility.** All iOS bridge fixes, Swift/Objective-C issues, and Android `autoSkipOnError` patches are pre-applied.
+[![npm version](https://img.shields.io/npm/v/expo-gliph-player)](https://www.npmjs.com/package/expo-gliph-player)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
+**Fixed version of react-native-gliph-player with full Expo compatibility.**
+A high-performance, New Architecture (JSI / TurboModules) compatible audio player for React Native. Built for developers who need absolute control over audio playback, background services, and system integration without fighting complex APIs.
 ---
 
 ## 📦 Installation
@@ -18,7 +18,7 @@ yarn add expo-gliph-player
 ### From GitHub (Alternative):
 
 ```bash
-yarn add https://github.com
+yarn add https://github.com/alex303606/expo-gliph-player
 ```
 
 ---
@@ -56,59 +56,271 @@ npx expo run:ios
 # or
 npx expo run:android
 ```
-
 ---
 
-## 💻 Reactive State
+## 🚀 Full Implementation Example
 
-Instead of manually fetching state, Gliph Player ships with powerful React Hooks. These hooks automatically re-render your components whenever the audio state changes.
+Want to skip straight to the code? Here is a complete, production-ready implementation containing both the main app setup (`App.tsx`) and the user interface (`MusicPlayer.tsx`).
 
-### Play/Pause State:
+### 1. App.tsx (Main Entry & Background Engine Setup)
 
 ```tsx
-import { useIsPlaying } from 'expo-gliph-player';
+import React, { useEffect } from 'react';
+import { View, Platform, PermissionsAndroid } from 'react-native';
+import GliphPlayer, { Capability, AppKilledPlaybackBehavior } from 'expo-gliph-player';
+import { MusicPlayer } from './components/MusicPlayer';
+
+const tracks = [
+  {
+    id: '1',
+    url: 'https://example.com',
+    title: 'Gliph Journey',
+    artist: 'Gliph Labs',
+    artwork: 'https://example.com',
+  },
+];
+
+export default function App() {
+  useEffect(() => {
+    const setup = async () => {
+      // Android Notification Permission (API 33+)
+      if (Platform.OS === 'android' && Platform.Version >= 33) {
+        await PermissionsAndroid.request('android.permission.POST_NOTIFICATIONS' as any);
+      }
 
-const { playing } = useIsPlaying(); // Returns true or false
+      await GliphPlayer.setupPlayer({
+        playBuffer: 0.5, // 0.5s buffer for zero-lag seeking
+        android: {
+          appKilledPlaybackBehavior: AppKilledPlaybackBehavior.ContinuePlayback,
+        },
+      });
+
+      await GliphPlayer.updateOptions({
+        capabilities: [
+          Capability.Play, Capability.Pause,
+          Capability.SkipToNext, Capability.SkipToPrevious,
+          Capability.SeekTo,
+        ],
+      });
+
+      await GliphPlayer.add(tracks);
+    };
+
+    setup();
+  }, []);
+
+  return (
+    <View style={{ flex: 1, backgroundColor: '#121212' }}>
+      <MusicPlayer />
+    </View>
+  );
+}
 ```
 
-### Progress & Duration (in seconds):
+### 2. MusicPlayer.tsx (UI Component)
 
 ```tsx
-import { useProgress } from 'expo-gliph-player';
+import React, { useState } from 'react';
+import { View, Text, TouchableOpacity, Image, StyleSheet } from 'react-native';
+import Slider from '@react-native-community/slider';
+import GliphPlayer, { usePlaybackState, useProgress, useActiveTrack, State, RepeatMode } from 'expo-gliph-player';
+
+export const MusicPlayer = () => {
+    const { state } = usePlaybackState();
+    const { position, duration } = useProgress(500);
+    const track = useActiveTrack();
+    const [repeatMode, setRepeatMode] = useState('off');
+
+    const togglePlayback = async () => {
+        if (state === State.Playing) {
+            await GliphPlayer.pause();
+        } else {
+            await GliphPlayer.play();
+        }
+    };
+
+    const cycleRepeat = async () => {
+        const next = repeatMode === 'off' ? 'one' : repeatMode === 'one' ? 'all' : 'off';
+        setRepeatMode(next);
+        await GliphPlayer.setRepeatMode(
+            next === 'one' ? RepeatMode.Track : next === 'all' ? RepeatMode.Queue : RepeatMode.Off
+        );
+    };
+
+    return (
+        <View style={styles.container}>
+            <Image source={{ uri: track?.artwork }} style={styles.artwork} />
+            <Text style={styles.title}>{track?.title || 'No Track'}</Text>
+
+            <Slider
+                style={{ width: '100%', height: 40 }}
+                value={position}
+                maximumValue={duration || 1}
+                onSlidingComplete={(val) => GliphPlayer.seekTo(val)}
+                minimumTrackTintColor="#1DB954"
+            />
+
+            <View style={styles.controls}>
+                <TouchableOpacity onPress={() => GliphPlayer.skipToPrevious()}>
+                    <Text style={styles.btn}>Prev</Text>
+                </TouchableOpacity>
+
+                <TouchableOpacity onPress={togglePlayback} style={styles.playBtn}>
+                    <Text style={{ color: '#fff' }}>{state === State.Playing ? 'PAUSE' : 'PLAY'}</Text>
+                </TouchableOpacity>
+
+                <TouchableOpacity onPress={() => GliphPlayer.skipToNext()}>
+                    <Text style={styles.btn}>Next</Text>
+                </TouchableOpacity>
+            </View>
+
+            <TouchableOpacity onPress={cycleRepeat} style={{ marginTop: 20 }}>
+                <Text style={{ color: '#1DB954' }}>Repeat: {repeatMode.toUpperCase()}</Text>
+            </TouchableOpacity>
+        </View>
+    );
+};
 
-const { position, duration } = useProgress(500); // Updates every 500ms
+const styles = StyleSheet.create({
+    container: { padding: 20, alignItems: 'center', justifyContent: 'center', flex: 1 },
+    artwork: { width: 300, height: 300, borderRadius: 10 },
+    title: { color: '#fff', fontSize: 24, marginVertical: 20 },
+    controls: { flexDirection: 'row', alignItems: 'center', gap: 40, marginTop: 20 },
+    playBtn: { width: 80, height: 80, borderRadius: 40, backgroundColor: '#333', justifyContent: 'center', alignItems: 'center' },
+    btn: { color: '#fff', fontSize: 18 }
+});
 ```
+---
+
+## 💻 Complete Integration
+
+Let's put the pieces together. Using react-native-gliph-player requires two steps: initializing the background service, and then actually rendering your UI.
+
+### Step 1: Setting up the Player
 
-### "Now Playing" Track Metadata:
+You should initialize the player as soon as your app mounts (usually in App.tsx). You configure the buffer size, define what buttons show on the lock screen, and add your initial tracks.
 
 ```tsx
-import { useActiveTrack } from 'expo-gliph-player';
+import React, { useEffect } from 'react';
+import { Platform, PermissionsAndroid } from 'react-native';
+import GliphPlayer, { Capability, AppKilledPlaybackBehavior } from 'react-native-gliph-player';
+
+const myTracks = [
+    {
+        id: '1',
+        url: 'https://example.com/audio.mp3',
+        title: 'Awesome Song',
+        artist: 'Gliph Labs',
+        artwork: 'https://example.com/cover.jpg', // Shows on lock screen
+    }
+];
 
-const track = useActiveTrack(); // Contains url, title, artist, artwork
+export default function App() {
+    useEffect(() => {
+        const initializeAudio = async () => {
+            // 1. Request Android 13+ Notification Permission
+            if (Platform.OS === 'android' && Platform.Version >= 33) {
+                await PermissionsAndroid.request('android.permission.POST_NOTIFICATIONS' as any);
+            }
+
+            // 2. Setup the engine
+            await GliphPlayer.setupPlayer({
+                playBuffer: 0.5, // 0.5s buffer for zero-lag seeking
+                android: {
+                    // Keep playing even if user swipes app away
+                    appKilledPlaybackBehavior: AppKilledPlaybackBehavior.ContinuePlayback,
+                },
+            });
+
+            // 3. Define Lock Screen Controls
+            await GliphPlayer.updateOptions({
+                capabilities: [
+                    Capability.Play, Capability.Pause,
+                    Capability.SkipToNext, Capability.SkipToPrevious,
+                    Capability.SeekTo,
+                ],
+            });
+
+            // 4. Add tracks to queue
+            await GliphPlayer.add(myTracks);
+        };
+
+        initializeAudio();
+    }, []);
+
+    return <YourMainUI />;
+}
 ```
-
 ---
 
-## 🎛️ Playback & Queue Controls
+## 🔧 Controlling Playback
+
+Now that the player is initialized, you can control it from anywhere in your app using the GliphPlayer API.
 
 ### Basic Controls
 
+Building play, pause, next, and previous buttons is straightforward. All commands are async promises.
+
 ```tsx
-await GliphPlayer.play();
-await GliphPlayer.pause();
-await GliphPlayer.stop();
+import GliphPlayer from 'react-native-gliph-player';
+import { TouchableOpacity, Text, View } from 'react-native';
+
+export function PlayerControls() {
+    return (
+        <View style={{ flexDirection: 'row', gap: 20 }}>
+            <TouchableOpacity onPress={() => GliphPlayer.skipToPrevious()}>
+                <Text>Prev</Text>
+            </TouchableOpacity>
+
+            <TouchableOpacity onPress={() => GliphPlayer.play()}>
+                <Text>Play</Text>
+            </TouchableOpacity>
+
+            <TouchableOpacity onPress={() => GliphPlayer.pause()}>
+                <Text>Pause</Text>
+            </TouchableOpacity>
+
+            <TouchableOpacity onPress={() => GliphPlayer.skipToNext()}>
+                <Text>Next</Text>
+            </TouchableOpacity>
+        </View>
+    );
+}
 ```
 
-### Navigation & Seeking
+### Seeking and Jumping
+
+You can seek to a specific second, or jump forward/backward by an offset.
 
 ```tsx
-await GliphPlayer.skipToNext();
-await GliphPlayer.skipToPrevious();
-await GliphPlayer.seekTo(60); // Jump to exactly 1 minute (in seconds)
-await GliphPlayer.seekBy(15); // Jump forward 15 seconds (great for podcasts)
+// Jump to exactly 1 minute in
+<TouchableOpacity onPress={() => GliphPlayer.seekTo(60)}>
+    <Text>Go to 1:00</Text>
+</TouchableOpacity>
+
+// Jump forward 15 seconds (great for podcasts)
+<TouchableOpacity onPress={() => GliphPlayer.seekBy(15)}>
+    <Text>+15s</Text>
+</TouchableOpacity>
 ```
 
-### Managing the Queue
+### Seeking and Jumping
+
+You can seek to a specific second, or jump forward/backward by an offset.
+
+```tsx
+// Jump to exactly 1 minute in
+<TouchableOpacity onPress={() => GliphPlayer.seekTo(60)}>
+  <Text>Go to 1:00</Text>
+</TouchableOpacity>
+
+// Jump forward 15 seconds (great for podcasts)
+<TouchableOpacity onPress={() => GliphPlayer.seekBy(15)}>
+  <Text>+15s</Text>
+</TouchableOpacity>
+```
+
+## Managing the Queue
 
 You can dynamically add, remove, or reorder tracks while the audio is playing.
 
@@ -116,12 +328,12 @@ You can dynamically add, remove, or reorder tracks while the audio is playing.
 // Add a track to the end of the queue
 await GliphPlayer.add({
   id: 'new-song',
-  url: 'https://example.com',
+  url: 'https://example.com/new.mp3',
   title: 'Just Added',
   artist: 'User'
 });
 
-// Remove a specific track by ID
+// Remove a specific track
 await GliphPlayer.remove('track-1');
 
 // Stop playback and empty the queue entirely
@@ -130,184 +342,142 @@ await GliphPlayer.reset();
 
 ---
 
-## 🔒 Lock Screen & Background Events
+## 🎛️ Reactive State
 
-To ensure your lock screen and notification panel controls actually respond to user input, you must connect native remote events to the player engine.
+Instead of manually fetching state, Gliph Player ships with powerful React Hooks. These hooks automatically re-render your components whenever the audio state changes.
 
-### Inside Components (`useTrackPlayerEvents`)
+### Building a Play/Pause Button
 
-```tsx
-import { useTrackPlayerEvents, Event } from 'expo-gliph-player';
-import GliphPlayer from 'expo-gliph-player';
+The useIsPlaying() hook makes it incredibly easy to toggle a play/pause icon.
 
-export function PlaybackObserver() {
-  useTrackPlayerEvents([
-    Event.RemotePlay, 
-    Event.RemotePause, 
-    Event.RemoteNext, 
-    Event.RemotePrevious
-  ], (event) => {
-    if (event.type === Event.RemotePlay) GliphPlayer.play();
-    if (event.type === Event.RemotePause) GliphPlayer.pause();
-    if (event.type === Event.RemoteNext) GliphPlayer.skipToNext();
-    if (event.type === Event.RemotePrevious) GliphPlayer.skipToPrevious();
-  });
+```tsx
+import GliphPlayer, { useIsPlaying } from 'react-native-gliph-player';
+import { TouchableOpacity, Text } from 'react-native';
+
+export function PlayPauseButton() {
+    const { playing } = useIsPlaying();
+
+    const toggle = async () => {
+        if (playing) {
+            await GliphPlayer.pause();
+        } else {
+            await GliphPlayer.play();
+        }
+    };
 
-  return null; // Headless component, acts as a layout listener
+    return (
+        <TouchableOpacity onPress={toggle} style={{ padding: 20, backgroundColor: '#333' }}>
+            <Text style={{ color: '#fff' }}>{playing ? 'PAUSE' : 'PLAY'}</Text>
+        </TouchableOpacity>
+    );
 }
 ```
 
-### Global Listeners (`GliphPlayer.addEventListener`)
+### Building a Progress Slider
 
-To handle audio events even when your React UI components are unmounted, register global listeners inside your app root (`index.js` or `App.tsx` outside the component lifecycle):
+The useProgress() hook returns the current position and duration. It updates automatically so your slider moves smoothly in real-time.
 
 ```tsx
-import GliphPlayer, { Event } from 'expo-gliph-player';
-
-GliphPlayer.addEventListener(Event.RemotePlay, () => {
-  GliphPlayer.play();
-});
+import GliphPlayer, { useProgress } from 'react-native-gliph-player';
+import Slider from '@react-native-community/slider';
 
-GliphPlayer.addEventListener(Event.RemotePause, () => {
-  GliphPlayer.pause();
-});
+export function ProgressBar() {
+    // Updates 2 times a second (500ms)
+    const { position, duration } = useProgress(500);
+
+    return (
+        <Slider
+            style={{ width: '100%', height: 40 }}
+            value={position}
+            maximumValue={duration || 1}
+            onSlidingComplete={(value) => GliphPlayer.seekTo(value)}
+            minimumTrackTintColor="#1DB954"
+            maximumTrackTintColor="#ffffff"
+        />
+    );
+}
 ```
 
----
-
-## 🚀 Full Implementation Example
-
-Here is a production-ready, complete example split into the main entry file (`App.tsx`) and the user interface component (`MusicPlayer.tsx`).
+### Showing "Now Playing"
 
-### 1. App.tsx (Main Entry & Background Engine Setup)
+The useActiveTrack() hook returns the data for the song currently playing. It changes automatically when a song skips.
 
 ```tsx
-import React, { useEffect } from 'react';
-import { View, Platform, PermissionsAndroid } from 'react-native';
-import GliphPlayer, { Capability, AppKilledPlaybackBehavior } from 'expo-gliph-player';
-import { MusicPlayer } from './components/MusicPlayer';
+import { useActiveTrack } from 'react-native-gliph-player';
+import { View, Image, Text } from 'react-native';
 
-const tracks = [
-  {
-    id: '1',
-    url: 'https://example.com',
-    title: 'Gliph Journey',
-    artist: 'Gliph Labs',
-    artwork: 'https://example.com',
-  },
-];
+export function NowPlaying() {
+    const track = useActiveTrack();
 
-export default function App() {
-  useEffect(() => {
-    const setup = async () => {
-      // 1. Android Notification Permission (API 33+)
-      if (Platform.OS === 'android' && Platform.Version >= 33) {
-        await PermissionsAndroid.request('android.permission.POST_NOTIFICATIONS' as any);
-      }
+    if (!track) return <Text>Nothing playing</Text>;
 
-      // 2. Setup the engine
-      await GliphPlayer.setupPlayer({
-        playBuffer: 0.5, // 0.5s buffer for zero-lag seeking
-        android: {
-          appKilledPlaybackBehavior: AppKilledPlaybackBehavior.ContinuePlayback,
-        },
-      });
-
-      // 3. Define Lock Screen / Notification Controls
-      await GliphPlayer.updateOptions({
-        capabilities: [
-          Capability.Play, Capability.Pause,
-          Capability.SkipToNext, Capability.SkipToPrevious,
-          Capability.SeekTo,
-        ],
-      });
+    return (
+        <View style={{ alignItems: 'center' }}>
+            <Image source={{ uri: track.artwork }} style={{ width: 200, height: 200 }} />
+            <Text style={{ fontSize: 24, fontWeight: 'bold' }}>{track.title}</Text>
+            <Text style={{ fontSize: 18, color: 'gray' }}>{track.artist}</Text>
+        </View>
+    );
+}
+```
 
-      // 4. Add tracks to queue
-      await GliphPlayer.add(tracks);
-    };
+---
 
-    setup();
-  }, []);
+## 🔒 Background & Lock Screen
 
-  return (
-    <View style={{ flex: 1, backgroundColor: '#121212' }}>
-      <MusicPlayer />
-    </View>
-  );
-}
-```
+One of the biggest advantages of Gliph Player is that audio keeps playing when the app is minimized. The system lock screen and notification panel will show your track artwork and controls automatically.
 
-### 2. MusicPlayer.tsx (UI Component)
+### Lock Screen Buttons
+The native OS provides the lock screen controls, but you need to tell Gliph Player how to respond when a user taps "Next" on their lock screen. If you don't listen for these events, the lock screen buttons won't do anything!
+We provide a special hook `useTrackPlayerEvents` to capture these native remote events cleanly inside your components.
 
 ```tsx
-import React, { useState } from 'react';
-import { View, Text, TouchableOpacity, Image, StyleSheet } from 'react-native';
-import Slider from '@react-native-community/slider';
-import GliphPlayer, { useIsPlaying, useProgress, useActiveTrack, RepeatMode } from 'expo-gliph-player';
+import { useTrackPlayerEvents, Event } from 'expo-gliph-player';
+import GliphPlayer from 'expo-gliph-player';
 
-export const MusicPlayer = () => {
-  const { playing } = useIsPlaying();
-  const { position, duration } = useProgress(500);
-  const track = useActiveTrack();
-  const [repeatMode, setRepeatMode] = useState('off');
-
-  const togglePlayback = async () => {
-    if (playing) {
-      await GliphPlayer.pause();
-    } else {
-      await GliphPlayer.play();
+export function PlaybackObserver() {
+  // Listen for native remote control events
+  useTrackPlayerEvents([
+    Event.RemotePlay, 
+    Event.RemotePause, 
+    Event.RemoteNext, 
+    Event.RemotePrevious
+  ], (event) => {
+    if (event.type === Event.RemotePlay) {
+      GliphPlayer.play();
+    }
+    
+    if (event.type === Event.RemotePause) {
+      GliphPlayer.pause();
     }
-  };
+    
+    if (event.type === Event.RemoteNext) {
+      GliphPlayer.skipToNext();
+    }
+    
+    if (event.type === Event.RemotePrevious) {
+      GliphPlayer.skipToPrevious();
+    }
+  });
 
-  const cycleRepeat = async () => {
-    const next = repeatMode === 'off' ? 'one' : repeatMode === 'one' ? 'all' : 'off';
-    setRepeatMode(next);
-    await GliphPlayer.setRepeatMode(
-      next === 'one' ? RepeatMode.Track : next === 'all' ? RepeatMode.Queue : RepeatMode.Off
-    );
-  };
+  // This component doesn't need to render anything visual
+  return null;
+}
+```
 
-  return (
-    <View style={styles.container}>
-      <Image source={{ uri: track?.artwork }} style={styles.artwork} />
-      <Text style={styles.title}>{track?.title || 'No Track'}</Text>
-      
-      <Slider
-        style={{ width: '100%', height: 40 }}
-        value={position}
-        maximumValue={duration || 1}
-        onSlidingComplete={(val) => GliphPlayer.seekTo(val)}
-        minimumTrackTintColor="#1DB954"
-      />
-
-      <View style={styles.controls}>
-        <TouchableOpacity onPress={() => GliphPlayer.skipToPrevious()}>
-          <Text style={styles.btn}>Prev</Text>
-        </TouchableOpacity>
-        
-        <TouchableOpacity onPress={togglePlayback} style={styles.playBtn}>
-          <Text style={{ color: '#fff' }}>{playing ? 'PAUSE' : 'PLAY'}</Text>
-        </TouchableOpacity>
+### Background Services (Advanced)
+If you want to handle events globally even when your React UI is completely unmounted, you can register listeners outside of the component tree (e.g. in your `index.js` or `App.tsx` file outside the component lifecycle) using `GliphPlayer.addEventListener()`.
 
-        <TouchableOpacity onPress={() => GliphPlayer.skipToNext()}>
-          <Text style={styles.btn}>Next</Text>
-        </TouchableOpacity>
-      </View>
+```tsx
+import GliphPlayer, { Event } from 'expo-gliph-player';
 
-      <TouchableOpacity onPress={cycleRepeat} style={{ marginTop: 20 }}>
-        <Text style={{ color: '#1DB954' }}>Repeat: {repeatMode.toUpperCase()}</Text>
-      </TouchableOpacity>
-    </View>
-  );
-};
+// In index.js or App.tsx (outside component)
+GliphPlayer.addEventListener(Event.RemotePlay, () => {
+  GliphPlayer.play();
+});
 
-const styles = StyleSheet.create({
-  container: { padding: 20, alignItems: 'center', justifyContent: 'center', flex: 1 },
-  artwork: { width: 300, height: 300, borderRadius: 10 },
-  title: { color: '#fff', fontSize: 24, marginVertical: 20 },
-  controls: { flexDirection: 'row', alignItems: 'center', gap: 40, marginTop: 20 },
-  playBtn: { width: 80, height: 80, borderRadius: 40, backgroundColor: '#333', justifyContent: 'center', alignItems: 'center' },
-  btn: { color: '#fff', fontSize: 18 }
+GliphPlayer.addEventListener(Event.RemotePause, () => {
+  GliphPlayer.pause();
 });
 ```
 

package/ios/GliphAudioPlayer.swift

@@ -43,6 +43,22 @@ public typealias EventEmitter = (String, [String: Any]?) -> Void
     super.init()
   }
 
+  // ── Thread helper ───────────────────────────────────────────────────────────
+
+  /// Executes `block` synchronously on the main thread.
+  /// Safe to call from any thread — avoids deadlock if already on main.
+  /// Several AVAudioSession / UIApplication / MPRemoteCommandCenter APIs are
+  /// documented as main-thread-only; the RN bridge does not guarantee that
+  /// native module methods run on main, so every touch of those APIs goes
+  /// through this helper.
+  private func runOnMain(_ block: () -> Void) {
+    if Thread.isMainThread {
+      block()
+    } else {
+      DispatchQueue.main.sync(execute: block)
+    }
+  }
+
   // ── Setup ───────────────────────────────────────────────────────────────────
 
   @objc public func setupPlayer(
@@ -52,29 +68,39 @@ public typealias EventEmitter = (String, [String: Any]?) -> Void
   ) {
     guard !isSetup else { resolve(nil); return }
 
-    self.options = options
-    self.progressInterval = (options["progressUpdateEventInterval"] as? Double) ?? 1.0
+    var setupError: Error?
 
-    do {
-      let session = AVAudioSession.sharedInstance()
-      let category = mapIOSCategory(options["iosCategory"] as? String)
-      let mode = mapIOSMode(options["iosCategoryMode"] as? String)
-      let opts = mapIOSOptions(options["iosCategoryOptions"] as? [String])
+    runOnMain {
+      self.options = options
+      self.progressInterval = (options["progressUpdateEventInterval"] as? Double) ?? 1.0
+
+      do {
+        let session = AVAudioSession.sharedInstance()
+        let category = self.mapIOSCategory(options["iosCategory"] as? String)
+        let mode = self.mapIOSMode(options["iosCategoryMode"] as? String)
+        let opts = self.mapIOSOptions(options["iosCategoryOptions"] as? [String])
+
+        try session.setCategory(category, mode: mode, options: opts)
+        try session.setActive(true)
+      } catch {
+        setupError = error
+        return
+      }
 
-      try session.setCategory(category, mode: mode, options: opts)
-      try session.setActive(true)
-    } catch {
+      self.player = AVQueuePlayer()
+      self.player?.allowsExternalPlayback = false
+      self.player?.automaticallyWaitsToMinimizeStalling = (options["waitForBuffer"] as? Bool) ?? true
+
+      self.setupRemoteCommands()
+      self.setupNotificationObservers()
+      self.isSetup = true
+    }
+
+    if let error = setupError {
       reject("setup_error", "Failed to configure audio session: \(error.localizedDescription)", error)
       return
     }
 
-    player = AVQueuePlayer()
-    player?.allowsExternalPlayback = false
-    player?.automaticallyWaitsToMinimizeStalling = (options["waitForBuffer"] as? Bool) ?? true
-
-    setupRemoteCommands()
-    setupNotificationObservers()
-    isSetup = true
     resolve(nil)
   }
 
@@ -89,7 +115,9 @@ public typealias EventEmitter = (String, [String: Any]?) -> Void
     currentIndex = -1
     isSetup = false
     MPNowPlayingInfoCenter.default().nowPlayingInfo = nil
-    UIApplication.shared.endReceivingRemoteControlEvents()
+    runOnMain {
+      UIApplication.shared.endReceivingRemoteControlEvents()
+    }
   }
 
   @objc public func isReady() -> Bool { return isSetup }
@@ -345,7 +373,9 @@ public typealias EventEmitter = (String, [String: Any]?) -> Void
     reject: @escaping RCTPromiseRejectBlock
   ) {
     options = opts
-    setupRemoteCommands()
+    runOnMain {
+      self.setupRemoteCommands()
+    }
     resolve(nil)
   }
 
@@ -426,6 +456,10 @@ public typealias EventEmitter = (String, [String: Any]?) -> Void
 
   // ── Remote commands ─────────────────────────────────────────────────────────
 
+  /// Must always be called on the main thread (see `runOnMain` call sites:
+  /// `setupPlayer` and `updateOptions`). `MPRemoteCommandCenter` and
+  /// `UIApplication.beginReceivingRemoteControlEvents()` are main-thread-only
+  /// APIs.
   private func setupRemoteCommands() {
     let center = MPRemoteCommandCenter.shared()
     UIApplication.shared.beginReceivingRemoteControlEvents()
@@ -694,4 +728,4 @@ public typealias EventEmitter = (String, [String: Any]?) -> Void
     }
     return opts
   }
-}
+}

package/ios/expo_gliph_player.h

@@ -1,22 +1 @@
-//
-//  expo_gliph_player.h
-//
-//  Master header matching the pod's module name (dashes -> underscores).
-//  Xcode's Swift-generated interop header (expo_gliph_player-Swift.h) hardcodes
-//  a self-import of <expo_gliph_player/expo_gliph_player.h> for any module that
-//  has DEFINES_MODULE = YES and contains Swift — this file only needs to EXIST
-//  under that exact name for the build to find it.
-//
-//  IMPORTANT: do NOT re-export GliphAudioPlayer.h from here (e.g. via
-//  `#import "GliphAudioPlayer.h"`). The authoritative Objective-C interface
-//  for the Swift `GliphAudioPlayer` class is auto-generated by the Swift
-//  compiler itself, inside expo_gliph_player-Swift.h. GliphPlayerModule.mm
-//  imports that generated header directly. If this file also pulls in a
-//  second, hand-written declaration of the same class name, both end up in
-//  the same translation unit and the build fails with:
-//  "Duplicate interface definition for class 'GliphAudioPlayer'"
-//  (which in turn cascades into unrelated-looking parse errors later in
-//  GliphPlayerModule.mm, since Clang's parser gets confused after the
-//  redefinition).
-//
 #import <Foundation/Foundation.h>

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "expo-gliph-player",
-  "version": "1.0.0",
-  "description": "Expo compatible audio player with iOS and Android support",
+  "author": {
+    "name": "Aleksey Ostrikov",
+    "email": "alex303606@gmail.com"
+  },
+  "version": "1.3.4",
+  "description": "Fixed version of react-native-gliph-player with Expo compatibility",
   "main": "app.plugin.js",
   "module": "lib/module/index.js",
   "types": "lib/typescript/src/index.d.ts",
@@ -17,22 +21,14 @@
     "expo-plugin"
   ],
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/alex303606/expo-gliph-player.git"
-  },
-  "bugs": {
-    "url": "https://github.com/alex303606/expo-gliph-player/issues"
-  },
-  "homepage": "https://github.com/alex303606/expo-gliph-player#readme",
-  "author": "alex303606 <alex303606@gmail.com>",
   "peerDependencies": {
     "expo": ">=50.0.0",
     "react": "*",
     "react-native": ">=0.71.0"
   },
   "dependencies": {
-    "@expo/config-plugins": ">=7.0.0"
+    "@expo/config-plugins": ">=7.0.0",
+    "react-native-gliph-player": "^1.3.4"
   },
   "files": [
     "app.plugin.js",
@@ -41,16 +37,9 @@
     "android",
     "lib",
     "*.podspec",
-    "!ios/**/*.xcodeproj",
-    "!android/**/*.iml",
-    "!android/build",
-    "!android/.gradle",
     "LICENSE",
     "README.md"
   ],
-  "scripts": {
-    "prepublishOnly": "echo 'No build needed'"
-  },
   "codegenConfig": {
     "name": "RNGliphPlayerSpec",
     "type": "modules",

package/src/types.ts

@@ -220,8 +220,8 @@ export interface PlayerOptions {
   /** Android-specific options */
   android?: {
     appKilledPlaybackBehavior?: AppKilledPlaybackBehavior;
-    audioContentType?: AndroidAudioContentType;
-    audioUsage?: AndroidAudioUsage;
+    audioContentType?: AndroidAudioContentType | string;
+    audioUsage?: AndroidAudioUsage | string;
     autoSkipOnError?: boolean;
   };
   /** Progress update interval in seconds */

package/src/withGliphPlayer.js

@@ -8,8 +8,6 @@ const fs = require('fs');
 const path = require('path');
 
 module.exports = function withGliphPlayer(config) {
-    console.log('🔧 Starting expo-gliph-player plugin...');
-
     // ===== iOS: Info.plist =====
     config = withInfoPlist(config, (config) => {
         if (!config.modResults.UIBackgroundModes) {