expo-gliph-player 1.0.0

package/src/specs/NativeGliphPlayer.ts

@@ -0,0 +1,105 @@
+/**
+ * NativeGliphPlayer.ts
+ *
+ * TurboModule spec for the New React Native Architecture (Codegen).
+ * This file is parsed by Codegen to generate C++/Java/ObjC bridge code.
+ * All types must be Codegen-compatible (no unions of complex types, etc.)
+ */
+
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+// ─── Codegen-compatible track object ────────────────────────────────────────
+export interface TrackObject {
+  id: string;
+  url: string;
+  title: string;
+  artist: string;
+  album?: string;
+  artwork?: string;
+  duration?: number;
+  genre?: string;
+  date?: string;
+  description?: string;
+  rating?: number;
+  isLiveStream?: boolean;
+  headers?: Object;
+  pitchAlgorithm?: number;
+  userAgent?: string;
+}
+
+// ─── Player options ──────────────────────────────────────────────────────────
+export interface PlayerOptions {
+  minBuffer?: number;
+  maxBuffer?: number;
+  playBuffer?: number;
+  backBuffer?: number;
+  maxCacheSize?: number;
+  iosCategory?: string;
+  iosCategoryMode?: string;
+  iosCategoryOptions?: ReadonlyArray<string>;
+  waitForBuffer?: boolean;
+  autoHandleInterruptions?: boolean;
+  autoUpdateMetadata?: boolean;
+  android?: Object;
+  progressUpdateEventInterval?: number;
+}
+
+// ─── TurboModule spec ────────────────────────────────────────────────────────
+export interface Spec extends TurboModule {
+  // Setup / teardown
+  setupPlayer(options: Object): Promise<void>;
+  destroy(): void;
+  isServiceRunning(): Promise<boolean>;
+
+  // Queue management
+  // NOTE: Codegen does not support optional number params — use -1 as sentinel for "not provided"
+  add(tracks: ReadonlyArray<Object>, insertBeforeIndex: number): Promise<number>;
+  remove(tracks: ReadonlyArray<string>): Promise<void>;
+  removeUpcomingTracks(): Promise<void>;
+  skip(index: number, initialPosition: number): Promise<void>;
+  skipToNext(initialPosition: number): Promise<void>;
+  skipToPrevious(initialPosition: number): Promise<void>;
+  move(fromIndex: number, toIndex: number): Promise<void>;
+
+  // Playback control
+  play(): Promise<void>;
+  pause(): Promise<void>;
+  stop(): Promise<void>;
+  reset(): Promise<void>;
+  seekTo(position: number): Promise<void>;
+  seekBy(offset: number): Promise<void>;
+  setVolume(volume: number): Promise<void>;
+  getVolume(): Promise<number>;
+  setRate(rate: number): Promise<void>;
+  getRate(): Promise<number>;
+  setRepeatMode(mode: number): Promise<void>;
+  getRepeatMode(): Promise<number>;
+
+  // Queue getters
+  // NOTE: Codegen does not support nullable primitives in return position.
+  // getActiveTrackIndex returns -1 when no track is active (sentinel value).
+  getQueue(): Promise<ReadonlyArray<Object>>;
+  getActiveTrackIndex(): Promise<number>;
+  getActiveTrack(): Promise<Object | null>;
+  getTrack(index: number): Promise<Object | null>;
+  getQueueSize(): Promise<number>;
+
+  // Playback state
+  getPlaybackState(): Promise<Object>;
+  getProgress(): Promise<Object>;
+
+  // Metadata update
+  updateMetadataForTrack(index: number, metadata: Object): Promise<void>;
+  clearNowPlayingMetadata(): Promise<void>;
+  updateNowPlayingMetadata(metadata: Object): Promise<void>;
+
+  // Capabilities / notification
+  updateOptions(options: Object): Promise<void>;
+
+  // Events (emitter support — required for TurboModule event emission)
+  addListener(eventType: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.get<Spec>('RNGliphPlayer');

package/src/types.ts

@@ -0,0 +1,395 @@
+/**
+ * types.ts — Public TypeScript types for react-native-gliph-player
+ */
+
+// ─── Track ───────────────────────────────────────────────────────────────────
+
+export interface Track {
+  /** Unique identifier for the track (auto-generated if not provided) */
+  id?: string;
+  /** URL of the audio file (local or remote) */
+  url: string | number; // number = require('./file.mp3')
+  /** Track title */
+  title: string;
+  /** Artist name */
+  artist: string;
+  /** Album name */
+  album?: string;
+  /** Artwork URL or local require() */
+  artwork?: string | number;
+  /** Duration in seconds */
+  duration?: number;
+  /** Genre */
+  genre?: string;
+  /** Release date string */
+  date?: string;
+  /** Description / lyrics */
+  description?: string;
+  /** Rating (0–1 or 0–5 depending on ratingType) */
+  rating?: number;
+  /** Whether this is a live stream */
+  isLiveStream?: boolean;
+  /** Custom HTTP headers for the audio request */
+  headers?: Record<string, string>;
+  /** iOS pitch algorithm */
+  pitchAlgorithm?: PitchAlgorithm;
+  /** Custom user agent */
+  userAgent?: string;
+}
+
+// ─── Enums ───────────────────────────────────────────────────────────────────
+
+export enum State {
+  /** No player setup yet */
+  None = 'none',
+  /** Player is ready but not playing */
+  Ready = 'ready',
+  /** Audio is playing */
+  Playing = 'playing',
+  /** Audio is paused */
+  Paused = 'paused',
+  /** Player is stopped */
+  Stopped = 'stopped',
+  /** Buffering / loading */
+  Buffering = 'buffering',
+  /** Loading initial data */
+  Loading = 'loading',
+  /** An error occurred */
+  Error = 'error',
+  /** End of queue reached */
+  Ended = 'ended',
+}
+
+export enum Event {
+  /** Playback state changed */
+  PlaybackState = 'playback-state',
+  /** Playback error */
+  PlaybackError = 'playback-error',
+  /** Active track changed */
+  PlaybackActiveTrackChanged = 'playback-active-track-changed',
+  /** Queue ended */
+  PlaybackQueueEnded = 'playback-queue-ended',
+  /** Track ended */
+  PlaybackTrackEnded = 'playback-track-ended',
+  /** Playback progress updated */
+  PlaybackProgressUpdated = 'playback-progress-updated',
+  /** Metadata received (e.g. from stream) */
+  PlaybackMetadataReceived = 'playback-metadata-received',
+  /** Repeat mode changed */
+  PlaybackRepeatModeChanged = 'playback-repeat-mode-changed',
+
+  // Remote control events (from notification / lock screen / headphones)
+  RemotePlay = 'remote-play',
+  RemotePause = 'remote-pause',
+  RemoteStop = 'remote-stop',
+  RemoteSkip = 'remote-skip',
+  RemoteNext = 'remote-next',
+  RemotePrevious = 'remote-previous',
+  RemoteJumpForward = 'remote-jump-forward',
+  RemoteJumpBackward = 'remote-jump-backward',
+  RemoteSeek = 'remote-seek',
+  RemoteSetRating = 'remote-set-rating',
+  RemoteDuck = 'remote-duck',
+  RemoteLike = 'remote-like',
+  RemoteDislike = 'remote-dislike',
+  RemoteBookmark = 'remote-bookmark',
+}
+
+export enum RepeatMode {
+  /** No repeat */
+  Off = 0,
+  /** Repeat current track */
+  Track = 1,
+  /** Repeat entire queue */
+  Queue = 2,
+}
+
+export enum Capability {
+  Play = 'play',
+  Pause = 'pause',
+  Stop = 'stop',
+  SeekTo = 'seek-to',
+  Skip = 'skip',
+  SkipToNext = 'skip-to-next',
+  SkipToPrevious = 'skip-to-previous',
+  JumpForward = 'jump-forward',
+  JumpBackward = 'jump-backward',
+  SetRating = 'set-rating',
+  Like = 'like',
+  Dislike = 'dislike',
+  Bookmark = 'bookmark',
+}
+
+export enum RatingType {
+  Heart = 'heart',
+  ThumbsUpDown = 'thumbs-up-down',
+  ThreeStars = '3-stars',
+  FourStars = '4-stars',
+  FiveStars = '5-stars',
+  Percentage = 'percentage',
+}
+
+export enum PitchAlgorithm {
+  /** Best quality, higher CPU */
+  Quality = 0,
+  /** Balanced */
+  Consistency = 1,
+  /** Lowest CPU */
+  Varispeed = 2,
+}
+
+export enum IOSCategory {
+  Playback = 'playback',
+  PlayAndRecord = 'playAndRecord',
+  MultiRoute = 'multiRoute',
+  Ambient = 'ambient',
+  SoloAmbient = 'soloAmbient',
+  Record = 'record',
+}
+
+export enum IOSCategoryMode {
+  Default = 'default',
+  GameChat = 'gameChat',
+  Measurement = 'measurement',
+  MoviePlayback = 'moviePlayback',
+  SpokenAudio = 'spokenAudio',
+  VideoChat = 'videoChat',
+  VideoRecording = 'videoRecording',
+  VoiceChat = 'voiceChat',
+  VoicePrompt = 'voicePrompt',
+}
+
+export enum IOSCategoryOptions {
+  MixWithOthers = 'mixWithOthers',
+  DuckOthers = 'duckOthers',
+  InterruptSpokenAudioAndMixWithOthers = 'interruptSpokenAudioAndMixWithOthers',
+  AllowBluetooth = 'allowBluetooth',
+  AllowBluetoothA2DP = 'allowBluetoothA2DP',
+  AllowAirPlay = 'allowAirPlay',
+  DefaultToSpeaker = 'defaultToSpeaker',
+}
+
+export enum AndroidAudioContentType {
+  Unknown = 0,
+  Speech = 1,
+  Music = 2,
+  Movie = 3,
+  Sonification = 4,
+}
+
+export enum AndroidAudioUsage {
+  Unknown = 0,
+  Media = 1,
+  VoiceCommunication = 2,
+  VoiceCommunicationSignalling = 3,
+  Alarm = 4,
+  Notification = 5,
+  NotificationRingtone = 6,
+  NotificationEvent = 10,
+  AssistanceAccessibility = 11,
+  AssistanceNavigationGuidance = 12,
+  AssistanceSonification = 13,
+  Game = 14,
+}
+
+// ─── Options ─────────────────────────────────────────────────────────────────
+
+export interface PlayerOptions {
+  /** Minimum seconds to buffer before playback starts (Android) */
+  minBuffer?: number;
+  /** Maximum seconds to buffer ahead (Android) */
+  maxBuffer?: number;
+  /** Seconds buffered before playback resumes after stall (Android) */
+  playBuffer?: number;
+  /** Seconds of audio to keep behind current position (Android) */
+  backBuffer?: number;
+  /** Max cache size in bytes (Android) */
+  maxCacheSize?: number;
+  /** iOS audio session category */
+  iosCategory?: IOSCategory;
+  /** iOS audio session category mode */
+  iosCategoryMode?: IOSCategoryMode;
+  /** iOS audio session category options */
+  iosCategoryOptions?: IOSCategoryOptions[];
+  /** Wait for buffer before auto-playing */
+  waitForBuffer?: boolean;
+  /** Auto handle audio interruptions (calls, etc.) */
+  autoHandleInterruptions?: boolean;
+  /** Auto update Now Playing metadata */
+  autoUpdateMetadata?: boolean;
+  /** Android-specific options */
+  android?: {
+    appKilledPlaybackBehavior?: AppKilledPlaybackBehavior;
+    audioContentType?: AndroidAudioContentType;
+    audioUsage?: AndroidAudioUsage;
+    autoSkipOnError?: boolean;
+  };
+  /** Progress update interval in seconds */
+  progressUpdateEventInterval?: number;
+}
+
+export enum AppKilledPlaybackBehavior {
+  /** Stop playback when app is killed */
+  StopPlaybackAndRemoveNotification = 'StopPlaybackAndRemoveNotification',
+  /** Continue playback in background service */
+  ContinuePlayback = 'ContinuePlayback',
+  /** Pause playback but keep notification */
+  PausePlayback = 'PausePlayback',
+}
+
+export interface UpdateOptions {
+  /** Notification icon (Android) — resource name */
+  icon?: number;
+  /** Notification icon resource name (Android) */
+  notificationIcon?: string;
+  /** Playback capabilities to show in notification */
+  capabilities?: Capability[];
+  /** Capabilities to show when paused */
+  notificationCapabilities?: Capability[];
+  /** Capabilities to show in compact notification view */
+  compactCapabilities?: Capability[];
+  /** Jump forward interval in seconds */
+  forwardJumpInterval?: number;
+  /** Jump backward interval in seconds */
+  backwardJumpInterval?: number;
+  /** Progress update interval in seconds */
+  progressUpdateEventInterval?: number;
+  /** Rating type */
+  ratingType?: RatingType;
+  /** Android notification color (hex string) */
+  color?: number;
+  /** Android notification channel name */
+  notificationChannelName?: string;
+  /** Android custom actions */
+  customActions?: CustomAction[];
+}
+
+export interface CustomAction {
+  icon: number;
+  title: string;
+  name: string;
+}
+
+// ─── Playback state / progress ───────────────────────────────────────────────
+
+export interface PlaybackState {
+  state: State;
+  error?: PlaybackError;
+}
+
+export interface Progress {
+  /** Current position in seconds */
+  position: number;
+  /** Total duration in seconds */
+  duration: number;
+  /** Buffered position in seconds */
+  buffered: number;
+}
+
+export interface PlaybackError {
+  code: string;
+  message: string;
+}
+
+// ─── Event payloads ──────────────────────────────────────────────────────────
+
+export interface PlaybackRepeatModeChangedEvent {
+  mode: RepeatMode;
+}
+
+export interface PlaybackStateEvent {
+  state: State;
+}
+
+export interface PlaybackErrorEvent {
+  code: string;
+  message: string;
+}
+
+export interface PlaybackActiveTrackChangedEvent {
+  index: number | null;
+  track: Track | null;
+  lastIndex: number | null;
+  lastTrack: Track | null;
+  lastPosition: number;
+}
+
+export interface PlaybackQueueEndedEvent {
+  index: number;
+  position: number;
+  track: Track | null;
+}
+
+export interface PlaybackProgressUpdatedEvent {
+  position: number;
+  duration: number;
+  buffered: number;
+  track: number;
+}
+
+export interface PlaybackTrackEndedEvent {
+  index: number;
+}
+
+export interface PlaybackMetadataReceivedEvent {
+  source: 'icy' | 'id3' | 'unknown';
+  title?: string;
+  url?: string;
+  artist?: string;
+  album?: string;
+  date?: string;
+  genre?: string;
+}
+
+export interface RemoteSeekEvent {
+  position: number;
+}
+
+export interface RemoteJumpForwardEvent {
+  interval: number;
+}
+
+export interface RemoteJumpBackwardEvent {
+  interval: number;
+}
+
+export interface RemoteSetRatingEvent {
+  rating: number;
+}
+
+export interface RemoteDuckEvent {
+  paused: boolean;
+  permanent: boolean;
+  focusLoss: boolean;
+}
+
+export interface RemoteSkipEvent {
+  index: number;
+}
+
+// ─── Event map ───────────────────────────────────────────────────────────────
+
+export interface EventPayloadByEvent {
+  [Event.PlaybackState]: PlaybackStateEvent;
+  [Event.PlaybackError]: PlaybackErrorEvent;
+  [Event.PlaybackActiveTrackChanged]: PlaybackActiveTrackChangedEvent;
+  [Event.PlaybackQueueEnded]: PlaybackQueueEndedEvent;
+  [Event.PlaybackTrackEnded]: PlaybackTrackEndedEvent;
+  [Event.PlaybackProgressUpdated]: PlaybackProgressUpdatedEvent;
+  [Event.PlaybackMetadataReceived]: PlaybackMetadataReceivedEvent;
+  [Event.PlaybackRepeatModeChanged]: PlaybackRepeatModeChangedEvent;
+  [Event.RemotePlay]: void;
+  [Event.RemotePause]: void;
+  [Event.RemoteStop]: void;
+  [Event.RemoteNext]: void;
+  [Event.RemotePrevious]: void;
+  [Event.RemoteSkip]: RemoteSkipEvent;
+  [Event.RemoteJumpForward]: RemoteJumpForwardEvent;
+  [Event.RemoteJumpBackward]: RemoteJumpBackwardEvent;
+  [Event.RemoteSeek]: RemoteSeekEvent;
+  [Event.RemoteSetRating]: RemoteSetRatingEvent;
+  [Event.RemoteDuck]: RemoteDuckEvent;
+  [Event.RemoteLike]: void;
+  [Event.RemoteDislike]: void;
+  [Event.RemoteBookmark]: void;
+}

package/src/withGliphPlayer.js

@@ -0,0 +1,166 @@
+const {
+    withDangerousMod,
+    withPodfile,
+    withInfoPlist,
+    withAndroidManifest,
+} = require('@expo/config-plugins');
+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) {
+            config.modResults.UIBackgroundModes = [];
+        }
+        if (!config.modResults.UIBackgroundModes.includes('audio')) {
+            config.modResults.UIBackgroundModes.push('audio');
+        }
+        return config;
+    });
+
+    // ===== iOS: Podfile =====
+    config = withPodfile(config, (config) => {
+        let content = config.modResults.contents;
+
+        if (!content.includes("pod 'expo-gliph-player'")) {
+            const podLine =
+                `  pod 'expo-gliph-player', :path => '../node_modules/expo-gliph-player', :build_type => :static_framework`;
+
+            // Use the real host app target name instead of a hardcoded one, so
+            // this plugin works in any Expo project, not just the app it was
+            // originally extracted from.
+            const targetName = config.modRequest?.projectName;
+            const namedTargetRegex = targetName
+                ? new RegExp(`target '${targetName}' do`)
+                : null;
+
+            if (namedTargetRegex && namedTargetRegex.test(content)) {
+                content = content.replace(namedTargetRegex, (match) => `${match}\n${podLine}`);
+            } else {
+                // Fallback: insert into the first `target '...' do` block, which
+                // is always the main app target in a standard Expo-generated Podfile.
+                content = content.replace(/target '([^']+)' do/, (match) => `${match}\n${podLine}`);
+            }
+        }
+
+        if (!content.includes("target.name == 'expo-gliph-player'")) {
+            const gliphConfig = `
+    # Configure expo-gliph-player
+    installer.pods_project.targets.each do |target|
+      if target.name == 'expo-gliph-player'
+        target.build_configurations.each do |config|
+          config.build_settings['DEFINES_MODULE'] = 'YES'
+          config.build_settings['SWIFT_INSTALL_OBJC_HEADER'] = 'YES'
+          config.build_settings['SWIFT_OBJC_INTERFACE_HEADER_NAME'] = 'expo_gliph_player-Swift.h'
+          config.build_settings['SWIFT_VERSION'] = '5.9'
+          # RCT_NEW_ARCH_ENABLED is intentionally left alone here — it should
+          # come from the host app's actual architecture setting via Expo/RN
+          # autolinking, not be forced on unconditionally (see podspec).
+        end
+      end
+    end`;
+
+            content = content.replace(
+                /post_install do \|installer\|/,
+                `post_install do |installer|${gliphConfig}`
+            );
+        }
+
+        config.modResults.contents = content;
+        return config;
+    });
+
+    // ===== Android: AndroidManifest.xml =====
+    config = withAndroidManifest(config, (config) => {
+        const manifest = config.modResults;
+        const application = manifest.manifest?.application?.[0];
+        if (!application) return config;
+
+        if (!application.service) application.service = [];
+
+        const hasService = application.service.some(
+            (s) => s.$?.['android:name'] === 'com.gliphplayer.GliphPlayerService',
+        );
+
+        if (!hasService) {
+            const serviceData = {
+                $: {
+                    'android:name': 'com.gliphplayer.GliphPlayerService',
+                    'android:exported': 'true',
+                    'android:foregroundServiceType': 'mediaPlayback',
+                    'android:stopWithTask': 'false',
+                },
+                'intent-filter': [{
+                    action: [
+                        { $: { 'android:name': 'androidx.media3.session.MediaLibraryService' } },
+                        { $: { 'android:name': 'android.media.browse.MediaBrowserService' } },
+                    ],
+                }],
+            };
+            application.service.push(serviceData);
+        }
+        return config;
+    });
+
+    // ===== Android: MainApplication.kt =====
+    config = withDangerousMod(config, [
+        'android',
+        async (config) => {
+            // Derive the path from the project's real Android package name instead
+            // of guessing against a hardcoded list of paths from one specific app.
+            const pkg = config.android?.package;
+            if (!pkg) {
+                console.warn(
+                    "[expo-gliph-player] Couldn't determine the Android package name " +
+                    '(config.android.package is missing) — skipping MainApplication.kt patch. ' +
+                    'Set "android.package" in app.json/app.config.js.'
+                );
+                return config;
+            }
+
+            const pkgPath = pkg.replace(/\./g, '/');
+            const mainAppPath = path.join(
+                config.modRequest.projectRoot,
+                `android/app/src/main/java/${pkgPath}/MainApplication.kt`
+            );
+
+            if (fs.existsSync(mainAppPath)) {
+                let content = fs.readFileSync(mainAppPath, 'utf8');
+
+                if (!content.includes('import com.gliphplayer.GliphPlayerPackage')) {
+                    const lines = content.split('\n');
+                    let lastImportIndex = -1;
+                    for (let i = 0; i < lines.length; i++) {
+                        if (lines[i].trim().startsWith('import ')) {
+                            lastImportIndex = i;
+                        }
+                    }
+                    if (lastImportIndex !== -1) {
+                        lines.splice(lastImportIndex + 1, 0, 'import com.gliphplayer.GliphPlayerPackage');
+                        content = lines.join('\n');
+                    }
+                }
+
+                if (!content.includes('add(GliphPlayerPackage())')) {
+                    const applyRegex = /PackageList\(this\)\.packages\.apply\s*\{/;
+                    if (applyRegex.test(content)) {
+                        content = content.replace(
+                            applyRegex,
+                            (match) => `${match}\n          add(GliphPlayerPackage())`
+                        );
+                    }
+                }
+
+                fs.writeFileSync(mainAppPath, content, 'utf8');
+            } else {
+                console.warn(`[expo-gliph-player] MainApplication.kt not found at ${mainAppPath} — skipping patch.`);
+            }
+            return config;
+        },
+    ]);
+
+    return config;
+};