@javascriptcommon/react-native-track-player 4.1.7 → 4.1.9

package/android/src/main/java/com/doublesymmetry/trackplayer/module/MusicModule.kt

@@ -15,6 +15,7 @@ import com.doublesymmetry.trackplayer.model.Track
 import com.doublesymmetry.trackplayer.module.MusicEvents.Companion.EVENT_INTENT
 import com.doublesymmetry.trackplayer.service.MusicService
 import com.doublesymmetry.trackplayer.utils.AppForegroundTracker
+import com.doublesymmetry.trackplayer.utils.AutoConnectionDetector
 import com.doublesymmetry.trackplayer.utils.RejectionException
 import com.doublesymmetry.trackplayer.NativeTrackPlayerSpec
 import com.facebook.react.bridge.*
@@ -64,6 +65,7 @@ class MusicModule(reactContext: ReactApplicationContext) : NativeTrackPlayerSpec
 
     override fun initialize() {
         AppForegroundTracker.start()
+        AutoConnectionDetector(context).registerCarConnectionReceiver()
     }
 
     override fun onServiceConnected(name: ComponentName, service: IBinder) {

package/android/src/main/java/com/doublesymmetry/trackplayer/service/MusicService.kt

@@ -951,30 +951,33 @@ class MusicService : HeadlessJsMediaService() {
 
     @SuppressLint("VisibleForTests")
     private fun selfWake(clientPackageName: String): Boolean {
-        val reactActivity = reactContext?.currentActivity
-        if (
-        // HACK: validate reactActivity is present; if not, send wake intent
-            (reactActivity == null || reactActivity.isDestroyed)
-            && Settings.canDrawOverlays(this)
-        ) {
-            val currentTime = System.currentTimeMillis()
-            if (currentTime - lastWake < 100000) {
-                return false
-            }
-            lastWake = currentTime
-            val activityIntent = packageManager.getLaunchIntentForPackage(packageName)
-            activityIntent!!.data = "trackplayer://service-bound".toUri()
-            activityIntent.action = Intent.ACTION_VIEW
-            activityIntent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
-            var activityOptions = ActivityOptions.makeBasic()
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-                activityOptions = activityOptions.setPendingIntentBackgroundActivityStartMode(
-                    ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED)
-            }
-            this.startActivity(activityIntent, activityOptions.toBundle())
-            return true
-        }
+        // FORK PATCH: AVOID STARTING APP IN FOREGROUND, PREFER STARTING HEADLESS
         return false
+
+//        val reactActivity = reactContext?.currentActivity
+//        if (
+//        // HACK: validate reactActivity is present; if not, send wake intent
+//            (reactActivity == null || reactActivity.isDestroyed)
+//            && Settings.canDrawOverlays(this)
+//        ) {
+//            val currentTime = System.currentTimeMillis()
+//            if (currentTime - lastWake < 100000) {
+//                return false
+//            }
+//            lastWake = currentTime
+//            val activityIntent = packageManager.getLaunchIntentForPackage(packageName)
+//            activityIntent!!.data = "trackplayer://service-bound".toUri()
+//            activityIntent.action = Intent.ACTION_VIEW
+//            activityIntent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
+//            var activityOptions = ActivityOptions.makeBasic()
+//            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+//                activityOptions = activityOptions.setPendingIntentBackgroundActivityStartMode(
+//                    ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED)
+//            }
+//            this.startActivity(activityIntent, activityOptions.toBundle())
+//            return true
+//        }
+//        return false
     }
 
     override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaLibrarySession {
@@ -1006,6 +1009,7 @@ class MusicService : HeadlessJsMediaService() {
             player.destroy()
         }
 
+        // FORK PATCH
         // -> Attempt to fix https://github.com/doublesymmetry/react-native-track-player/issues/2485
         mediaSession.release()
         
@@ -1086,15 +1090,17 @@ class MusicService : HeadlessJsMediaService() {
         private val rootItem = buildMediaItem(title = "root", mediaId = AA_ROOT_KEY, isPlayable = false)
         private val forYouItem = buildMediaItem(title = "For You", mediaId = AA_FOR_YOU_KEY, isPlayable = false)
 
-        override fun onDisconnected(
-            session: MediaSession,
-            controller: MediaSession.ControllerInfo
-        ) {
-            emit(MusicEvents.CONNECTOR_DISCONNECTED, Bundle().apply {
-                putString("package", controller.packageName)
-            })
-            super.onDisconnected(session, controller)
-        }
+        // FORK PATCH: onDisconnected it's called only a long time after Android Auto disconnection, replaced with AutoConnectionDetector
+//        override fun onDisconnected(
+//            session: MediaSession,
+//            controller: MediaSession.ControllerInfo
+//        ) {
+//
+//            emit(MusicEvents.CONNECTOR_DISCONNECTED, Bundle().apply {
+//                putString("package", controller.packageName)
+//            })
+//            super.onDisconnected(session, controller)
+//        }
         // Configure commands available to the controller in onConnect()
         @OptIn(UnstableApi::class)
         override fun onConnect(

package/android/src/main/java/com/doublesymmetry/trackplayer/utils/AutoConnectionDetector.kt

@@ -0,0 +1,97 @@
+package com.doublesymmetry.trackplayer.utils
+
+import android.os.Handler
+import android.os.Looper
+import androidx.car.app.connection.CarConnection
+import androidx.lifecycle.LifecycleOwner
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.doublesymmetry.trackplayer.module.MusicEvents
+
+class AutoConnectionDetector(
+    val context: ReactContext,
+    onConnectionChange: ((Boolean) -> Unit)? = null
+) {
+
+    companion object {
+        const val TAG = "AutoConnectionDetector"
+    }
+
+    var isCarConnected = false
+    private var carConnection: CarConnection? = null
+    private val onConnectionChangeCallback = onConnectionChange
+    private var isObserving = false
+
+    fun registerCarConnectionReceiver() {
+        if (carConnection == null) {
+            carConnection = CarConnection(context)
+        }
+
+        val mainHandler = Handler(Looper.getMainLooper())
+        mainHandler.post {
+            val lifecycleOwner = context.currentActivity as? LifecycleOwner
+            if (lifecycleOwner != null && !isObserving) {
+                try {
+                    carConnection?.type?.observe(lifecycleOwner, ::onConnectionStateUpdated)
+                    isObserving = true
+                } catch (_: Throwable) {}
+            }
+        }
+    }
+
+    private fun onConnectionStateUpdated(connectionState: Int) {
+        when (connectionState) {
+            CarConnection.CONNECTION_TYPE_NOT_CONNECTED -> {
+                if (isCarConnected) {
+                    notifyCarDisconnected()
+                }
+            }
+            CarConnection.CONNECTION_TYPE_NATIVE -> {
+                notifyCarConnected(connectionState)
+            }
+            CarConnection.CONNECTION_TYPE_PROJECTION -> {
+                notifyCarConnected(connectionState)
+            }
+        }
+    }
+
+    private fun emitConnectorEvent(eventName: String, connectionState: Int?) {
+        val params = Arguments.createMap()
+        params.putString("package", "com.google.android.projection.gearhead") // Android Auto package name
+        params.putBoolean(
+            "isAutomotiveController",
+            connectionState == CarConnection.CONNECTION_TYPE_NATIVE // Android Automotive
+        )
+        params.putBoolean(
+            "isAutoCompanionController",
+            connectionState == CarConnection.CONNECTION_TYPE_PROJECTION // Android Auto
+        )
+        params.putBoolean("isMediaNotificationController", false)
+
+        context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            ?.emit(eventName, params)
+    }
+
+    private fun notifyCarConnected(connectionState: Int) {
+        if (isCarConnected) return
+        isCarConnected = true
+
+        // emitConnectionUpdate(params) // old
+        // emitConnectorEvent(MusicEvents.CONNECTOR_CONNECTED, connectionState) // new but not necessary (MusicService event works)
+
+        onConnectionChangeCallback?.invoke(true)
+    }
+
+    private fun notifyCarDisconnected() {
+        if (!isCarConnected) return
+        isCarConnected = false
+
+        // emitConnectionUpdate(params) // old
+
+        // MusicService event doesn't work -> emit manually
+        emitConnectorEvent(MusicEvents.CONNECTOR_DISCONNECTED, CarConnection.CONNECTION_TYPE_NOT_CONNECTED)
+
+        onConnectionChangeCallback?.invoke(false)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@javascriptcommon/react-native-track-player",
-  "version": "4.1.7",
+  "version": "4.1.9",
   "description": "A fully fledged audio module created for music apps",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",
@@ -31,7 +31,6 @@
     "android/src/**/*",
     "android/build.gradle",
     "android/proguard-rules.txt",
-    "web/**/*",
     "*.podspec",
     "specs"
   ],

package/lib/src/TrackPlayerModule.web.d.ts

@@ -1,2 +0,0 @@
-import TrackPlayerModule from '../web';
-export default TrackPlayerModule;

package/lib/src/TrackPlayerModule.web.js

@@ -1,2 +0,0 @@
-import TrackPlayerModule from '../web';
-export default TrackPlayerModule;

package/lib/src/resolveAssetSource.web.d.ts

@@ -1,2 +0,0 @@
-declare const resolveAssetResource: (base64: unknown) => unknown;
-export default resolveAssetResource;

package/lib/src/resolveAssetSource.web.js

@@ -1,8 +0,0 @@
-const resolveAssetResource = (base64) => {
-    if (/^https?:\/\//.test(base64)) {
-        return base64;
-    }
-    // TODO: resolveAssetResource for web
-    return base64;
-};
-export default resolveAssetResource;

package/lib/web/TrackPlayer/Player.d.ts

@@ -1,40 +0,0 @@
-import { State } from '../../src/constants/State';
-import type { Track, Progress, PlaybackState } from '../../src/interfaces';
-export declare class Player {
-    protected hasInitialized: boolean;
-    protected element?: HTMLMediaElement;
-    protected player?: shaka.Player;
-    protected _current?: Track;
-    protected _playWhenReady: boolean;
-    protected _state: PlaybackState;
-    get current(): Track | undefined;
-    set current(cur: Track | undefined);
-    get state(): PlaybackState;
-    set state(newState: PlaybackState);
-    get playWhenReady(): boolean;
-    set playWhenReady(pwr: boolean);
-    setupPlayer(): Promise<void>;
-    /**
-     * event handlers
-     */
-    protected onStateUpdate(state: Exclude<State, State.Error>): void;
-    protected onError(error: any): void;
-    /**
-     * player control
-     */
-    load(track: Track): Promise<void>;
-    retry(): Promise<void>;
-    stop(): Promise<void>;
-    play(): Promise<void>;
-    pause(): void;
-    setRate(rate: number): number;
-    getRate(): number;
-    seekBy(offset: number): void;
-    seekTo(seconds: number): void;
-    setVolume(volume: number): void;
-    getVolume(): number;
-    getDuration(): number;
-    getPosition(): number;
-    getProgress(): Progress;
-    getBufferedPosition(): (index: number) => number;
-}

package/lib/web/TrackPlayer/Player.js

@@ -1,188 +0,0 @@
-import { State } from '../../src/constants/State';
-import { SetupNotCalledError } from './SetupNotCalledError';
-export class Player {
-    hasInitialized = false;
-    element;
-    player;
-    _current = undefined;
-    _playWhenReady = false;
-    _state = { state: State.None };
-    // current getter/setter
-    get current() {
-        return this._current;
-    }
-    set current(cur) {
-        this._current = cur;
-    }
-    // state getter/setter
-    get state() {
-        return this._state;
-    }
-    set state(newState) {
-        this._state = newState;
-    }
-    // playWhenReady getter/setter
-    get playWhenReady() {
-        return this._playWhenReady;
-    }
-    set playWhenReady(pwr) {
-        this._playWhenReady = pwr;
-    }
-    async setupPlayer() {
-        // shaka only runs in a browser
-        if (typeof window === 'undefined')
-            return;
-        if (this.hasInitialized === true) {
-            // TODO: double check the structure of this error message
-            throw { code: 'player_already_initialized', message: 'The player has already been initialized via setupPlayer.' };
-        }
-        // @ts-ignore
-        const shaka = (await import('shaka-player/dist/shaka-player.ui')).default;
-        // Install built-in polyfills to patch browser incompatibilities.
-        shaka.polyfill.installAll();
-        // Check to see if the browser supports the basic APIs Shaka needs.
-        if (!shaka.Player.isBrowserSupported()) {
-            // This browser does not have the minimum set of APIs we need.
-            this.state = {
-                state: State.Error,
-                error: {
-                    code: 'not_supported',
-                    message: 'Browser not supported.',
-                },
-            };
-            throw new Error('Browser not supported.');
-        }
-        // build dom element and attach shaka-player
-        this.element = document.createElement('audio');
-        this.element.setAttribute('id', 'react-native-track-player');
-        this.player = new shaka.Player();
-        this.player?.attach(this.element);
-        // Listen for relevant events events.
-        this.player.addEventListener('error', (error) => {
-            // Extract the shaka.util.Error object from the event.
-            this.onError(error.detail);
-        });
-        this.element.addEventListener('ended', this.onStateUpdate.bind(this, State.Ended));
-        this.element.addEventListener('playing', this.onStateUpdate.bind(this, State.Playing));
-        this.element.addEventListener('pause', this.onStateUpdate.bind(this, State.Paused));
-        this.player.addEventListener('loading', this.onStateUpdate.bind(this, State.Loading));
-        this.player.addEventListener('loaded', this.onStateUpdate.bind(this, State.Ready));
-        this.player.addEventListener('buffering', ({ buffering }) => {
-            if (buffering === true) {
-                this.onStateUpdate(State.Buffering);
-            }
-        });
-        // Attach player to the window to make it easy to access in the JS console.
-        // @ts-ignore
-        window.rntp = this.player;
-        this.hasInitialized = true;
-    }
-    /**
-     * event handlers
-     */
-    onStateUpdate(state) {
-        this.state = { state };
-    }
-    onError(error) {
-        // unload the current track to allow for clean playback on other
-        this.player?.unload();
-        this.state = {
-            state: State.Error,
-            error: {
-                code: error.code.toString(),
-                message: error.message,
-            },
-        };
-        // Log the error.
-        console.debug('Error code', error.code, 'object', error);
-    }
-    /**
-     * player control
-     */
-    async load(track) {
-        if (!this.player)
-            throw new SetupNotCalledError();
-        await this.player.load(track.url);
-        this.current = track;
-    }
-    async retry() {
-        if (!this.player)
-            throw new SetupNotCalledError();
-        this.player.retryStreaming();
-    }
-    async stop() {
-        if (!this.player)
-            throw new SetupNotCalledError();
-        this.current = undefined;
-        await this.player.unload();
-    }
-    play() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        this.playWhenReady = true;
-        return this.element.play()
-            .catch(err => {
-            console.error(err);
-        });
-    }
-    pause() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        this.playWhenReady = false;
-        return this.element.pause();
-    }
-    setRate(rate) {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        return this.element.playbackRate = rate;
-    }
-    getRate() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        return this.element.playbackRate;
-    }
-    seekBy(offset) {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        this.element.currentTime += offset;
-    }
-    seekTo(seconds) {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        this.element.currentTime = seconds;
-    }
-    setVolume(volume) {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        this.element.volume = volume;
-    }
-    getVolume() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        return this.element.volume;
-    }
-    getDuration() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        return this.element.duration;
-    }
-    getPosition() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        return this.element.currentTime;
-    }
-    getProgress() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        return {
-            position: this.element.currentTime,
-            duration: this.element.duration || 0,
-            buffered: 0, // TODO: this.element.buffered.end,
-        };
-    }
-    getBufferedPosition() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        return this.element.buffered.end;
-    }
-}

