expo-native-track-player 0.1.1

package/ios/ExpoNativeTrackPlayer.mm

@@ -0,0 +1,475 @@
+#import "ExpoNativeTrackPlayer.h"
+#import <AVFoundation/AVFoundation.h>
+#import <React/RCTBridge.h>
+
+@interface ExpoNativeTrackPlayer ()
+
+@property (nonatomic, strong) AVPlayer *player;
+@property (nonatomic, strong) NSMutableArray<NSDictionary *> *queue;
+@property (nonatomic, assign) NSInteger currentIndex;
+@property (nonatomic, copy) NSString *repeatMode;
+@property (nonatomic, strong, nullable) NSNumber *loopStartMs;
+@property (nonatomic, strong, nullable) NSNumber *loopEndMs;
+@property (nonatomic, copy) NSString *playbackState;
+@property (nonatomic, assign) float playbackRate;
+@property (nonatomic, strong, nullable) id timeObserver;
+@property (nonatomic, strong, nullable) id endObserver;
+
+@end
+
+@implementation ExpoNativeTrackPlayer
+
+RCT_EXPORT_MODULE();
+@synthesize bridge = _bridge;
+
+static NSString *const ExpoNativeTrackPlayerEventPlaybackState = @"playback-state";
+static NSString *const ExpoNativeTrackPlayerEventPlaybackProgress = @"playback-progress-updated";
+static NSString *const ExpoNativeTrackPlayerEventPlaybackActiveTrackChanged =
+  @"playback-active-track-changed";
+static NSString *const ExpoNativeTrackPlayerEventPlaybackQueueEnded =
+  @"playback-queue-ended";
+static NSString *const ExpoNativeTrackPlayerEventQueueUpdated = @"queue-updated";
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _player = [[AVPlayer alloc] init];
+    _queue = [NSMutableArray array];
+    _currentIndex = -1;
+    _repeatMode = @"off";
+    _playbackState = @"stopped";
+    _playbackRate = 1.0f;
+    [self configureAudioSession];
+    [self startLoopWatcher];
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  if (_timeObserver != nil) {
+    [_player removeTimeObserver:_timeObserver];
+    _timeObserver = nil;
+  }
+  if (_endObserver != nil) {
+    [[NSNotificationCenter defaultCenter] removeObserver:_endObserver];
+    _endObserver = nil;
+  }
+}
+
+- (NSDictionary *)dictionaryFromTrack:(JS::NativeExpoNativeTrackPlayer::TrackMetadata &)track
+{
+  NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
+  dictionary[@"id"] = track.id_();
+  dictionary[@"url"] = track.url();
+
+  if (track.title().length > 0) dictionary[@"title"] = track.title();
+  if (track.artist().length > 0) dictionary[@"artist"] = track.artist();
+  if (track.albumName().length > 0) dictionary[@"albumName"] = track.albumName();
+  if (track.artworkUri().length > 0) dictionary[@"artworkUri"] = track.artworkUri();
+  if (track.type().length > 0) dictionary[@"type"] = track.type();
+  if (track.userAgent().length > 0) dictionary[@"userAgent"] = track.userAgent();
+  if (track.contentType().length > 0) dictionary[@"contentType"] = track.contentType();
+  if (track.pitchAlgorithm().length > 0) dictionary[@"pitchAlgorithm"] = track.pitchAlgorithm();
+  if (track.composer().length > 0) dictionary[@"composer"] = track.composer();
+  if (track.conductor().length > 0) dictionary[@"conductor"] = track.conductor();
+  if (track.genre().length > 0) dictionary[@"genre"] = track.genre();
+  if (track.compilation().length > 0) dictionary[@"compilation"] = track.compilation();
+  if (track.subtitle().length > 0) dictionary[@"subtitle"] = track.subtitle();
+  if (track.description().length > 0) dictionary[@"description"] = track.description();
+  if (track.station().length > 0) dictionary[@"station"] = track.station();
+  if (track.trackNumber().has_value()) {
+    dictionary[@"trackNumber"] = @(track.trackNumber().value());
+  }
+  if (track.duration().has_value()) {
+    dictionary[@"duration"] = @(track.duration().value());
+  }
+  if (track.mediaType().has_value()) {
+    dictionary[@"mediaType"] = @(track.mediaType().value());
+  }
+
+  return dictionary;
+}
+
+- (NSNumber * _Nullable)nullableNumberFrom:(NSNumber *)value
+{
+  if (value == (id)kCFNull) return nil;
+  return value;
+}
+
+- (void)addListener:(NSString *)eventName
+{
+}
+
+- (void)removeListeners:(double)count
+{
+}
+
+- (void)emitEvent:(NSString *)name body:(NSDictionary *)body
+{
+  if (self.bridge == nil || name.length == 0) return;
+  NSArray *args = body != nil ? @[name, body] : @[name, [NSNull null]];
+  [self.bridge enqueueJSCall:@"RCTDeviceEventEmitter" method:@"emit" args:args completion:NULL];
+}
+
+- (void)emitPlaybackState
+{
+  [self emitEvent:ExpoNativeTrackPlayerEventPlaybackState body:@{
+    @"state": self.playbackState ?: @"stopped"
+  }];
+}
+
+- (void)emitQueueUpdated
+{
+  NSDictionary *payload = @{
+    @"count": @(self.queue.count),
+    @"trackIndex": @(self.currentIndex),
+    @"queue": [self.queue copy]
+  };
+  [self emitEvent:ExpoNativeTrackPlayerEventQueueUpdated body:payload];
+}
+
+- (void)emitTrackChanged
+{
+  NSDictionary *track = nil;
+  if (self.currentIndex >= 0 && self.currentIndex < (NSInteger)self.queue.count) {
+    track = self.queue[(NSUInteger)self.currentIndex];
+  }
+  NSDictionary *payload = @{
+    @"trackIndex": @(self.currentIndex),
+    @"track": track ?: (id)kCFNull
+  };
+  [self emitEvent:ExpoNativeTrackPlayerEventPlaybackActiveTrackChanged body:payload];
+}
+
+- (void)emitPlaybackPositionWithPosition:(double)position
+                               duration:(double)duration
+                              trackIndex:(NSInteger)trackIndex
+{
+  NSDictionary *payload = @{
+    @"position": @(position),
+    @"duration": @(duration),
+    @"trackIndex": @(trackIndex)
+  };
+  [self emitEvent:ExpoNativeTrackPlayerEventPlaybackProgress body:payload];
+}
+
+- (void)emitPlaybackQueueEnded
+{
+  NSDictionary *payload = @{
+    @"trackIndex": @(self.currentIndex),
+    @"position": @([self getPosition].doubleValue)
+  };
+  [self emitEvent:ExpoNativeTrackPlayerEventPlaybackQueueEnded body:payload];
+}
+
+- (void)addToQueue:(JS::NativeExpoNativeTrackPlayer::TrackMetadata &)track
+{
+  NSDictionary *dictionary = [self dictionaryFromTrack:track];
+  [self.queue addObject:dictionary];
+  [self emitQueueUpdated];
+}
+
+- (void)addQueue:(NSArray *)tracks
+{
+  if (tracks == nil) return;
+  for (NSDictionary *track in tracks) {
+    if (![track isKindOfClass:[NSDictionary class]]) continue;
+    [self.queue addObject:track];
+  }
+  [self emitQueueUpdated];
+}
+
+- (NSArray<NSDictionary *> *)getQueue
+{
+  return [self.queue copy];
+}
+
+- (void)removeFromQueue:(NSString *)trackId
+{
+  if (trackId.length == 0) return;
+  __block NSInteger indexToRemove = NSNotFound;
+  [self.queue enumerateObjectsUsingBlock:^(NSDictionary *track, NSUInteger idx, BOOL *stop) {
+    if ([[track objectForKey:@"id"] isEqualToString:trackId]) {
+      indexToRemove = (NSInteger)idx;
+      *stop = YES;
+    }
+  }];
+  if (indexToRemove == NSNotFound) return;
+
+  [self.queue removeObjectAtIndex:indexToRemove];
+  if (indexToRemove == self.currentIndex) {
+    [self stopInternal];
+    self.currentIndex = -1;
+    [self emitTrackChanged];
+  } else if (indexToRemove < self.currentIndex) {
+    self.currentIndex -= 1;
+    [self emitTrackChanged];
+  }
+  [self emitQueueUpdated];
+}
+
+- (void)clearQueue
+{
+  [self.queue removeAllObjects];
+  [self stopInternal];
+  self.currentIndex = -1;
+  [self emitQueueUpdated];
+  [self emitTrackChanged];
+}
+
+- (void)play:(NSNumber *)index
+{
+  [self playInternal:[self nullableNumberFrom:index]];
+}
+
+- (void)pause
+{
+  [self.player pause];
+  [self setPlaybackState:@"paused"];
+}
+
+- (void)stop
+{
+  [self stopInternal];
+}
+
+- (void)skipToNext
+{
+  [self playInternal:@(self.currentIndex + 1)];
+}
+
+- (void)skipToPrevious
+{
+  [self playInternal:@(self.currentIndex - 1)];
+}
+
+- (void)skipToIndex:(double)index
+{
+  [self playInternal:@((NSInteger)index)];
+}
+
+- (void)seekTo:(double)positionMs
+{
+  CMTime position = CMTimeMakeWithSeconds(positionMs / 1000.0, 600);
+  [self.player seekToTime:position];
+}
+
+- (void)reset
+{
+  [self.queue removeAllObjects];
+  [self stopInternal];
+  self.currentIndex = -1;
+  [self emitQueueUpdated];
+  [self emitTrackChanged];
+}
+
+- (void)setRepeatMode:(NSString *)mode startMs:(NSNumber *)startMs endMs:(NSNumber *)endMs
+{
+  self.repeatMode = mode ?: @"off";
+  self.loopStartMs = [self nullableNumberFrom:startMs];
+  self.loopEndMs = [self nullableNumberFrom:endMs];
+}
+
+- (NSString *)getRepeatMode
+{
+  return self.repeatMode;
+}
+
+- (NSDictionary * _Nullable)getCurrentTrack
+{
+  if (self.currentIndex < 0 || self.currentIndex >= (NSInteger)self.queue.count) return nil;
+  return self.queue[self.currentIndex];
+}
+
+- (NSNumber *)getCurrentTrackIndex
+{
+  return @(self.currentIndex);
+}
+
+- (NSNumber *)getPosition
+{
+  return @(CMTimeGetSeconds([self.player currentTime]) * 1000.0);
+}
+
+- (NSNumber *)getDuration
+{
+  double duration = CMTimeGetSeconds(self.player.currentItem.duration);
+  return @(isfinite(duration) ? duration * 1000.0 : 0.0);
+}
+
+- (NSString *)getPlaybackState
+{
+  return self.playbackState;
+}
+
+- (void)setVolume:(double)volume
+{
+  self.player.volume = (float)volume;
+}
+
+- (NSNumber *)getVolume
+{
+  return @(self.player.volume);
+}
+
+- (void)setRate:(double)rate
+{
+  self.playbackRate = (float)rate;
+  if ([self.playbackState isEqualToString:@"playing"]) {
+    [self.player playImmediatelyAtRate:self.playbackRate];
+  }
+}
+
+- (NSNumber *)getRate
+{
+  return @(self.playbackRate);
+}
+
+- (void)playInternal:(NSNumber * _Nullable)index
+{
+  if (self.queue.count == 0) return;
+  if (index != nil) {
+    NSInteger target = [index integerValue];
+    if (target < 0 || target >= (NSInteger)self.queue.count) return;
+    [self loadTrackAtIndex:target];
+  } else if (self.currentIndex < 0) {
+    [self loadTrackAtIndex:0];
+  }
+  [self.player playImmediatelyAtRate:self.playbackRate];
+  [self setPlaybackState:@"playing"];
+}
+
+- (void)loadTrackAtIndex:(NSInteger)index
+{
+  NSDictionary *track = self.queue[index];
+  NSString *urlString = [track objectForKey:@"url"];
+  if (urlString.length == 0) return;
+  NSURL *url = [NSURL URLWithString:urlString];
+  if (!url) return;
+
+  AVPlayerItem *item = [AVPlayerItem playerItemWithURL:url];
+  [self.player replaceCurrentItemWithPlayerItem:item];
+  self.currentIndex = index;
+  [self observeItemEnd:item];
+  [self emitTrackChanged];
+}
+
+- (void)observeItemEnd:(AVPlayerItem *)item
+{
+  if (self.endObserver != nil) {
+    [[NSNotificationCenter defaultCenter] removeObserver:self.endObserver];
+  }
+  __weak ExpoNativeTrackPlayer *weakSelf = self;
+  self.endObserver = [[NSNotificationCenter defaultCenter]
+    addObserverForName:AVPlayerItemDidPlayToEndTimeNotification
+                object:item
+                 queue:[NSOperationQueue mainQueue]
+            usingBlock:^(NSNotification *note) {
+              [weakSelf handleTrackEnded];
+            }];
+}
+
+- (void)handleTrackEnded
+{
+  if ([self.repeatMode isEqualToString:@"track"]) {
+    [self.player seekToTime:kCMTimeZero];
+    [self.player playImmediatelyAtRate:self.playbackRate];
+    return;
+  }
+  if ([self.repeatMode isEqualToString:@"queue"]) {
+    NSInteger nextIndex = self.currentIndex + 1;
+    if (nextIndex >= (NSInteger)self.queue.count) {
+      [self loadTrackAtIndex:0];
+    } else {
+      [self loadTrackAtIndex:nextIndex];
+    }
+    [self.player playImmediatelyAtRate:self.playbackRate];
+    return;
+  }
+  if ([self.repeatMode isEqualToString:@"loop_portion"]) {
+    [self seekToLoopStart];
+    [self.player playImmediatelyAtRate:self.playbackRate];
+    return;
+  }
+  NSInteger nextIndex = self.currentIndex + 1;
+  if (nextIndex < (NSInteger)self.queue.count) {
+    [self loadTrackAtIndex:nextIndex];
+    [self.player playImmediatelyAtRate:self.playbackRate];
+  } else {
+    [self setPlaybackState:@"ended"];
+    [self emitPlaybackQueueEnded];
+  }
+}
+
+- (void)startLoopWatcher
+{
+  __weak ExpoNativeTrackPlayer *weakSelf = self;
+  CMTime interval = CMTimeMakeWithSeconds(0.1, 600);
+  self.timeObserver = [self.player addPeriodicTimeObserverForInterval:interval
+                                                                queue:dispatch_get_main_queue()
+                                                           usingBlock:^(CMTime time) {
+    double positionMs = CMTimeGetSeconds(time) * 1000.0;
+    [weakSelf handleLoopPortionIfNeeded:positionMs];
+    double durationMs = 0.0;
+    AVPlayerItem *item = weakSelf.player.currentItem;
+    if (item != nil) {
+      durationMs = CMTimeGetSeconds(item.duration) * 1000.0;
+      if (isnan(durationMs) || isinf(durationMs)) {
+        durationMs = 0.0;
+      }
+    }
+    [weakSelf emitPlaybackPositionWithPosition:positionMs
+                                      duration:durationMs
+                                     trackIndex:weakSelf.currentIndex];
+  }];
+}
+
+- (void)handleLoopPortionIfNeeded:(double)positionMs
+{
+  if (![self.repeatMode isEqualToString:@"loop_portion"]) return;
+  if (self.loopStartMs == nil || self.loopEndMs == nil) return;
+  double startMs = [self.loopStartMs doubleValue];
+  double endMs = [self.loopEndMs doubleValue];
+  if (endMs <= startMs) return;
+  if (positionMs >= endMs) {
+    [self seekToLoopStart];
+  }
+}
+
+- (void)seekToLoopStart
+{
+  double startMs = self.loopStartMs != nil ? [self.loopStartMs doubleValue] : 0.0;
+  CMTime position = CMTimeMakeWithSeconds(startMs / 1000.0, 600);
+  [self.player seekToTime:position];
+}
+
+- (void)stopInternal
+{
+  [self.player pause];
+  [self.player seekToTime:kCMTimeZero];
+  [self setPlaybackState:@"stopped"];
+}
+
+- (void)setPlaybackState:(NSString *)state
+{
+  NSString *nextState = state ?: @"stopped";
+  _playbackState = [nextState copy];
+  [self emitPlaybackState];
+}
+
+- (void)configureAudioSession
+{
+  AVAudioSession *session = [AVAudioSession sharedInstance];
+  NSError *error = nil;
+  [session setCategory:AVAudioSessionCategoryPlayback error:&error];
+  [session setActive:YES error:&error];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeExpoNativeTrackPlayerSpecJSI>(params);
+}
+
+@end

