react-native-mp3-player 1.0.0

package/src/interfaces/UpdateOptions.ts

@@ -0,0 +1,59 @@
+import type { AndroidOptions } from './AndroidOptions';
+import type { FeedbackOptions } from './FeedbackOptions';
+import type { ResourceObject } from './ResourceObject';
+import type { RatingType, Capability } from '../constants';
+import { CustomButtons } from './CustomButtons';
+
+export interface UpdateOptions {
+  android?: AndroidOptions;
+  ratingType?: RatingType;
+  forwardJumpInterval?: number;
+  backwardJumpInterval?: number;
+  progressUpdateEventInterval?: number; // in seconds
+
+  // ios
+  likeOptions?: FeedbackOptions;
+  dislikeOptions?: FeedbackOptions;
+  bookmarkOptions?: FeedbackOptions;
+
+  capabilities?: Capability[];
+
+  // android
+  /**
+   * @deprecated Use `android` options and `appKilledPlaybackMode` instead.
+   * @example
+   * ```
+   * await TrackPlayer.updateOptions({
+   *   android: {
+   *     appKilledPlaybackMode: AppKilledPlaybackMode.PausePlayback
+   *  },
+   * });
+   *  ```
+   */
+  stoppingAppPausesPlayback?: boolean;
+  /**
+   * @deprecated use `TrackPlayer.updateOptions({ android: { alwaysPauseOnInterruption: boolean }})` instead
+   */
+  alwaysPauseOnInterruption?: boolean;
+  notificationCapabilities?: Capability[];
+  compactCapabilities?: Capability[];
+
+  icon?: ResourceObject;
+  playIcon?: ResourceObject;
+  pauseIcon?: ResourceObject;
+  stopIcon?: ResourceObject;
+  previousIcon?: ResourceObject;
+  nextIcon?: ResourceObject;
+  rewindIcon?: ResourceObject;
+  forwardIcon?: ResourceObject;
+  color?: number;
+  /**
+   * Android Only. Specifies custom Actions using the key customActionsList as a list of strings,
+   * then specify the imported icons for the actions to keys for each action.
+   * This is useful for android auto, as any extra buttons (when total > 5, > 4 extra buttons) will show up in a menu.
+   * please note customActions will always show in the notification bar, because there is no other way
+   * they will be called.
+   * isCompat is always false unless there is a need to show them.
+   */
+  customActions?: CustomButtons;
+}

package/src/interfaces/events/AudioMetadataReceivedEvent.ts

@@ -0,0 +1,37 @@
+export interface AudioMetadataReceivedEvent {
+  metadata: AudioMetadata[];
+}
+
+export interface AudioCommonMetadataReceivedEvent {
+  metadata: AudioCommonMetadata;
+}
+
+export interface AudioCommonMetadata {
+  title: string | undefined;
+  artist: string | undefined;
+  albumTitle: string | undefined;
+  subtitle: string | undefined;
+  description: string | undefined;
+  artworkUri: string | undefined;
+  trackNumber: string | undefined;
+  composer: string | undefined;
+  conductor: string | undefined;
+  genre: string | undefined;
+  compilation: string | undefined;
+  station: string | undefined;
+  mediaType: string | undefined;
+  creationDate: string | undefined;
+  creationYear: string | undefined;
+}
+
+export interface AudioMetadata extends AudioCommonMetadata {
+  raw: RawEntry[];
+}
+
+export interface RawEntry {
+  commonKey: string | undefined;
+  keySpace: string | undefined;
+  time: number | undefined;
+  value: unknown | null;
+  key: string;
+}

package/src/interfaces/events/ControllerConnectedEvent.ts

@@ -0,0 +1,9 @@
+export interface ControllerConnectedEvent extends ControllerDisconnectedEvent {
+  isMediaNotificationController: boolean;
+  isAutomotiveController: boolean;
+  isAutoCompanionController: boolean;
+}
+
+export interface ControllerDisconnectedEvent {
+  package: string;
+}

package/src/interfaces/events/EventPayloadByEvent.ts

