react-native-nitro-player 1.6.0-alpha.1 → 1.7.0-alpha.0

package/lib/hooks/useAndroidAutoConnection.js

@@ -1,5 +1,6 @@
 import { useEffect, useState } from 'react';
 import { TrackPlayer } from '../index';
+import { callbackManager } from './callbackManager';
 /**
  * Hook to detect Android Auto connection status using the official Android for Cars API
  * Based on: https://developer.android.com/training/cars/apps#car-connection
@@ -13,13 +14,10 @@ import { TrackPlayer } from '../index';
 export function useAndroidAutoConnection() {
     const [isConnected, setIsConnected] = useState(false);
     useEffect(() => {
-        // Set initial state
         const initialState = TrackPlayer.isAndroidAutoConnected();
         setIsConnected(initialState);
-        // Listen for connection changes
-        TrackPlayer.onAndroidAutoConnectionChange((connected) => {
+        return callbackManager.subscribeToAndroidAutoConnection((connected) => {
             setIsConnected(connected);
-            console.log('🚗 Android Auto connection changed:', connected);
         });
     }, []);
     return { isConnected };

package/lib/hooks/useAudioDevices.js

@@ -1,6 +1,10 @@
 import { useEffect, useState } from 'react';
-import { Platform } from 'react-native';
-import { NitroModules } from 'react-native-nitro-modules';
+import { AudioDevices } from '../index';
+function devicesEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return a.every((d, i) => d.id === b[i].id && d.isActive === b[i].isActive);
+}
 /**
  * Hook to get audio devices (Android only)
  *
@@ -26,30 +30,23 @@ import { NitroModules } from 'react-native-nitro-modules';
 export function useAudioDevices() {
     const [devices, setDevices] = useState([]);
     useEffect(() => {
-        if (Platform.OS !== 'android') {
-            return undefined;
-        }
-        try {
-            const AudioDevices = NitroModules.createHybridObject('AudioDevices');
-            // Get initial devices
-            const updateDevices = () => {
-                try {
-                    const currentDevices = AudioDevices.getAudioDevices();
-                    setDevices(currentDevices);
-                }
-                catch (error) {
-                    console.error('Error getting audio devices:', error);
-                }
-            };
-            updateDevices();
-            // Poll for changes every 2 seconds
-            const interval = setInterval(updateDevices, 2000);
-            return () => clearInterval(interval);
-        }
-        catch (error) {
-            console.error('Error setting up audio devices polling:', error);
+        if (!AudioDevices) {
             return undefined;
         }
+        const updateDevices = () => {
+            try {
+                const currentDevices = AudioDevices.getAudioDevices();
+                // Bail when nothing changed — the bridge returns a fresh array identity
+                // every tick, which would otherwise re-render every consumer at 0.5Hz
+                setDevices((prev) => devicesEqual(prev, currentDevices) ? prev : currentDevices);
+            }
+            catch (error) {
+                console.error('Error getting audio devices:', error);
+            }
+        };
+        updateDevices();
+        const interval = setInterval(updateDevices, 2000);
+        return () => clearInterval(interval);
     }, []);
     return { devices };
 }

package/lib/hooks/useDownloadActions.js

@@ -1,4 +1,4 @@
-import { useCallback, useState } from 'react';
+import { useCallback, useRef, useState } from 'react';
 import { DownloadManager } from '../index';
 /**
  * Hook for download actions (download, pause, resume, cancel, delete)
@@ -7,8 +7,30 @@ export function useDownloadActions() {
     const [isDownloading, setIsDownloading] = useState(false);
     const [isDeleting, setIsDeleting] = useState(false);
     const [error, setError] = useState(null);
-    const downloadTrack = useCallback(async (track, playlistId) => {
+    // Pending counts: overlapping calls otherwise clear the flag while a
+    // second request is still in flight
+    const downloadingCount = useRef(0);
+    const deletingCount = useRef(0);
+    const beginDownloading = useCallback(() => {
+        downloadingCount.current += 1;
         setIsDownloading(true);
+    }, []);
+    const endDownloading = useCallback(() => {
+        downloadingCount.current = Math.max(0, downloadingCount.current - 1);
+        if (downloadingCount.current === 0)
+            setIsDownloading(false);
+    }, []);
+    const beginDeleting = useCallback(() => {
+        deletingCount.current += 1;
+        setIsDeleting(true);
+    }, []);
+    const endDeleting = useCallback(() => {
+        deletingCount.current = Math.max(0, deletingCount.current - 1);
+        if (deletingCount.current === 0)
+            setIsDeleting(false);
+    }, []);
+    const downloadTrack = useCallback(async (track, playlistId) => {
+        beginDownloading();
         setError(null);
         try {
             const downloadId = await DownloadManager.downloadTrack(track, playlistId);
@@ -19,11 +41,11 @@ export function useDownloadActions() {
             throw e;
         }
         finally {
-            setIsDownloading(false);
+            endDownloading();
         }
     }, []);
     const downloadPlaylist = useCallback(async (playlistId, tracks) => {
-        setIsDownloading(true);
+        beginDownloading();
         setError(null);
         try {
             const downloadIds = await DownloadManager.downloadPlaylist(playlistId, tracks);
@@ -34,7 +56,7 @@ export function useDownloadActions() {
             throw e;
         }
         finally {
-            setIsDownloading(false);
+            endDownloading();
         }
     }, []);
     const pauseDownload = useCallback(async (downloadId) => {
@@ -59,30 +81,30 @@ export function useDownloadActions() {
         await DownloadManager.cancelAllDownloads();
     }, []);
     const deleteTrack = useCallback(async (trackId) => {
-        setIsDeleting(true);
+        beginDeleting();
         try {
             await DownloadManager.deleteDownloadedTrack(trackId);
         }
         finally {
-            setIsDeleting(false);
+            endDeleting();
         }
     }, []);
     const deletePlaylist = useCallback(async (playlistId) => {
-        setIsDeleting(true);
+        beginDeleting();
         try {
             await DownloadManager.deleteDownloadedPlaylist(playlistId);
         }
         finally {
-            setIsDeleting(false);
+            endDeleting();
         }
     }, []);
     const deleteAll = useCallback(async () => {
-        setIsDeleting(true);
+        beginDeleting();
         try {
             await DownloadManager.deleteAllDownloads();
         }
         finally {
-            setIsDeleting(false);
+            endDeleting();
         }
     }, []);
     const configure = useCallback((config) => {

package/lib/hooks/useDownloadProgress.js

@@ -1,4 +1,4 @@
-import { useEffect, useState, useRef, useCallback } from 'react';
+import { useEffect, useState, useRef, useCallback, useMemo } from 'react';
 import { DownloadManager } from '../index';
 import { downloadCallbackManager } from './downloadCallbackManager';
 /**
@@ -8,22 +8,24 @@ export function useDownloadProgress(options = {}) {
     const { trackIds, downloadIds, activeOnly = false } = options;
     const [progressMap, setProgressMap] = useState(new Map());
     const isMounted = useRef(true);
+    // Content keys: callers pass inline arrays, so identity-based deps would
+    // resubscribe (and re-fetch over the bridge) on every parent render
+    const trackIdsKey = JSON.stringify(trackIds ?? []);
+    const downloadIdsKey = JSON.stringify(downloadIds ?? []);
     const shouldTrack = useCallback((progress) => {
-        if (trackIds &&
-            trackIds.length > 0 &&
-            !trackIds.includes(progress.trackId)) {
+        const ids = JSON.parse(trackIdsKey);
+        const dlIds = JSON.parse(downloadIdsKey);
+        if (ids.length > 0 && !ids.includes(progress.trackId)) {
             return false;
         }
-        if (downloadIds &&
-            downloadIds.length > 0 &&
-            !downloadIds.includes(progress.downloadId)) {
+        if (dlIds.length > 0 && !dlIds.includes(progress.downloadId)) {
             return false;
         }
         if (activeOnly && progress.state !== 'downloading') {
             return false;
         }
         return true;
-    }, [trackIds, downloadIds, activeOnly]);
+    }, [trackIdsKey, downloadIdsKey, activeOnly]);
     useEffect(() => {
         isMounted.current = true;
         // Initialize with current active downloads
@@ -69,12 +71,16 @@ export function useDownloadProgress(options = {}) {
             unsubscribe();
         };
     }, [shouldTrack]);
-    const progressList = Array.from(progressMap.values());
-    const overallProgress = progressList.length > 0
-        ? progressList.reduce((sum, p) => sum + p.progress, 0) /
-            progressList.length
-        : 0;
-    const isDownloading = progressList.some((p) => p.state === 'downloading');
+    const { progressList, overallProgress, isDownloading } = useMemo(() => {
+        const list = Array.from(progressMap.values());
+        return {
+            progressList: list,
+            overallProgress: list.length > 0
+                ? list.reduce((sum, p) => sum + p.progress, 0) / list.length
+                : 0,
+            isDownloading: list.some((p) => p.state === 'downloading'),
+        };
+    }, [progressMap]);
     const getProgress = useCallback((trackId) => progressMap.get(trackId), [progressMap]);
     return {
         progressMap,

package/lib/hooks/useDownloadStorage.js

@@ -46,7 +46,7 @@ export function useDownloadStorage() {
     const formattedAvailable = storageInfo
         ? formatBytes(storageInfo.availableSpace)
         : '0 B';
-    const usagePercentage = storageInfo
+    const usagePercentage = storageInfo && storageInfo.totalSpace > 0
         ? (storageInfo.totalDownloadedSize / storageInfo.totalSpace) * 100
         : 0;
     return {

package/lib/hooks/useNowPlaying.js

@@ -47,19 +47,41 @@ const DEFAULT_STATE = {
 export function useNowPlaying() {
     const [state, setState] = useState(DEFAULT_STATE);
     const isMounted = useRef(true);
+    // Once pushed events carry position, an async getState() snapshot must not
+    // overwrite it — a slow snapshot resolving after newer ticks jumped the
+    // progress bar backward on play/pause/track transitions.
+    const eventsOwnPosition = useRef(false);
+    const fetchScheduled = useRef(false);
     const fetchFullState = useCallback(async () => {
         if (!isMounted.current)
             return;
         try {
             const newState = await TrackPlayer.getState();
             if (isMounted.current) {
-                setState(newState);
+                setState((prev) => eventsOwnPosition.current
+                    ? {
+                        ...newState,
+                        currentPosition: prev.currentPosition,
+                        totalDuration: prev.totalDuration,
+                    }
+                    : newState);
             }
         }
         catch (error) {
             console.error('[useNowPlaying] Error updating player state:', error);
         }
     }, []);
+    // Coalesces the track-change + playback-state burst that fires on one
+    // transition into a single getState() round trip
+    const requestFullState = useCallback(() => {
+        if (fetchScheduled.current)
+            return;
+        fetchScheduled.current = true;
+        queueMicrotask(() => {
+            fetchScheduled.current = false;
+            fetchFullState();
+        });
+    }, [fetchFullState]);
     // Initialize with current state
     useEffect(() => {
         isMounted.current = true;
@@ -68,18 +90,20 @@ export function useNowPlaying() {
             isMounted.current = false;
         };
     }, [fetchFullState]);
-    // Subscribe to track changes — full refresh
+    // Subscribe to track changes — full refresh; the new track's position comes
+    // from the snapshot, so release event ownership until ticks resume
     useEffect(() => {
         return callbackManager.subscribeToTrackChange(() => {
-            fetchFullState();
+            eventsOwnPosition.current = false;
+            requestFullState();
         });
-    }, [fetchFullState]);
+    }, [requestFullState]);
     // Subscribe to playback state changes — full refresh
     useEffect(() => {
         return callbackManager.subscribeToPlaybackState(() => {
-            fetchFullState();
+            requestFullState();
         });
-    }, [fetchFullState]);
+    }, [requestFullState]);
     // Subscribe to progress changes — lightweight position/duration update.
     // Bail out when neither value changed at whole-second resolution: the native tick
     // is sub-second, and a new state object on every tick re-renders every consumer.
@@ -87,6 +111,7 @@ export function useNowPlaying() {
         return callbackManager.subscribeToPlaybackProgressChange((currentPosition, totalDuration) => {
             if (!isMounted.current)
                 return;
+            eventsOwnPosition.current = true;
             setState((prev) => {
                 if (Math.floor(prev.currentPosition) === Math.floor(currentPosition) &&
                     prev.totalDuration === totalDuration) {
@@ -101,6 +126,7 @@ export function useNowPlaying() {
         return callbackManager.subscribeToSeek((currentPosition, totalDuration) => {
             if (!isMounted.current)
                 return;
+            eventsOwnPosition.current = true;
             setState((prev) => ({ ...prev, currentPosition, totalDuration }));
         });
     }, []);

package/lib/hooks/useOnSeek.js

@@ -1,5 +1,5 @@
 import { useEffect, useState } from 'react';
-import { TrackPlayer } from '../index';
+import { callbackManager } from './callbackManager';
 /**
  * Hook to get the last seek event information
  * @returns Object with last seek position and total duration, or undefined if no seek has occurred
@@ -8,7 +8,7 @@ export function useOnSeek() {
     const [position, setPosition] = useState(undefined);
     const [totalDuration, setTotalDuration] = useState(undefined);
     useEffect(() => {
-        TrackPlayer.onSeek((newPosition, newTotalDuration) => {
+        return callbackManager.subscribeToSeek((newPosition, newTotalDuration) => {
             setPosition(newPosition);
             setTotalDuration(newTotalDuration);
         });

package/lib/hooks/usePlaylist.js

@@ -40,7 +40,6 @@ export function usePlaylist() {
     const [allTracks, setAllTracks] = useState([]);
     const [isLoading, setIsLoading] = useState(true);
     const isMounted = useRef(true);
-    const hasSubscribed = useRef(false);
     // Tracks the last fetched playlist ID so track-change events can skip
     // a full refresh when the playlist itself hasn't changed.
     const lastPlaylistIdRef = useRef(undefined);
@@ -119,21 +118,13 @@ export function usePlaylist() {
             isMounted.current = false;
         };
     }, [refreshPlaylists]);
-    // Subscribe to native playlist changes (only once)
+    // Subscribe to native playlist changes via the shared manager
     useEffect(() => {
-        if (hasSubscribed.current)
-            return;
-        hasSubscribed.current = true;
-        try {
-            PlayerQueue.onPlaylistsChanged(() => {
-                if (isMounted.current) {
-                    refreshPlaylists();
-                }
-            });
-        }
-        catch (error) {
-            console.error('[usePlaylist] Error setting up playlist listener:', error);
-        }
+        return callbackManager.subscribeToPlaylistsChanged(() => {
+            if (isMounted.current) {
+                refreshPlaylists();
+            }
+        });
     }, [refreshPlaylists]);
     // Refresh on track change only if the active playlist ID changed.
     useEffect(() => {

package/lib/specs/TrackPlayer.nitro.d.ts

@@ -46,6 +46,11 @@ export interface TrackPlayer extends HybridObject<{
      * updates and ID3 frames emitted while a live stream plays.
      */
     onTimedMetadata(callback: (metadata: TimedMetadata) => void): void;