package/lib/module/NativeExpoNativeTrackPlayer.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('ExpoNativeTrackPlayer');
+//# sourceMappingURL=NativeExpoNativeTrackPlayer.js.map

package/lib/module/NativeExpoNativeTrackPlayer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeExpoNativeTrackPlayer.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;AAqEpE,eAAeA,mBAAmB,CAACC,YAAY,CAAO,uBAAuB,CAAC","ignoreList":[]}

package/lib/module/constants.js

@@ -0,0 +1,31 @@
+"use strict";
+
+export const TrackTypes = {
+  Default: 'default',
+  Dash: 'dash',
+  Hls: 'hls',
+  SmoothStreaming: 'smoothstreaming'
+};
+export const PitchAlgorithms = {
+  Linear: 'linear',
+  Music: 'music',
+  Voice: 'voice'
+};
+export const State = {
+  None: 'none',
+  Ready: 'ready',
+  Playing: 'playing',
+  Paused: 'paused',
+  Stopped: 'stopped',
+  Loading: 'loading',
+  Buffering: 'buffering',
+  Error: 'error',
+  Ended: 'ended'
+};
+export const RepeatModes = {
+  Off: 'off',
+  Track: 'track',
+  Queue: 'queue',
+  LoopPortion: 'loop_portion'
+};
+//# sourceMappingURL=constants.js.map

