diff --git a/.gitignore b/.gitignore index 7e8c2a4c8..e7a85e20a 100644 --- a/.gitignore +++ b/.gitignore @@ -3,7 +3,6 @@ .DS_Store node_modules/ build/ -lib/ DerivedData/ package-lock.json yarn.lock diff --git a/lib/hooks.d.ts b/lib/hooks.d.ts new file mode 100644 index 000000000..34908fa4e --- /dev/null +++ b/lib/hooks.d.ts @@ -0,0 +1,23 @@ +import { State, Event } from './index'; +/** Get current playback state and subsequent updatates */ +export declare const usePlaybackState: () => State; +declare type Handler = (payload: { + type: Event; + [key: string]: any; +}) => void; +/** + * Attaches a handler to the given TrackPlayer events and performs cleanup on unmount + * @param events - TrackPlayer events to subscribe to + * @param handler - callback invoked when the event fires + */ +export declare const useTrackPlayerEvents: (events: Event[], handler: Handler) => void; +/** + * Poll for track progress for the given interval (in miliseconds) + * @param interval - ms interval + */ +export declare function useProgress(updateInterval?: number): { + position: number; + duration: number; + buffered: number; +}; +export {}; diff --git a/lib/hooks.js b/lib/hooks.js new file mode 100644 index 000000000..f73bd3417 --- /dev/null +++ b/lib/hooks.js @@ -0,0 +1,147 @@ +"use strict"; +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.useProgress = exports.useTrackPlayerEvents = exports.usePlaybackState = void 0; +var react_1 = require("react"); +var index_1 = require("./index"); +/** Get current playback state and subsequent updatates */ +exports.usePlaybackState = function () { + var _a = react_1.useState(index_1.State.None), state = _a[0], setState = _a[1]; + react_1.useEffect(function () { + function setPlayerState() { + return __awaiter(this, void 0, void 0, function () { + var playerState; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, index_1.default.getState()]; + case 1: + playerState = _a.sent(); + setState(playerState); + return [2 /*return*/]; + } + }); + }); + } + setPlayerState(); + var sub = index_1.default.addEventListener(index_1.Event.PlaybackState, function (data) { + setState(data.state); + }); + return function () { + sub.remove(); + }; + }, []); + return state; +}; +/** + * Attaches a handler to the given TrackPlayer events and performs cleanup on unmount + * @param events - TrackPlayer events to subscribe to + * @param handler - callback invoked when the event fires + */ +exports.useTrackPlayerEvents = function (events, handler) { + var savedHandler = react_1.useRef(); + react_1.useEffect(function () { + savedHandler.current = handler; + }, [handler]); + react_1.useEffect(function () { + if (__DEV__) { + var allowedTypes_1 = Object.values(index_1.Event); + var invalidTypes = events.filter(function (type) { return !allowedTypes_1.includes(type); }); + if (invalidTypes.length) { + console.warn('One or more of the events provided to useTrackPlayerEvents is ' + + ("not a valid TrackPlayer event: " + invalidTypes.join("', '") + ". ") + + 'A list of available events can be found at ' + + 'https://react-native-kit.github.io/react-native-track-player/documentation/#events'); + } + } + var subs = events.map(function (event) { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + return index_1.default.addEventListener(event, function (payload) { return savedHandler.current(__assign(__assign({}, payload), { type: event })); }); + }); + return function () { + subs.forEach(function (sub) { return sub.remove(); }); + }; + }, events); +}; +/** + * Poll for track progress for the given interval (in miliseconds) + * @param interval - ms interval + */ +function useProgress(updateInterval) { + var _this = this; + var _a = react_1.useState({ position: 0, duration: 0, buffered: 0 }), state = _a[0], setState = _a[1]; + var playerState = exports.usePlaybackState(); + var getProgress = function () { return __awaiter(_this, void 0, void 0, function () { + var _a, position, duration, buffered; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: return [4 /*yield*/, Promise.all([ + index_1.default.getPosition(), + index_1.default.getDuration(), + index_1.default.getBufferedPosition(), + ])]; + case 1: + _a = _b.sent(), position = _a[0], duration = _a[1], buffered = _a[2]; + setState({ position: position, duration: duration, buffered: buffered }); + return [2 /*return*/]; + } + }); + }); }; + react_1.useEffect(function () { + if (playerState === index_1.State.Stopped) { + setState({ position: 0, duration: 0, buffered: 0 }); + return; + } + if (playerState !== index_1.State.Playing && playerState !== index_1.State.Buffering) + return; + var poll = setInterval(getProgress, updateInterval || 1000); + return function () { return clearInterval(poll); }; + }, [playerState]); + return state; +} +exports.useProgress = useProgress; diff --git a/lib/index.d.ts b/lib/index.d.ts new file mode 100644 index 000000000..640fd8e84 --- /dev/null +++ b/lib/index.d.ts @@ -0,0 +1,75 @@ +import { MetadataOptions, PlayerOptions, Event, Track, State, TrackMetadataBase, NowPlayingMetadata } from './interfaces'; +declare function setupPlayer(options?: PlayerOptions): Promise; +declare function isServiceRunning(): any; +declare function destroy(): any; +declare type ServiceHandler = () => Promise; +declare function registerPlaybackService(factory: () => ServiceHandler): void; +declare function addEventListener(event: Event, listener: (data: any) => void): import("react-native").EmitterSubscription; +declare function setAlarm(seconds: Number): Promise; +declare function cancelAlarm(): Promise; +declare function add(tracks: Track | Track[], insertBeforeId?: string): Promise; +declare function remove(tracks: string | string[]): Promise; +declare function removeUpcomingTracks(): Promise; +declare function skip(trackId: string): Promise; +declare function skipToNext(): Promise; +declare function skipToPrevious(): Promise; +declare function updateOptions(options?: MetadataOptions): Promise; +declare function updateMetadataForTrack(trackId: string, metadata: TrackMetadataBase): Promise; +declare function clearNowPlayingMetadata(): Promise; +declare function updateNowPlayingMetadata(metadata: NowPlayingMetadata): Promise; +declare function reset(): Promise; +declare function play(): Promise; +declare function pause(): Promise; +declare function pauseForDucking(): Promise; +declare function stop(): Promise; +declare function seekTo(position: number): Promise; +declare function setVolume(level: number): Promise; +declare function setRate(rate: number): Promise; +declare function getVolume(): Promise; +declare function getRate(): Promise; +declare function getTrack(trackId: string): Promise; +declare function getQueue(): Promise; +declare function getCurrentTrack(): Promise; +declare function getDuration(): Promise; +declare function getBufferedPosition(): Promise; +declare function getPosition(): Promise; +declare function getState(): Promise; +export * from './hooks'; +export * from './interfaces'; +declare const _default: { + setupPlayer: typeof setupPlayer; + isServiceRunning: typeof isServiceRunning; + destroy: typeof destroy; + registerPlaybackService: typeof registerPlaybackService; + addEventListener: typeof addEventListener; + setAlarm: typeof setAlarm; + cancelAlarm: typeof cancelAlarm; + add: typeof add; + remove: typeof remove; + removeUpcomingTracks: typeof removeUpcomingTracks; + skip: typeof skip; + skipToNext: typeof skipToNext; + skipToPrevious: typeof skipToPrevious; + updateOptions: typeof updateOptions; + updateMetadataForTrack: typeof updateMetadataForTrack; + clearNowPlayingMetadata: typeof clearNowPlayingMetadata; + updateNowPlayingMetadata: typeof updateNowPlayingMetadata; + reset: typeof reset; + play: typeof play; + pause: typeof pause; + pauseForDucking: typeof pauseForDucking; + stop: typeof stop; + seekTo: typeof seekTo; + setVolume: typeof setVolume; + setRate: typeof setRate; + getVolume: typeof getVolume; + getRate: typeof getRate; + getTrack: typeof getTrack; + getQueue: typeof getQueue; + getCurrentTrack: typeof getCurrentTrack; + getDuration: typeof getDuration; + getBufferedPosition: typeof getBufferedPosition; + getPosition: typeof getPosition; + getState: typeof getState; +}; +export default _default; diff --git a/lib/index.js b/lib/index.js new file mode 100644 index 000000000..9f3a80d90 --- /dev/null +++ b/lib/index.js @@ -0,0 +1,381 @@ +"use strict"; +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p); +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __spreadArrays = (this && this.__spreadArrays) || function () { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; + for (var r = Array(s), k = 0, i = 0; i < il; i++) + for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) + r[k] = a[j]; + return r; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var react_native_1 = require("react-native"); +// @ts-ignore +var resolveAssetSource = require("react-native/Libraries/Image/resolveAssetSource"); +var TrackPlayer = react_native_1.NativeModules.TrackPlayerModule; +var emitter = react_native_1.Platform.OS !== 'android' ? new react_native_1.NativeEventEmitter(TrackPlayer) : react_native_1.DeviceEventEmitter; +// MARK: - Helpers +function resolveImportedPath(path) { + if (!path) + return undefined; + return resolveAssetSource(path) || path; +} +// MARK: - General API +function setupPlayer(options) { + if (options === void 0) { options = {}; } + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.setupPlayer(options || {})]; + }); + }); +} +function isServiceRunning() { + return TrackPlayer.isServiceRunning(); +} +function destroy() { + return TrackPlayer.destroy(); +} +function registerPlaybackService(factory) { + if (react_native_1.Platform.OS === 'android') { + // Registers the headless task + react_native_1.AppRegistry.registerHeadlessTask('TrackPlayer', factory); + } + else { + // Initializes and runs the service in the next tick + setImmediate(factory()); + } +} +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function addEventListener(event, listener) { + return emitter.addListener(event, listener); +} +function setAlarm(seconds) { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, react_native_1.Platform.OS === 'android' ? TrackPlayer.setAlarm(seconds) : Promise.resolve()]; + }); + }); +} +function cancelAlarm() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, react_native_1.Platform.OS === 'android' ? TrackPlayer.cancelAlarm() : Promise.resolve()]; + }); + }); +} +// MARK: - Queue API +function add(tracks, insertBeforeId) { + return __awaiter(this, void 0, void 0, function () { + var i; + return __generator(this, function (_a) { + // Clone the array before modifying it + if (Array.isArray(tracks)) { + tracks = __spreadArrays(tracks); + } + else { + tracks = [tracks]; + } + if (tracks.length < 1) + return [2 /*return*/]; + for (i = 0; i < tracks.length; i++) { + // Clone the object before modifying it + tracks[i] = __assign({}, tracks[i]); + // Resolve the URLs + tracks[i].url = resolveImportedPath(tracks[i].url); + tracks[i].artwork = resolveImportedPath(tracks[i].artwork); + // Cast ID's into strings + tracks[i].id = "" + tracks[i].id; + } + return [2 /*return*/, TrackPlayer.add(tracks, insertBeforeId)]; + }); + }); +} +function remove(tracks) { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + if (!Array.isArray(tracks)) { + tracks = [tracks]; + } + return [2 /*return*/, TrackPlayer.remove(tracks)]; + }); + }); +} +function removeUpcomingTracks() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.removeUpcomingTracks()]; + }); + }); +} +function skip(trackId) { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.skip(trackId)]; + }); + }); +} +function skipToNext() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.skipToNext()]; + }); + }); +} +function skipToPrevious() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.skipToPrevious()]; + }); + }); +} +// MARK: - Control Center / Notifications API +function updateOptions(options) { + if (options === void 0) { options = {}; } + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + options = __assign({}, options); + // Resolve the asset for each icon + options.icon = resolveImportedPath(options.icon); + options.playIcon = resolveImportedPath(options.playIcon); + options.pauseIcon = resolveImportedPath(options.pauseIcon); + options.stopIcon = resolveImportedPath(options.stopIcon); + options.previousIcon = resolveImportedPath(options.previousIcon); + options.nextIcon = resolveImportedPath(options.nextIcon); + options.rewindIcon = resolveImportedPath(options.rewindIcon); + options.forwardIcon = resolveImportedPath(options.forwardIcon); + return [2 /*return*/, TrackPlayer.updateOptions(options)]; + }); + }); +} +function updateMetadataForTrack(trackId, metadata) { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.updateMetadataForTrack(trackId, metadata)]; + }); + }); +} +function clearNowPlayingMetadata() { + return TrackPlayer.clearNowPlayingMetadata(); +} +function updateNowPlayingMetadata(metadata) { + return TrackPlayer.updateNowPlayingMetadata(metadata); +} +// MARK: - Playback API +function reset() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.reset()]; + }); + }); +} +function play() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.play()]; + }); + }); +} +function pause() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.pause()]; + }); + }); +} +function pauseForDucking() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, react_native_1.Platform.OS === 'android' ? TrackPlayer.pauseForDucking() : TrackPlayer.pause()]; + }); + }); +} +function stop() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.stop()]; + }); + }); +} +function seekTo(position) { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.seekTo(position)]; + }); + }); +} +function setVolume(level) { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.setVolume(level)]; + }); + }); +} +function setRate(rate) { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.setRate(rate)]; + }); + }); +} +// MARK: - Getters +function getVolume() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.getVolume()]; + }); + }); +} +function getRate() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.getRate()]; + }); + }); +} +function getTrack(trackId) { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.getTrack(trackId)]; + }); + }); +} +function getQueue() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.getQueue()]; + }); + }); +} +function getCurrentTrack() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.getCurrentTrack()]; + }); + }); +} +function getDuration() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.getDuration()]; + }); + }); +} +function getBufferedPosition() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.getBufferedPosition()]; + }); + }); +} +function getPosition() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.getPosition()]; + }); + }); +} +function getState() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + return [2 /*return*/, TrackPlayer.getState()]; + }); + }); +} +__exportStar(require("./hooks"), exports); +__exportStar(require("./interfaces"), exports); +exports.default = { + // MARK: - General API + setupPlayer: setupPlayer, + isServiceRunning: isServiceRunning, + destroy: destroy, + registerPlaybackService: registerPlaybackService, + addEventListener: addEventListener, + setAlarm: setAlarm, + cancelAlarm: cancelAlarm, + // MARK: - Queue API + add: add, + remove: remove, + removeUpcomingTracks: removeUpcomingTracks, + skip: skip, + skipToNext: skipToNext, + skipToPrevious: skipToPrevious, + // MARK: - Control Center / Notifications API + updateOptions: updateOptions, + updateMetadataForTrack: updateMetadataForTrack, + clearNowPlayingMetadata: clearNowPlayingMetadata, + updateNowPlayingMetadata: updateNowPlayingMetadata, + // MARK: - Playback API + reset: reset, + play: play, + pause: pause, + pauseForDucking: pauseForDucking, + stop: stop, + seekTo: seekTo, + setVolume: setVolume, + setRate: setRate, + // MARK: - Getters + getVolume: getVolume, + getRate: getRate, + getTrack: getTrack, + getQueue: getQueue, + getCurrentTrack: getCurrentTrack, + getDuration: getDuration, + getBufferedPosition: getBufferedPosition, + getPosition: getPosition, + getState: getState, +}; diff --git a/lib/interfaces.d.ts b/lib/interfaces.d.ts new file mode 100644 index 000000000..2419875d9 --- /dev/null +++ b/lib/interfaces.d.ts @@ -0,0 +1,165 @@ +export declare enum IOSCategory { + Playback = "playback", + PlayAndRecord = "playAndRecord", + MultiRoute = "multiRoute", + Ambient = "ambient", + SoloAmbient = "soloAmbient", + Record = "record" +} +export declare enum IOSCategoryMode { + Default = "default", + GameChat = "gameChat", + Measurement = "measurement", + MoviePlayback = "moviePlayback", + SpokenAudio = "spokenAudio", + VideoChat = "videoChat", + VideoRecording = "videoRecording", + VoiceChat = "voiceChat", + VoicePrompt = "voicePrompt" +} +export declare enum IOSCategoryOptions { + MixWithOthers = "mixWithOthers", + DuckOthers = "duckOthers", + InterruptSpokenAudioAndMixWithOthers = "interruptSpokenAudioAndMixWithOthers", + AllowBluetooth = "allowBluetooth", + AllowBluetoothA2DP = "allowBluetoothA2DP", + AllowAirPlay = "allowAirPlay", + DefaultToSpeaker = "defaultToSpeaker" +} +export interface PlayerOptions { + minBuffer?: number; + maxBuffer?: number; + playBuffer?: number; + maxCacheSize?: number; + iosCategory?: IOSCategory; + iosCategoryMode?: IOSCategoryMode; + iosCategoryOptions?: IOSCategoryOptions[]; + /** + * Indicates whether the player should automatically delay playback in order to minimize stalling. + * Defaults to `false`. + */ + waitForBuffer?: boolean; + /** + * Indicates whether the player should automatically update now playing metadata data in control center / notification. + * Defaults to `true`. + */ + autoUpdateMetadata?: boolean; +} +export declare enum RatingType { + Heart, + ThumbsUpDown, + ThreeStars, + FourStars, + FiveStars, + Percentage +} +export interface FeedbackOptions { + /** Marks wether the option should be marked as active or "done" */ + isActive: boolean; + /** The title to give the action (relevant for iOS) */ + title: string; +} +export declare enum Capability { + Play, + PlayFromId, + PlayFromSearch, + Pause, + TogglePlayPause, + Stop, + SeekTo, + Skip, + SkipToNext, + SkipToPrevious, + JumpForward, + JumpBackward, + SetRating, + Like, + Dislike, + Bookmark +} +export declare type ResourceObject = number; +export interface MetadataOptions { + ratingType?: RatingType; + jumpInterval?: number; + likeOptions?: FeedbackOptions; + dislikeOptions?: FeedbackOptions; + bookmarkOptions?: FeedbackOptions; + stopWithApp?: boolean; + capabilities?: Capability[]; + notificationCapabilities?: Capability[]; + compactCapabilities?: Capability[]; + icon?: ResourceObject; + playIcon?: ResourceObject; + pauseIcon?: ResourceObject; + stopIcon?: ResourceObject; + previousIcon?: ResourceObject; + nextIcon?: ResourceObject; + rewindIcon?: ResourceObject; + forwardIcon?: ResourceObject; + color?: number; +} +export declare enum Event { + PlaybackState = "playback-state", + PlaybackError = "playback-error", + PlaybackQueueEnded = "playback-queue-ended", + PlaybackTrackChanged = "playback-track-changed", + RemotePlay = "remote-play", + RemotePlayId = "remote-play-id", + RemotePlaySearch = "remote-play-search", + 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 declare enum TrackType { + Default = "default", + Dash = "dash", + HLS = "hls", + SmoothStreaming = "smoothstreaming" +} +export declare enum PitchAlgorithm { + Linear, + Music, + Voice +} +export declare enum State { + None, + Ready, + Playing, + Paused, + Stopped, + Buffering, + Connecting +} +export interface TrackMetadataBase { + title?: string; + album?: string; + artist?: string; + duration?: number; + artwork?: string | ResourceObject; + description?: string; + genre?: string; + date?: string; + rating?: number | boolean; +} +export interface NowPlayingMetadata extends TrackMetadataBase { + elapsedTime?: number; +} +export interface Track extends TrackMetadataBase { + id: string; + url: string | ResourceObject; + type?: TrackType; + userAgent?: string; + contentType?: string; + pitchAlgorithm?: PitchAlgorithm; + [key: string]: any; +} diff --git a/lib/interfaces.js b/lib/interfaces.js new file mode 100644 index 000000000..65b278d52 --- /dev/null +++ b/lib/interfaces.js @@ -0,0 +1,110 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.State = exports.PitchAlgorithm = exports.TrackType = exports.Event = exports.Capability = exports.RatingType = exports.IOSCategoryOptions = exports.IOSCategoryMode = exports.IOSCategory = void 0; +var react_native_1 = require("react-native"); +var TrackPlayer = react_native_1.NativeModules.TrackPlayerModule; +var IOSCategory; +(function (IOSCategory) { + IOSCategory["Playback"] = "playback"; + IOSCategory["PlayAndRecord"] = "playAndRecord"; + IOSCategory["MultiRoute"] = "multiRoute"; + IOSCategory["Ambient"] = "ambient"; + IOSCategory["SoloAmbient"] = "soloAmbient"; + IOSCategory["Record"] = "record"; +})(IOSCategory = exports.IOSCategory || (exports.IOSCategory = {})); +var IOSCategoryMode; +(function (IOSCategoryMode) { + IOSCategoryMode["Default"] = "default"; + IOSCategoryMode["GameChat"] = "gameChat"; + IOSCategoryMode["Measurement"] = "measurement"; + IOSCategoryMode["MoviePlayback"] = "moviePlayback"; + IOSCategoryMode["SpokenAudio"] = "spokenAudio"; + IOSCategoryMode["VideoChat"] = "videoChat"; + IOSCategoryMode["VideoRecording"] = "videoRecording"; + IOSCategoryMode["VoiceChat"] = "voiceChat"; + IOSCategoryMode["VoicePrompt"] = "voicePrompt"; +})(IOSCategoryMode = exports.IOSCategoryMode || (exports.IOSCategoryMode = {})); +var IOSCategoryOptions; +(function (IOSCategoryOptions) { + IOSCategoryOptions["MixWithOthers"] = "mixWithOthers"; + IOSCategoryOptions["DuckOthers"] = "duckOthers"; + IOSCategoryOptions["InterruptSpokenAudioAndMixWithOthers"] = "interruptSpokenAudioAndMixWithOthers"; + IOSCategoryOptions["AllowBluetooth"] = "allowBluetooth"; + IOSCategoryOptions["AllowBluetoothA2DP"] = "allowBluetoothA2DP"; + IOSCategoryOptions["AllowAirPlay"] = "allowAirPlay"; + IOSCategoryOptions["DefaultToSpeaker"] = "defaultToSpeaker"; +})(IOSCategoryOptions = exports.IOSCategoryOptions || (exports.IOSCategoryOptions = {})); +var RatingType; +(function (RatingType) { + RatingType[RatingType["Heart"] = TrackPlayer.RATING_HEART] = "Heart"; + RatingType[RatingType["ThumbsUpDown"] = TrackPlayer.RATING_THUMBS_UP_DOWN] = "ThumbsUpDown"; + RatingType[RatingType["ThreeStars"] = TrackPlayer.RATING_3_STARS] = "ThreeStars"; + RatingType[RatingType["FourStars"] = TrackPlayer.RATING_4_STARS] = "FourStars"; + RatingType[RatingType["FiveStars"] = TrackPlayer.RATING_5_STARS] = "FiveStars"; + RatingType[RatingType["Percentage"] = TrackPlayer.RATING_PERCENTAGE] = "Percentage"; +})(RatingType = exports.RatingType || (exports.RatingType = {})); +var Capability; +(function (Capability) { + Capability[Capability["Play"] = TrackPlayer.CAPABILITY_PLAY] = "Play"; + Capability[Capability["PlayFromId"] = TrackPlayer.CAPABILITY_PLAY_FROM_ID] = "PlayFromId"; + Capability[Capability["PlayFromSearch"] = TrackPlayer.CAPABILITY_PLAY_FROM_SEARCH] = "PlayFromSearch"; + Capability[Capability["Pause"] = TrackPlayer.CAPABILITY_PAUSE] = "Pause"; + Capability[Capability["TogglePlayPause"] = TrackPlayer.CAPABILITY_TOGGLE_PLAY_PAUSE] = "TogglePlayPause"; + Capability[Capability["Stop"] = TrackPlayer.CAPABILITY_STOP] = "Stop"; + Capability[Capability["SeekTo"] = TrackPlayer.CAPABILITY_SEEK_TO] = "SeekTo"; + Capability[Capability["Skip"] = TrackPlayer.CAPABILITY_SKIP] = "Skip"; + Capability[Capability["SkipToNext"] = TrackPlayer.CAPABILITY_SKIP_TO_NEXT] = "SkipToNext"; + Capability[Capability["SkipToPrevious"] = TrackPlayer.CAPABILITY_SKIP_TO_PREVIOUS] = "SkipToPrevious"; + Capability[Capability["JumpForward"] = TrackPlayer.CAPABILITY_JUMP_FORWARD] = "JumpForward"; + Capability[Capability["JumpBackward"] = TrackPlayer.CAPABILITY_JUMP_BACKWARD] = "JumpBackward"; + Capability[Capability["SetRating"] = TrackPlayer.CAPABILITY_SET_RATING] = "SetRating"; + Capability[Capability["Like"] = TrackPlayer.CAPABILITY_LIKE] = "Like"; + Capability[Capability["Dislike"] = TrackPlayer.CAPABILITY_DISLIKE] = "Dislike"; + Capability[Capability["Bookmark"] = TrackPlayer.CAPABILITY_BOOKMARK] = "Bookmark"; +})(Capability = exports.Capability || (exports.Capability = {})); +var Event; +(function (Event) { + Event["PlaybackState"] = "playback-state"; + Event["PlaybackError"] = "playback-error"; + Event["PlaybackQueueEnded"] = "playback-queue-ended"; + Event["PlaybackTrackChanged"] = "playback-track-changed"; + Event["RemotePlay"] = "remote-play"; + Event["RemotePlayId"] = "remote-play-id"; + Event["RemotePlaySearch"] = "remote-play-search"; + Event["RemotePause"] = "remote-pause"; + Event["RemoteStop"] = "remote-stop"; + Event["RemoteSkip"] = "remote-skip"; + Event["RemoteNext"] = "remote-next"; + Event["RemotePrevious"] = "remote-previous"; + Event["RemoteJumpForward"] = "remote-jump-forward"; + Event["RemoteJumpBackward"] = "remote-jump-backward"; + Event["RemoteSeek"] = "remote-seek"; + Event["RemoteSetRating"] = "remote-set-rating"; + Event["RemoteDuck"] = "remote-duck"; + Event["RemoteLike"] = "remote-like"; + Event["RemoteDislike"] = "remote-dislike"; + Event["RemoteBookmark"] = "remote-bookmark"; +})(Event = exports.Event || (exports.Event = {})); +var TrackType; +(function (TrackType) { + TrackType["Default"] = "default"; + TrackType["Dash"] = "dash"; + TrackType["HLS"] = "hls"; + TrackType["SmoothStreaming"] = "smoothstreaming"; +})(TrackType = exports.TrackType || (exports.TrackType = {})); +var PitchAlgorithm; +(function (PitchAlgorithm) { + PitchAlgorithm[PitchAlgorithm["Linear"] = TrackPlayer.PITCH_ALGORITHM_LINEAR] = "Linear"; + PitchAlgorithm[PitchAlgorithm["Music"] = TrackPlayer.PITCH_ALGORITHM_MUSIC] = "Music"; + PitchAlgorithm[PitchAlgorithm["Voice"] = TrackPlayer.PITCH_ALGORITHM_VOICE] = "Voice"; +})(PitchAlgorithm = exports.PitchAlgorithm || (exports.PitchAlgorithm = {})); +var State; +(function (State) { + State[State["None"] = TrackPlayer.STATE_NONE] = "None"; + State[State["Ready"] = TrackPlayer.STATE_READY] = "Ready"; + State[State["Playing"] = TrackPlayer.STATE_PLAYING] = "Playing"; + State[State["Paused"] = TrackPlayer.STATE_PAUSED] = "Paused"; + State[State["Stopped"] = TrackPlayer.STATE_STOPPED] = "Stopped"; + State[State["Buffering"] = TrackPlayer.STATE_BUFFERING] = "Buffering"; + State[State["Connecting"] = TrackPlayer.STATE_CONNECTING] = "Connecting"; +})(State = exports.State || (exports.State = {}));