+    /**
+     * Fires when the app was opened by tapping the playback notification,
+     * with the track that was playing at tap time. Android only — no-op on iOS.
+     */
+    appStartedWithNotification(callback: (track: TrackItem) => void): void;
     onAndroidAutoConnectionChange(callback: (connected: boolean) => void): void;
     isAndroidAutoConnected(): boolean;
     setVolume(volume: number): Promise<void>;
@@ -87,8 +92,7 @@ export interface TrackPlayer extends HybridObject<{
      */
     onTracksNeedUpdate(callback: (tracks: TrackItem[], lookahead: number) => void): void;
     /**
-     * Get the current track index in the active playlist
-     * @returns Promise resolving to 0-based index, or -1 if no track playing
+     * Set playback speed. Rejects non-finite and non-positive values.
      */
     setPlaybackSpeed(speed: number): Promise<void>;
     /**

package/lib/types/PlayerQueue.d.ts

@@ -48,6 +48,14 @@ export interface PlayerConfig {
     androidAutoEnabled?: boolean;
     carPlayEnabled?: boolean;
     showInNotification?: boolean;
+    /**
+     * Fixed interval, in seconds, for remote skip-forward controls (default: 15)
+     */
+    remoteSkipForwardInterval?: number;
+    /**
+     * Fixed interval, in seconds, for remote skip-backward controls (default: 15)
+     */
+    remoteSkipBackwardInterval?: number;
     /**
      * Number of upcoming tracks to preload URLs for (default: 5)
      * Higher values = more proactive loading, but more network requests

package/nitrogen/generated/android/NitroPlayerOnLoad.cpp

@@ -36,6 +36,7 @@
 #include "JFunc_void_double_double.hpp"
 #include "JFunc_void_double_double_std__optional_bool_.hpp"
 #include "JFunc_void_TimedMetadata.hpp"
+#include "JFunc_void_TrackItem.hpp"
 #include "JFunc_void_std__vector_TrackItem__double.hpp"
 #include "JFunc_void_std__vector_TrackItem__std__vector_TrackItem_.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
@@ -131,6 +132,7 @@ void registerAllNatives() {
   margelo::nitro::nitroplayer::JFunc_void_double_double_cxx::registerNatives();
   margelo::nitro::nitroplayer::JFunc_void_double_double_std__optional_bool__cxx::registerNatives();
   margelo::nitro::nitroplayer::JFunc_void_TimedMetadata_cxx::registerNatives();
+  margelo::nitro::nitroplayer::JFunc_void_TrackItem_cxx::registerNatives();
   margelo::nitro::nitroplayer::JFunc_void_std__vector_TrackItem__double_cxx::registerNatives();
   margelo::nitro::nitroplayer::JFunc_void_std__vector_TrackItem__std__vector_TrackItem__cxx::registerNatives();
 

package/nitrogen/generated/android/c++/JFunc_void_TrackItem.hpp

@@ -0,0 +1,85 @@
+///
+/// JFunc_void_TrackItem.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "TrackItem.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JTrackItem.hpp"
+#include <string>
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <optional>
+#include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(track: TrackItem) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_TrackItem: public jni::JavaClass<JFunc_void_TrackItem> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_TrackItem;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_TrackItem` instance holds through JNI.
+     */
+    void invoke(const TrackItem& track) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JTrackItem> /* track */)>("invoke");
+      method(self(), JTrackItem::fromCpp(track));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_TrackItem that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_TrackItem_cxx final: public jni::HybridClass<JFunc_void_TrackItem_cxx, JFunc_void_TrackItem> {
+  public:
+    static jni::local_ref<JFunc_void_TrackItem::javaobject> fromCpp(const std::function<void(const TrackItem& /* track */)>& func) {
+      return JFunc_void_TrackItem_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_TrackItem_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JTrackItem> track) {
+      _func(track->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const TrackItem& /* track */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_TrackItem_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_TrackItem_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_TrackItem_cxx(const std::function<void(const TrackItem& /* track */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const TrackItem& /* track */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer

package/nitrogen/generated/android/c++/JHybridTrackPlayerSpec.cpp

@@ -60,6 +60,7 @@ namespace margelo::nitro::nitroplayer { struct TimedMetadata; }
 #include "TimedMetadata.hpp"
 #include "JFunc_void_TimedMetadata.hpp"
 #include "JTimedMetadata.hpp"
+#include "JFunc_void_TrackItem.hpp"
 #include "JFunc_void_bool.hpp"
 #include "JFunc_void_std__vector_TrackItem__double.hpp"
 #include "JFunc_void_std__vector_TrackItem__std__vector_TrackItem_.hpp"
@@ -329,6 +330,10 @@ namespace margelo::nitro::nitroplayer {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_TimedMetadata::javaobject> /* callback */)>("onTimedMetadata_cxx");
     method(_javaPart, JFunc_void_TimedMetadata_cxx::fromCpp(callback));
   }
+  void JHybridTrackPlayerSpec::appStartedWithNotification(const std::function<void(const TrackItem& /* track */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_TrackItem::javaobject> /* callback */)>("appStartedWithNotification_cxx");
+    method(_javaPart, JFunc_void_TrackItem_cxx::fromCpp(callback));
+  }
   void JHybridTrackPlayerSpec::onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool::javaobject> /* callback */)>("onAndroidAutoConnectionChange_cxx");
     method(_javaPart, JFunc_void_bool_cxx::fromCpp(callback));

package/nitrogen/generated/android/c++/JHybridTrackPlayerSpec.hpp

@@ -73,6 +73,7 @@ namespace margelo::nitro::nitroplayer {
     void onSeek(const std::function<void(double /* position */, double /* totalDuration */)>& callback) override;
     void onPlaybackProgressChange(const std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>& callback) override;
     void onTimedMetadata(const std::function<void(const TimedMetadata& /* metadata */)>& callback) override;
+    void appStartedWithNotification(const std::function<void(const TrackItem& /* track */)>& callback) override;
     void onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) override;
     bool isAndroidAutoConnected() override;
     std::shared_ptr<Promise<void>> setVolume(double volume) override;

package/nitrogen/generated/android/c++/JPlayerConfig.hpp

@@ -38,6 +38,10 @@ namespace margelo::nitro::nitroplayer {
       jni::local_ref<jni::JBoolean> carPlayEnabled = this->getFieldValue(fieldCarPlayEnabled);
       static const auto fieldShowInNotification = clazz->getField<jni::JBoolean>("showInNotification");
       jni::local_ref<jni::JBoolean> showInNotification = this->getFieldValue(fieldShowInNotification);
+      static const auto fieldRemoteSkipForwardInterval = clazz->getField<jni::JDouble>("remoteSkipForwardInterval");
+      jni::local_ref<jni::JDouble> remoteSkipForwardInterval = this->getFieldValue(fieldRemoteSkipForwardInterval);
+      static const auto fieldRemoteSkipBackwardInterval = clazz->getField<jni::JDouble>("remoteSkipBackwardInterval");
+      jni::local_ref<jni::JDouble> remoteSkipBackwardInterval = this->getFieldValue(fieldRemoteSkipBackwardInterval);
       static const auto fieldLookaheadCount = clazz->getField<jni::JDouble>("lookaheadCount");
       jni::local_ref<jni::JDouble> lookaheadCount = this->getFieldValue(fieldLookaheadCount);
       static const auto fieldAndroidNotificationIcon = clazz->getField<jni::JString>("androidNotificationIcon");
@@ -46,6 +50,8 @@ namespace margelo::nitro::nitroplayer {
         androidAutoEnabled != nullptr ? std::make_optional(static_cast<bool>(androidAutoEnabled->value())) : std::nullopt,
         carPlayEnabled != nullptr ? std::make_optional(static_cast<bool>(carPlayEnabled->value())) : std::nullopt,
         showInNotification != nullptr ? std::make_optional(static_cast<bool>(showInNotification->value())) : std::nullopt,
+        remoteSkipForwardInterval != nullptr ? std::make_optional(remoteSkipForwardInterval->value()) : std::nullopt,
+        remoteSkipBackwardInterval != nullptr ? std::make_optional(remoteSkipBackwardInterval->value()) : std::nullopt,
         lookaheadCount != nullptr ? std::make_optional(lookaheadCount->value()) : std::nullopt,
         androidNotificationIcon != nullptr ? std::make_optional(androidNotificationIcon->toStdString()) : std::nullopt
       );
@@ -57,7 +63,7 @@ namespace margelo::nitro::nitroplayer {
      */
     [[maybe_unused]]
     static jni::local_ref<JPlayerConfig::javaobject> fromCpp(const PlayerConfig& value) {
-      using JSignature = JPlayerConfig(jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JString>);
+      using JSignature = JPlayerConfig(jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JString>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -65,6 +71,8 @@ namespace margelo::nitro::nitroplayer {
         value.androidAutoEnabled.has_value() ? jni::JBoolean::valueOf(value.androidAutoEnabled.value()) : nullptr,
         value.carPlayEnabled.has_value() ? jni::JBoolean::valueOf(value.carPlayEnabled.value()) : nullptr,
         value.showInNotification.has_value() ? jni::JBoolean::valueOf(value.showInNotification.value()) : nullptr,
+        value.remoteSkipForwardInterval.has_value() ? jni::JDouble::valueOf(value.remoteSkipForwardInterval.value()) : nullptr,
+        value.remoteSkipBackwardInterval.has_value() ? jni::JDouble::valueOf(value.remoteSkipBackwardInterval.value()) : nullptr,
         value.lookaheadCount.has_value() ? jni::JDouble::valueOf(value.lookaheadCount.value()) : nullptr,
         value.androidNotificationIcon.has_value() ? jni::make_jstring(value.androidNotificationIcon.value()) : nullptr
       );