package/lib/module/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TrackTypes","Default","Dash","Hls","SmoothStreaming","PitchAlgorithms","Linear","Music","Voice","State","None","Ready","Playing","Paused","Stopped","Loading","Buffering","Error","Ended","RepeatModes","Off","Track","Queue","LoopPortion"],"sourceRoot":"../../src","sources":["constants.ts"],"mappings":";;AAAA,OAAO,MAAMA,UAAU,GAAG;EACxBC,OAAO,EAAE,SAAS;EAClBC,IAAI,EAAE,MAAM;EACZC,GAAG,EAAE,KAAK;EACVC,eAAe,EAAE;AACnB,CAAU;AAIV,OAAO,MAAMC,eAAe,GAAG;EAC7BC,MAAM,EAAE,QAAQ;EAChBC,KAAK,EAAE,OAAO;EACdC,KAAK,EAAE;AACT,CAAU;AAKV,OAAO,MAAMC,KAA6B,GAAG;EAC3CC,IAAI,EAAE,MAAM;EACZC,KAAK,EAAE,OAAO;EACdC,OAAO,EAAE,SAAS;EAClBC,MAAM,EAAE,QAAQ;EAChBC,OAAO,EAAE,SAAS;EAClBC,OAAO,EAAE,SAAS;EAClBC,SAAS,EAAE,WAAW;EACtBC,KAAK,EAAE,OAAO;EACdC,KAAK,EAAE;AACT,CAAU;AAIV,OAAO,MAAMC,WAAW,GAAG;EACzBC,GAAG,EAAE,KAAK;EACVC,KAAK,EAAE,OAAO;EACdC,KAAK,EAAE,OAAO;EACdC,WAAW,EAAE;AACf,CAAU","ignoreList":[]}