@@ -0,0 +1,76 @@
+import { Event } from '../../constants';
+
+import type { PlaybackState } from '../PlaybackState';
+import type { PlaybackActiveTrackChangedEvent } from './PlaybackActiveTrackChangedEvent';
+import type { PlaybackErrorEvent } from './PlaybackErrorEvent';
+import type { PlaybackMetadataReceivedEvent } from './PlaybackMetadataReceivedEvent';
+import type { AudioMetadataReceivedEvent } from './AudioMetadataReceivedEvent';
+import type { AudioCommonMetadataReceivedEvent } from './AudioMetadataReceivedEvent';
+import type { PlaybackPlayWhenReadyChangedEvent } from './PlaybackPlayWhenReadyChangedEvent';
+import type { PlaybackProgressUpdatedEvent } from './PlaybackProgressUpdatedEvent';
+import type { PlaybackQueueEndedEvent } from './PlaybackQueueEndedEvent';
+import type { PlaybackTrackChangedEvent } from './PlaybackTrackChangedEvent';
+import { PlayerErrorEvent } from './PlayerErrorEvent';
+import type { RemoteDuckEvent } from './RemoteDuckEvent';
+import type { RemoteJumpBackwardEvent } from './RemoteJumpBackwardEvent';
+import type { RemoteJumpForwardEvent } from './RemoteJumpForwardEvent';
+import type { RemotePlayIdEvent } from './RemotePlayIdEvent';
+import type { RemotePlaySearchEvent } from './RemotePlaySearchEvent';
+import type { RemoteSeekEvent } from './RemoteSeekEvent';
+import type { RemoteSetRatingEvent } from './RemoteSetRatingEvent';
+import type { RemoteSkipEvent } from './RemoteSkipEvent';
+import type { PlaybackAnimatedVolumeChangedEvent } from './PlaybackAnimatedVolumeChangedEvent';
+import type { RemoteBrowseEvent } from './RemoteBrowseEvent';
+import type { RemoteCustomActionEvent } from './RemoteCustomActionEvent';
+import type { PlaybackResumeEvent } from './PlaybackResumeEvent';
+import type {
+  ControllerConnectedEvent,
+  ControllerDisconnectedEvent,
+} from './ControllerConnectedEvent';
+
+export type EventPayloadByEvent = {
+  [Event.PlayerError]: PlayerErrorEvent;
+  [Event.PlaybackState]: PlaybackState;
+  [Event.PlaybackError]: PlaybackErrorEvent;
+  [Event.PlaybackQueueEnded]: PlaybackQueueEndedEvent;
+  [Event.PlaybackTrackChanged]: PlaybackTrackChangedEvent;
+  [Event.PlaybackActiveTrackChanged]: PlaybackActiveTrackChangedEvent;
+  [Event.PlaybackMetadataReceived]: PlaybackMetadataReceivedEvent;
+  [Event.PlaybackPlayWhenReadyChanged]: PlaybackPlayWhenReadyChangedEvent;
+  [Event.PlaybackProgressUpdated]: PlaybackProgressUpdatedEvent;
+  [Event.RemotePlay]: never;
+  [Event.RemotePlayPause]: never;
+  [Event.RemotePlayId]: RemotePlayIdEvent;
+  [Event.RemotePlaySearch]: RemotePlaySearchEvent;
+  [Event.RemotePause]: never;
+  [Event.RemoteStop]: never;
+  [Event.RemoteSkip]: RemoteSkipEvent;
+  [Event.RemoteNext]: never;
+  [Event.RemotePrevious]: never;
+  [Event.RemoteJumpForward]: RemoteJumpForwardEvent | null;
+  [Event.RemoteJumpBackward]: RemoteJumpBackwardEvent | null;
+  [Event.RemoteSeek]: RemoteSeekEvent;
+  [Event.RemoteSetRating]: RemoteSetRatingEvent;
+  [Event.RemoteDuck]: RemoteDuckEvent;
+  [Event.RemoteLike]: never;
+  [Event.RemoteDislike]: never;
+  [Event.RemoteBookmark]: never;
+  [Event.PlaybackAnimatedVolumeChanged]: PlaybackAnimatedVolumeChangedEvent;
+  [Event.RemoteBrowse]: RemoteBrowseEvent;
+  [Event.PlaybackResume]: PlaybackResumeEvent;
+  [Event.RemoteCustomAction]: RemoteCustomActionEvent;
+  [Event.MetadataChapterReceived]: AudioMetadataReceivedEvent;
+  [Event.MetadataTimedReceived]: AudioMetadataReceivedEvent;
+  [Event.MetadataCommonReceived]: AudioCommonMetadataReceivedEvent;
+  [Event.connectorConnected]: ControllerConnectedEvent;
+  [Event.connectorDisconnected]: ControllerDisconnectedEvent;
+};
+
+// eslint-disable-next-line
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+
+export type EventPayloadByEventWithType = {
+  [K in keyof EventPayloadByEvent]: EventPayloadByEvent[K] extends never
+    ? { type: K }
+    : Simplify<EventPayloadByEvent[K] & { type: K }>;
+};