package/lib/web/TrackPlayer/PlaylistPlayer.d.ts

@@ -1,31 +0,0 @@
-import { Player } from './Player';
-import type { Track } from '../../src/interfaces';
-import { RepeatMode } from './RepeatMode';
-import { State } from '../../src';
-export declare class PlaylistPlayer extends Player {
-    protected playlist: Track[];
-    protected lastIndex?: number;
-    protected _currentIndex?: number;
-    protected repeatMode: RepeatMode;
-    protected onStateUpdate(state: Exclude<State, State.Error>): Promise<void>;
-    protected onTrackEnded(): Promise<void>;
-    protected onPlaylistEnded(): void;
-    protected get currentIndex(): number | undefined;
-    protected set currentIndex(current: number | undefined);
-    protected goToIndex(index: number, initialPosition?: number): Promise<void>;
-    add(tracks: Track[], insertBeforeIndex?: number): Promise<void>;
-    skip(index: number, initialPosition?: number): Promise<void>;
-    skipToNext(initialPosition?: number): Promise<void>;
-    skipToPrevious(initialPosition?: number): Promise<void>;
-    getTrack(index: number): Track | null;
-    setRepeatMode(mode: RepeatMode): void;
-    getRepeatMode(): RepeatMode;
-    remove(indexes: number[]): Promise<void>;
-    stop(): Promise<void>;
-    reset(): Promise<void>;
-    removeUpcomingTracks(): Promise<void>;
-    move(fromIndex: number, toIndex: number): Promise<void>;
-    updateMetadataForTrack(index: number, metadata: Partial<Track>): void;
-    clearNowPlayingMetadata(): void;
-    updateNowPlayingMetadata(metadata: Partial<Track>): void;
-}