package/lib/module/events.js

@@ -0,0 +1,56 @@
+"use strict";
+
+import { NativeEventEmitter } from 'react-native';
+import ExpoNativeTrackPlayer from "./NativeExpoNativeTrackPlayer.js";
+export const Event = {
+  PlayerError: 'player-error',
+  PlaybackState: 'playback-state',
+  PlaybackError: 'playback-error',
+  PlaybackQueueEnded: 'playback-queue-ended',
+  PlaybackActiveTrackChanged: 'playback-active-track-changed',
+  PlaybackPlayWhenReadyChanged: 'playback-play-when-ready-changed',
+  PlaybackProgressUpdated: 'playback-progress-updated',
+  PlaybackResume: 'android-playback-resume',
+  RemotePlay: 'remote-play',
+  RemotePlayPause: 'remote-play-pause',
+  RemotePause: 'remote-pause',
+  RemoteStop: 'remote-stop',
+  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',
+  RemotePlayId: 'remote-play-id',
+  RemotePlaySearch: 'remote-play-search',
+  RemoteSkip: 'remote-skip',
+  MetadataChapterReceived: 'metadata-chapter-received',
+  MetadataTimedReceived: 'metadata-timed-received',
+  MetadataCommonReceived: 'metadata-common-received',
+  AndroidConnectorConnected: 'android-controller-connected',
+  AndroidConnectorDisconnected: 'android-controller-disconnected'
+};
+export const TrackPlayerEvents = {
+  ...Event,
+  QueueUpdated: 'queue-updated'
+};
+const emitter = new NativeEventEmitter(ExpoNativeTrackPlayer);
+export function addEventListener(eventName, listener) {
+  return emitter.addListener(eventName, event => listener(event));
+}
+export function addTypedEventListener(eventName, listener) {
+  return emitter.addListener(eventName, event => listener(event));
+}
+export function removeAllEventListeners(eventName) {
+  emitter.removeAllListeners(eventName);
+}
+export const AudioEvents = {
+  addListener: addEventListener,
+  addTypedListener: addTypedEventListener,
+  removeAllListeners: removeAllEventListeners
+};
+//# sourceMappingURL=events.js.map