package/src/interfaces/events/PlaybackActiveTrackChangedEvent.ts

@@ -0,0 +1,29 @@
+import type { Track } from '../Track';
+
+export interface PlaybackActiveTrackChangedEvent {
+  /** The index of previously active track. */
+  lastIndex?: number;
+
+  /**
+   * The previously active track or `undefined` when there wasn't a previously
+   * active track.
+   */
+  lastTrack?: Track;
+
+  /**
+   * The position of the previously active track in seconds.
+   */
+  lastPosition: number;
+
+  /**
+   * The newly active track index or `undefined` if there is no longer an
+   * active track.
+   */
+  index?: number;
+
+  /**
+   * The newly active track or `undefined` if there is no longer an
+   * active track.
+   */
+  track?: Track;
+}

package/src/interfaces/events/PlaybackAnimatedVolumeChangedEvent.ts

@@ -0,0 +1,4 @@
+export interface PlaybackAnimatedVolumeChangedEvent {
+  /** the event message */
+  data: string;
+}

package/src/interfaces/events/PlaybackErrorEvent.ts

@@ -0,0 +1,6 @@
+export interface PlaybackErrorEvent {
+  /** The error code */
+  code: string;
+  /** The error message */
+  message: string;
+}

package/src/interfaces/events/PlaybackMetadataReceivedEvent.ts

@@ -0,0 +1,16 @@
+export interface PlaybackMetadataReceivedEvent {
+  /** The metadata source  */
+  source: string;
+  /** The track title */
+  title: string | null;
+  /** The track url */
+  url: string | null;
+  /** The track artist */
+  artist: string | null;
+  /** The track album */
+  album: string | null;
+  /** The track date */
+  date: string | null;
+  /** The track genre */
+  genre: string | null;
+}

package/src/interfaces/events/PlaybackPlayWhenReadyChangedEvent.ts

@@ -0,0 +1,4 @@
+export interface PlaybackPlayWhenReadyChangedEvent {
+  /** Whether the player will play when it is ready to do so. */
+  playWhenReady: boolean;
+}

package/src/interfaces/events/PlaybackProgressUpdatedEvent.ts

@@ -0,0 +1,5 @@
+import type { Progress } from '../Progress';
+
+export interface PlaybackProgressUpdatedEvent extends Progress {
+  track: number;
+}

package/src/interfaces/events/PlaybackQueueEndedEvent.ts

@@ -0,0 +1,9 @@
+export interface PlaybackQueueEndedEvent {
+  /** The index of the active track when the playback queue ended. */
+  track: number;
+  /**
+   * The playback position in seconds of the active track when the playback
+   * queue ended.
+   **/
+  position: number;
+}

package/src/interfaces/events/PlaybackResumeEvent.ts

@@ -0,0 +1,5 @@
+import type { Progress } from '../Progress';
+
+export interface PlaybackResumeEvent {
+  package: string;
+}

package/src/interfaces/events/PlaybackTrackChangedEvent.ts

@@ -0,0 +1,11 @@
+/**
+ * @deprecated
+ */
+export interface PlaybackTrackChangedEvent {
+  /** The index of previously active track. */
+  track: number | null;
+  /** The previous track position in seconds. */
+  position: number;
+  /** The next (active) track index. */
+  nextTrack: number;
+}

package/src/interfaces/events/PlayerErrorEvent.ts

@@ -0,0 +1,6 @@
+export interface PlayerErrorEvent {
+  /** The error code */
+  code: 'android-foreground-service-start-not-allowed';
+  /** The error message */
+  message: string;
+}

package/src/interfaces/events/RemoteBrowseEvent.ts

@@ -0,0 +1,4 @@
+export interface RemoteBrowseEvent {
+  /** The browsable media id */
+  mediaId: string;
+}

package/src/interfaces/events/RemoteCustomActionEvent.ts

@@ -0,0 +1,7 @@
+export interface RemoteCustomActionEvent {
+  /**
+   * The custom action button pressed event.
+   * remote-custom-action
+   **/
+  customAction: string;
+}

package/src/interfaces/events/RemoteDuckEvent.ts

@@ -0,0 +1,13 @@
+export interface RemoteDuckEvent {
+  /**
+   * On Android when true the player should pause playback, when false the
+   * player may resume playback. On iOS when true the playback was paused and
+   * when false the player may resume playback.
+   **/
+  paused: boolean;
+  /**
+   * Whether the interruption is permanent. On Android the player should stop
+   * playback.
+   **/
+  permanent: boolean;
+}