package/lib/web/TrackPlayer/PlaylistPlayer.js

@@ -1,181 +0,0 @@
-import { Player } from './Player';
-import { RepeatMode } from './RepeatMode';
-import { State } from '../../src';
-export class PlaylistPlayer extends Player {
-    // TODO: use immer to make the `playlist` immutable
-    playlist = [];
-    lastIndex;
-    _currentIndex;
-    repeatMode = RepeatMode.Off;
-    async onStateUpdate(state) {
-        super.onStateUpdate(state);
-        if (state === State.Ended) {
-            await this.onTrackEnded();
-        }
-    }
-    async onTrackEnded() {
-        switch (this.repeatMode) {
-            case RepeatMode.Track:
-                if (this.currentIndex !== undefined) {
-                    await this.goToIndex(this.currentIndex);
-                }
-                break;
-            case RepeatMode.Playlist:
-                if (this.currentIndex === this.playlist.length - 1) {
-                    await this.goToIndex(0);
-                }
-                else {
-                    await this.skipToNext();
-                }
-                break;
-            default:
-                try {
-                    await this.skipToNext();
-                }
-                catch (err) {
-                    if (err.message !== 'playlist_exhausted') {
-                        throw err;
-                    }
-                    this.onPlaylistEnded();
-                }
-                break;
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    onPlaylistEnded() { }
-    get currentIndex() {
-        return this._currentIndex;
-    }
-    set currentIndex(current) {
-        this.lastIndex = this.currentIndex;
-        this._currentIndex = current;
-    }
-    async goToIndex(index, initialPosition) {
-        const track = this.playlist[index];
-        if (!track) {
-            throw new Error('playlist_exhausted');
-        }
-        if (this.currentIndex !== index) {
-            this.currentIndex = index;
-            await this.load(track);
-        }
-        if (initialPosition) {
-            this.seekTo(initialPosition);
-        }
-        if (this.playWhenReady) {
-            await this.play();
-        }
-    }
-    async add(tracks, insertBeforeIndex) {
-        if (insertBeforeIndex !== -1 && insertBeforeIndex !== undefined) {
-            this.playlist.splice(insertBeforeIndex, 0, ...tracks);
-        }
-        else {
-            this.playlist.push(...tracks);
-        }
-        if (this.currentIndex === undefined) {
-            await this.goToIndex(0);
-        }
-    }
-    async skip(index, initialPosition) {
-        const track = this.playlist[index];
-        if (track === undefined) {
-            throw new Error('index out of bounds');
-        }
-        await this.goToIndex(index, initialPosition);
-    }
-    async skipToNext(initialPosition) {
-        if (this.currentIndex === undefined)
-            return;
-        const index = this.currentIndex + 1;
-        await this.goToIndex(index, initialPosition);
-    }
-    async skipToPrevious(initialPosition) {
-        if (this.currentIndex === undefined)
-            return;
-        const index = this.currentIndex - 1;
-        await this.goToIndex(index, initialPosition);
-    }
-    getTrack(index) {
-        const track = this.playlist[index];
-        return track || null;
-    }
-    setRepeatMode(mode) {
-        this.repeatMode = mode;
-    }
-    getRepeatMode() {
-        return this.repeatMode;
-    }
-    async remove(indexes) {
-        const idxMap = indexes.reduce((acc, elem) => {
-            acc[elem] = true;
-            return acc;
-        }, {});
-        let isCurrentRemoved = false;
-        this.playlist = this.playlist.filter((_track, idx) => {
-            const keep = !idxMap[idx];
-            if (!keep && idx === this.currentIndex) {
-                isCurrentRemoved = true;
-            }
-            return keep;
-        });
-        if (this.currentIndex === undefined) {
-            return;
-        }
-        const hasItems = this.playlist.length > 0;
-        if (isCurrentRemoved && hasItems) {
-            await this.goToIndex(this.currentIndex % this.playlist.length);
-        }
-        else if (isCurrentRemoved) {
-            await this.stop();
-        }
-    }
-    async stop() {
-        await super.stop();
-        this.currentIndex = undefined;
-    }
-    async reset() {
-        await this.stop();
-        this.playlist = [];
-    }
-    async removeUpcomingTracks() {
-        if (this.currentIndex === undefined)
-            return;
-        this.playlist = this.playlist.slice(0, this.currentIndex + 1);
-    }
-    async move(fromIndex, toIndex) {
-        if (!this.playlist[fromIndex]) {
-            throw new Error('index out of bounds');
-        }
-        if (this.currentIndex === fromIndex) {
-            throw new Error('you cannot move the currently playing track');
-        }
-        if (this.currentIndex === toIndex) {
-            throw new Error('you cannot replace the currently playing track');
-        }
-        // calculate `currentIndex` after move
-        let shift = undefined;
-        if (this.currentIndex) {
-            if (fromIndex < this.currentIndex && toIndex > this.currentIndex) {
-                shift = -1;
-            }
-            else if (fromIndex > this.currentIndex && toIndex < this.currentIndex) {
-                shift = +1;
-            }
-        }
-        // move the track
-        const fromItem = this.playlist[fromIndex];
-        this.playlist.splice(fromIndex, 1);
-        this.playlist.splice(toIndex, 0, fromItem);
-        if (this.currentIndex && shift) {
-            this.currentIndex = this.currentIndex + shift;
-        }
-    }
-    // TODO
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    updateMetadataForTrack(index, metadata) { }
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    clearNowPlayingMetadata() { }
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    updateNowPlayingMetadata(metadata) { }
-}