package/lib/module/events.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeEventEmitter","ExpoNativeTrackPlayer","Event","PlayerError","PlaybackState","PlaybackError","PlaybackQueueEnded","PlaybackActiveTrackChanged","PlaybackPlayWhenReadyChanged","PlaybackProgressUpdated","PlaybackResume","RemotePlay","RemotePlayPause","RemotePause","RemoteStop","RemoteNext","RemotePrevious","RemoteJumpForward","RemoteJumpBackward","RemoteSeek","RemoteSetRating","RemoteDuck","RemoteLike","RemoteDislike","RemoteBookmark","RemotePlayId","RemotePlaySearch","RemoteSkip","MetadataChapterReceived","MetadataTimedReceived","MetadataCommonReceived","AndroidConnectorConnected","AndroidConnectorDisconnected","TrackPlayerEvents","QueueUpdated","emitter","addEventListener","eventName","listener","addListener","event","addTypedEventListener","removeAllEventListeners","removeAllListeners","AudioEvents","addTypedListener"],"sourceRoot":"../../src","sources":["events.ts"],"mappings":";;AAAA,SAASA,kBAAkB,QAAkC,cAAc;AAC3E,OAAOC,qBAAqB,MAGrB,kCAA+B;AAEtC,OAAO,MAAMC,KAAK,GAAG;EACnBC,WAAW,EAAE,cAAc;EAC3BC,aAAa,EAAE,gBAAgB;EAC/BC,aAAa,EAAE,gBAAgB;EAC/BC,kBAAkB,EAAE,sBAAsB;EAC1CC,0BAA0B,EAAE,+BAA+B;EAC3DC,4BAA4B,EAAE,kCAAkC;EAChEC,uBAAuB,EAAE,2BAA2B;EACpDC,cAAc,EAAE,yBAAyB;EACzCC,UAAU,EAAE,aAAa;EACzBC,eAAe,EAAE,mBAAmB;EACpCC,WAAW,EAAE,cAAc;EAC3BC,UAAU,EAAE,aAAa;EACzBC,UAAU,EAAE,aAAa;EACzBC,cAAc,EAAE,iBAAiB;EACjCC,iBAAiB,EAAE,qBAAqB;EACxCC,kBAAkB,EAAE,sBAAsB;EAC1CC,UAAU,EAAE,aAAa;EACzBC,eAAe,EAAE,mBAAmB;EACpCC,UAAU,EAAE,aAAa;EACzBC,UAAU,EAAE,aAAa;EACzBC,aAAa,EAAE,gBAAgB;EAC/BC,cAAc,EAAE,iBAAiB;EACjCC,YAAY,EAAE,gBAAgB;EAC9BC,gBAAgB,EAAE,oBAAoB;EACtCC,UAAU,EAAE,aAAa;EACzBC,uBAAuB,EAAE,2BAA2B;EACpDC,qBAAqB,EAAE,yBAAyB;EAChDC,sBAAsB,EAAE,0BAA0B;EAClDC,yBAAyB,EAAE,8BAA8B;EACzDC,4BAA4B,EAAE;AAChC,CAAU;AAIV,OAAO,MAAMC,iBAAiB,GAAG;EAC/B,GAAG/B,KAAK;EACRgC,YAAY,EAAE;AAChB,CAAU;AAiEV,MAAMC,OAAO,GAAG,IAAInC,kBAAkB,CAACC,qBAAqB,CAAC;AAE7D,OAAO,SAASmC,gBAAgBA,CAC9BC,SAA+B,EAC/BC,QAA4B,EACP;EACrB,OAAOH,OAAO,CAACI,WAAW,CAACF,SAAS,EAAGG,KAAU,IAAKF,QAAQ,CAACE,KAAU,CAAC,CAAC;AAC7E;AAEA,OAAO,SAASC,qBAAqBA,CACnCJ,SAAY,EACZC,QAA6C,EACxB;EACrB,OAAOH,OAAO,CAACI,WAAW,CAACF,SAAS,EAAGG,KAAU,IAC/CF,QAAQ,CAACE,KAA2B,CACtC,CAAC;AACH;AAEA,OAAO,SAASE,uBAAuBA,CAACL,SAA+B,EAAQ;EAC7EF,OAAO,CAACQ,kBAAkB,CAACN,SAAS,CAAC;AACvC;AAEA,OAAO,MAAMO,WAAW,GAAG;EACzBL,WAAW,EAAEH,gBAAgB;EAC7BS,gBAAgB,EAAEJ,qBAAqB;EACvCE,kBAAkB,EAAED;AACtB,CAAC","ignoreList":[]}