package/src/interfaces/events/RemoteJumpBackwardEvent.ts

@@ -0,0 +1,8 @@
+export interface RemoteJumpBackwardEvent {
+  /**
+   * The number of seconds to jump backward.
+   * May be missing on Android
+   * See https://rntp.dev/docs/api/events#remotejumpbackward
+   **/
+  interval?: number;
+}

package/src/interfaces/events/RemoteJumpForwardEvent.ts

@@ -0,0 +1,8 @@
+export interface RemoteJumpForwardEvent {
+  /**
+   * The number of seconds to jump forward.
+   * May be missing on Android
+   * See https://rntp.dev/docs/api/events#remotejumpforward
+   **/
+  interval?: number;
+}

package/src/interfaces/events/RemotePlayIdEvent.ts

@@ -0,0 +1,4 @@
+export interface RemotePlayIdEvent {
+  /** The track id */
+  id: string;
+}

package/src/interfaces/events/RemotePlaySearchEvent.ts

@@ -0,0 +1,21 @@
+export interface RemotePlaySearchEvent {
+  /*
+  below is the Google Voice event log:
+  Event.RemotePlaySearchEvent {
+    "android.intent.extra.REFERRER_NAME": "android-app://com.google.android.googlequicksearchbox/https/www.google.com",
+    "android.intent.extra.START_PLAYBACK": true,
+    "android.intent.extra.focus": "vnd.android.cursor.item/*",
+    "android.intent.extra.user_query": "play seat",
+    "android.intent.extra.user_query_language": "en-US",
+    "com.google.android.projection.gearhead.ignore_original_pkg": false,
+    "opa_allow_launch_intent_on_lockscreen": true,
+    "query": "seat"} 
+  */
+  query: string;
+  focus?: 'artist' | 'album' | 'playlist' | 'genre';
+  title?: string;
+  artist?: string;
+  album?: string;
+  date?: string;
+  playlist?: string;
+}

package/src/interfaces/events/RemoteSeekEvent.ts

@@ -0,0 +1,4 @@
+export interface RemoteSeekEvent {
+  /** The position to seek to in seconds. */
+  position: number;
+}

package/src/interfaces/events/RemoteSetRatingEvent.ts

@@ -0,0 +1,5 @@
+import type { RatingType } from '../../constants';
+
+export interface RemoteSetRatingEvent {
+  rating: RatingType;
+}

package/src/interfaces/events/RemoteSkipEvent.ts

@@ -0,0 +1,3 @@
+export interface RemoteSkipEvent {
+  index: number;
+}

package/src/interfaces/events/index.ts

@@ -0,0 +1,18 @@
+export * from './EventPayloadByEvent';
+export * from './PlaybackActiveTrackChangedEvent';
+export * from './PlaybackErrorEvent';
+export * from './PlaybackMetadataReceivedEvent';
+export * from './PlaybackPlayWhenReadyChangedEvent';
+export * from './PlaybackProgressUpdatedEvent';
+export * from './PlaybackQueueEndedEvent';
+export * from './PlaybackTrackChangedEvent';
+export * from './RemoteDuckEvent';
+export * from './RemoteJumpBackwardEvent';
+export * from './RemoteJumpForwardEvent';
+export * from './RemotePlayIdEvent';
+export * from './RemotePlaySearchEvent';
+export * from './RemoteSeekEvent';
+export * from './RemoteSetRatingEvent';
+export * from './RemoteSkipEvent';
+export * from './RemoteBrowseEvent';
+export * from './ControllerConnectedEvent';

package/src/interfaces/index.ts

@@ -0,0 +1,15 @@
+export * from './AndroidOptions';
+export * from './FeedbackOptions';
+export * from './MetadataOptions';
+export * from './NowPlayingMetadata';
+export * from './PlaybackState';
+export * from './PlayerOptions';
+export * from './Progress';
+export * from './ResourceObject';
+export * from './ServiceHandler';
+export * from './Track';
+export * from './TrackMetadataBase';
+export * from './UpdateOptions';
+export * from './events';
+export * from './MediaItem';
+export * from './AndroidAutoBrowseTree';

package/src/resolveAssetSource.ts

@@ -0,0 +1,3 @@
+// @ts-expect-error because resolveAssetSource is untyped
+import resolve from 'react-native/Libraries/Image/resolveAssetSource';
+export default resolve;