package/lib/module/hooks.js

@@ -0,0 +1,105 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+import ExpoNativeTrackPlayer from "./NativeExpoNativeTrackPlayer.js";
+import { addEventListener, Event, TrackPlayerEvents } from "./events.js";
+export function usePlaybackState() {
+  const [state, setState] = useState('none');
+  useEffect(() => {
+    const subscription = addEventListener(Event.PlaybackState, event => setState(event.state));
+    return () => subscription.remove();
+  }, []);
+  return state;
+}
+export function useProgress(intervalMs = 1000) {
+  const [progress, setProgress] = useState({
+    position: 0,
+    duration: 0,
+    trackIndex: -1
+  });
+  useEffect(() => {
+    if (!Number.isFinite(intervalMs) || intervalMs <= 0) return;
+    let isActive = true;
+    const update = () => {
+      if (!isActive) return;
+      try {
+        const position = ExpoNativeTrackPlayer.getPosition();
+        const duration = ExpoNativeTrackPlayer.getDuration();
+        const trackIndex = ExpoNativeTrackPlayer.getCurrentTrackIndex();
+        setProgress({
+          position,
+          duration,
+          trackIndex
+        });
+      } catch (error) {
+        setProgress({
+          position: 0,
+          duration: 0,
+          trackIndex: -1
+        });
+      }
+    };
+    update();
+    const timer = setInterval(update, intervalMs);
+    return () => {
+      isActive = false;
+      clearInterval(timer);
+    };
+  }, [intervalMs]);
+  return progress;
+}
+export function useQueue() {
+  const [queue, setQueue] = useState([]);
+  useEffect(() => {
+    let isActive = true;
+    try {
+      const result = ExpoNativeTrackPlayer.getQueue();
+      if (isActive) setQueue(result);
+    } catch (error) {
+      if (isActive) setQueue([]);
+    }
+    const subscription = addEventListener(TrackPlayerEvents.QueueUpdated, event => setQueue(event.queue));
+    return () => {
+      isActive = false;
+      subscription.remove();
+    };
+  }, []);
+  return queue;
+}
+export function useCurrentTrack() {
+  const [track, setTrack] = useState(null);
+  useEffect(() => {
+    let isActive = true;
+    try {
+      const result = ExpoNativeTrackPlayer.getCurrentTrack();
+      if (isActive) setTrack(result);
+    } catch (error) {
+      if (isActive) setTrack(null);
+    }
+    const subscription = addEventListener(Event.PlaybackActiveTrackChanged, event => setTrack(event.track));
+    return () => {
+      isActive = false;
+      subscription.remove();
+    };
+  }, []);
+  return track;
+}
+export function useCurrentTrackIndex() {
+  const [index, setIndex] = useState(-1);
+  useEffect(() => {
+    let isActive = true;
+    try {
+      const result = ExpoNativeTrackPlayer.getCurrentTrackIndex();
+      if (isActive) setIndex(result);
+    } catch (error) {
+      if (isActive) setIndex(-1);
+    }
+    const subscription = addEventListener(Event.PlaybackActiveTrackChanged, event => setIndex(event.trackIndex));
+    return () => {
+      isActive = false;
+      subscription.remove();
+    };
+  }, []);
+  return index;
+}
+//# sourceMappingURL=hooks.js.map

package/lib/module/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useEffect","useState","ExpoNativeTrackPlayer","addEventListener","Event","TrackPlayerEvents","usePlaybackState","state","setState","subscription","PlaybackState","event","remove","useProgress","intervalMs","progress","setProgress","position","duration","trackIndex","Number","isFinite","isActive","update","getPosition","getDuration","getCurrentTrackIndex","error","timer","setInterval","clearInterval","useQueue","queue","setQueue","result","getQueue","QueueUpdated","useCurrentTrack","track","setTrack","getCurrentTrack","PlaybackActiveTrackChanged","useCurrentTrackIndex","index","setIndex"],"sourceRoot":"../../src","sources":["hooks.ts"],"mappings":"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","ignoreList":[]}