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

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/Func_void_TrackItem.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_TrackItem.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitroplayer
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(track: struct) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_TrackItem: (TrackItem) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(track: TrackItem): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(track: struct) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_TrackItem_cxx: Func_void_TrackItem {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(track: TrackItem): Unit
+    = invoke_cxx(track)
+
+  @FastNative
+  private external fun invoke_cxx(track: TrackItem): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(track: struct) => void`.
+ * This is implemented in Java/Kotlin, via a `(TrackItem) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_TrackItem_java(private val function: (TrackItem) -> Unit): Func_void_TrackItem {
+  @DoNotStrip
+  @Keep
+  override fun invoke(track: TrackItem): Unit {
+    return this.function(track)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/HybridTrackPlayerSpec.kt

@@ -130,6 +130,15 @@ abstract class HybridTrackPlayerSpec: HybridObject() {
     return __result
   }
   
+  abstract fun appStartedWithNotification(callback: (track: TrackItem) -> Unit): Unit
+  
+  @DoNotStrip
+  @Keep
+  private fun appStartedWithNotification_cxx(callback: Func_void_TrackItem): Unit {
+    val __result = appStartedWithNotification(callback)
+    return __result
+  }
+  
   abstract fun onAndroidAutoConnectionChange(callback: (connected: Boolean) -> Unit): Unit
   
   @DoNotStrip

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/PlayerConfig.kt

@@ -28,6 +28,12 @@ data class PlayerConfig(
   val showInNotification: Boolean?,
   @DoNotStrip
   @Keep
+  val remoteSkipForwardInterval: Double?,
+  @DoNotStrip
+  @Keep
+  val remoteSkipBackwardInterval: Double?,
+  @DoNotStrip
+  @Keep
   val lookaheadCount: Double?,
   @DoNotStrip
   @Keep
@@ -43,8 +49,8 @@ data class PlayerConfig(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(androidAutoEnabled: Boolean?, carPlayEnabled: Boolean?, showInNotification: Boolean?, lookaheadCount: Double?, androidNotificationIcon: String?): PlayerConfig {
-      return PlayerConfig(androidAutoEnabled, carPlayEnabled, showInNotification, lookaheadCount, androidNotificationIcon)
+    private fun fromCpp(androidAutoEnabled: Boolean?, carPlayEnabled: Boolean?, showInNotification: Boolean?, remoteSkipForwardInterval: Double?, remoteSkipBackwardInterval: Double?, lookaheadCount: Double?, androidNotificationIcon: String?): PlayerConfig {
+      return PlayerConfig(androidAutoEnabled, carPlayEnabled, showInNotification, remoteSkipForwardInterval, remoteSkipBackwardInterval, lookaheadCount, androidNotificationIcon)
     }
   }
 }

package/nitrogen/generated/ios/NitroPlayer-Swift-Cxx-Bridge.cpp

@@ -323,6 +323,14 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const TrackItem& /* track */)>
+  Func_void_TrackItem create_Func_void_TrackItem(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroPlayer::Func_void_TrackItem::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const TrackItem& track) mutable -> void {
+      swiftClosure.call(track);
+    };
+  }
+  
   // pragma MARK: std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>
   Func_void_std__vector_TrackItem__double create_Func_void_std__vector_TrackItem__double(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = NitroPlayer::Func_void_std__vector_TrackItem__double::fromUnsafe(swiftClosureWrapper);

package/nitrogen/generated/ios/NitroPlayer-Swift-Cxx-Bridge.hpp

@@ -1752,6 +1752,28 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
     return Func_void_TimedMetadata_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::function<void(const TrackItem& /* track */)>
+  /**
+   * Specialized version of `std::function<void(const TrackItem&)>`.
+   */
+  using Func_void_TrackItem = std::function<void(const TrackItem& /* track */)>;
+  /**
+   * Wrapper class for a `std::function<void(const TrackItem& / * track * /)>`, this can be used from Swift.
+   */
+  class Func_void_TrackItem_Wrapper final {
+  public:
+    explicit Func_void_TrackItem_Wrapper(std::function<void(const TrackItem& /* track */)>&& func): _function(std::make_unique<std::function<void(const TrackItem& /* track */)>>(std::move(func))) {}
+    inline void call(TrackItem track) const noexcept {
+      _function->operator()(track);
+    }
+  private:
+    std::unique_ptr<std::function<void(const TrackItem& /* track */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_TrackItem create_Func_void_TrackItem(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_TrackItem_Wrapper wrap_Func_void_TrackItem(Func_void_TrackItem value) noexcept {
+    return Func_void_TrackItem_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>
   /**
    * Specialized version of `std::function<void(const std::vector<TrackItem>&, double)>`.

package/nitrogen/generated/ios/c++/HybridTrackPlayerSpecSwift.hpp

@@ -238,6 +238,12 @@ namespace margelo::nitro::nitroplayer {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void appStartedWithNotification(const std::function<void(const TrackItem& /* track */)>& callback) override {
+      auto __result = _swiftPart.appStartedWithNotification(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) override {
       auto __result = _swiftPart.onAndroidAutoConnectionChange(callback);
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/Func_void_TrackItem.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_TrackItem.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ track: TrackItem) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_TrackItem {
+  public typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  private let closure: (_ track: TrackItem) -> Void
+
+  public init(_ closure: @escaping (_ track: TrackItem) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(track: TrackItem) -> Void {
+    self.closure(track)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_TrackItem`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_TrackItem>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_TrackItem {
+    return Unmanaged<Func_void_TrackItem>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec.swift

@@ -32,6 +32,7 @@ public protocol HybridTrackPlayerSpec_protocol: HybridObject {
   func onSeek(callback: @escaping (_ position: Double, _ totalDuration: Double) -> Void) throws -> Void
   func onPlaybackProgressChange(callback: @escaping (_ position: Double, _ totalDuration: Double, _ isManuallySeeked: Bool?) -> Void) throws -> Void
   func onTimedMetadata(callback: @escaping (_ metadata: TimedMetadata) -> Void) throws -> Void
+  func appStartedWithNotification(callback: @escaping (_ track: TrackItem) -> Void) throws -> Void
   func onAndroidAutoConnectionChange(callback: @escaping (_ connected: Bool) -> Void) throws -> Void
   func isAndroidAutoConnected() throws -> Bool
   func setVolume(volume: Double) throws -> Promise<Void>

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec_cxx.swift

@@ -494,6 +494,22 @@ open class HybridTrackPlayerSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func appStartedWithNotification(callback: bridge.Func_void_TrackItem) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.appStartedWithNotification(callback: { () -> (TrackItem) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_TrackItem(callback)
+        return { (__track: TrackItem) -> Void in
+          __wrappedFunction.call(__track)
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func onAndroidAutoConnectionChange(callback: bridge.Func_void_bool) -> bridge.Result_void_ {
     do {

package/nitrogen/generated/ios/swift/PlayerConfig.swift

@@ -18,7 +18,7 @@ public extension PlayerConfig {
   /**
    * Create a new instance of `PlayerConfig`.
    */
-  init(androidAutoEnabled: Bool?, carPlayEnabled: Bool?, showInNotification: Bool?, lookaheadCount: Double?, androidNotificationIcon: String?) {
+  init(androidAutoEnabled: Bool?, carPlayEnabled: Bool?, showInNotification: Bool?, remoteSkipForwardInterval: Double?, remoteSkipBackwardInterval: Double?, lookaheadCount: Double?, androidNotificationIcon: String?) {
     self.init({ () -> bridge.std__optional_bool_ in
       if let __unwrappedValue = androidAutoEnabled {
         return bridge.create_std__optional_bool_(__unwrappedValue)
@@ -37,6 +37,18 @@ public extension PlayerConfig {
       } else {
         return .init()
       }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = remoteSkipForwardInterval {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = remoteSkipBackwardInterval {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
     }(), { () -> bridge.std__optional_double_ in
       if let __unwrappedValue = lookaheadCount {
         return bridge.create_std__optional_double_(__unwrappedValue)
@@ -88,6 +100,30 @@ public extension PlayerConfig {
     }()
   }
   
+  @inline(__always)
+  var remoteSkipForwardInterval: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__remoteSkipForwardInterval) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__remoteSkipForwardInterval)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var remoteSkipBackwardInterval: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__remoteSkipBackwardInterval) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__remoteSkipBackwardInterval)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
   @inline(__always)
   var lookaheadCount: Double? {
     return { () -> Double? in

package/nitrogen/generated/shared/c++/HybridTrackPlayerSpec.cpp

@@ -33,6 +33,7 @@ namespace margelo::nitro::nitroplayer {
       prototype.registerHybridMethod("onSeek", &HybridTrackPlayerSpec::onSeek);
       prototype.registerHybridMethod("onPlaybackProgressChange", &HybridTrackPlayerSpec::onPlaybackProgressChange);
       prototype.registerHybridMethod("onTimedMetadata", &HybridTrackPlayerSpec::onTimedMetadata);
+      prototype.registerHybridMethod("appStartedWithNotification", &HybridTrackPlayerSpec::appStartedWithNotification);
       prototype.registerHybridMethod("onAndroidAutoConnectionChange", &HybridTrackPlayerSpec::onAndroidAutoConnectionChange);
       prototype.registerHybridMethod("isAndroidAutoConnected", &HybridTrackPlayerSpec::isAndroidAutoConnected);
       prototype.registerHybridMethod("setVolume", &HybridTrackPlayerSpec::setVolume);

package/nitrogen/generated/shared/c++/HybridTrackPlayerSpec.hpp

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

package/nitrogen/generated/shared/c++/PlayerConfig.hpp

@@ -43,12 +43,14 @@ namespace margelo::nitro::nitroplayer {
     std::optional<bool> androidAutoEnabled     SWIFT_PRIVATE;
     std::optional<bool> carPlayEnabled     SWIFT_PRIVATE;
     std::optional<bool> showInNotification     SWIFT_PRIVATE;
+    std::optional<double> remoteSkipForwardInterval     SWIFT_PRIVATE;
+    std::optional<double> remoteSkipBackwardInterval     SWIFT_PRIVATE;
     std::optional<double> lookaheadCount     SWIFT_PRIVATE;
     std::optional<std::string> androidNotificationIcon     SWIFT_PRIVATE;
 
   public:
     PlayerConfig() = default;
-    explicit PlayerConfig(std::optional<bool> androidAutoEnabled, std::optional<bool> carPlayEnabled, std::optional<bool> showInNotification, std::optional<double> lookaheadCount, std::optional<std::string> androidNotificationIcon): androidAutoEnabled(androidAutoEnabled), carPlayEnabled(carPlayEnabled), showInNotification(showInNotification), lookaheadCount(lookaheadCount), androidNotificationIcon(androidNotificationIcon) {}
+    explicit PlayerConfig(std::optional<bool> androidAutoEnabled, std::optional<bool> carPlayEnabled, std::optional<bool> showInNotification, std::optional<double> remoteSkipForwardInterval, std::optional<double> remoteSkipBackwardInterval, std::optional<double> lookaheadCount, std::optional<std::string> androidNotificationIcon): androidAutoEnabled(androidAutoEnabled), carPlayEnabled(carPlayEnabled), showInNotification(showInNotification), remoteSkipForwardInterval(remoteSkipForwardInterval), remoteSkipBackwardInterval(remoteSkipBackwardInterval), lookaheadCount(lookaheadCount), androidNotificationIcon(androidNotificationIcon) {}
 
   public:
     friend bool operator==(const PlayerConfig& lhs, const PlayerConfig& rhs) = default;
@@ -67,6 +69,8 @@ namespace margelo::nitro {
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "androidAutoEnabled"))),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "carPlayEnabled"))),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "showInNotification"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipForwardInterval"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipBackwardInterval"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "lookaheadCount"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "androidNotificationIcon")))
       );
@@ -76,6 +80,8 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "androidAutoEnabled"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.androidAutoEnabled));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "carPlayEnabled"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.carPlayEnabled));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "showInNotification"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.showInNotification));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipForwardInterval"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.remoteSkipForwardInterval));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipBackwardInterval"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.remoteSkipBackwardInterval));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "lookaheadCount"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.lookaheadCount));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "androidNotificationIcon"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.androidNotificationIcon));
       return obj;
@@ -91,6 +97,8 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "androidAutoEnabled")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "carPlayEnabled")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "showInNotification")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipForwardInterval")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipBackwardInterval")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "lookaheadCount")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "androidNotificationIcon")))) return false;
       return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "1.6.0-alpha.1",
+  "version": "1.7.0-alpha.0",
   "description": "A powerful audio player library for React Native with playlist management, playback controls, and support for Android Auto and CarPlay",
   "main": "lib/index",
   "module": "lib/index",

package/src/hooks/callbackManager.ts

@@ -19,6 +19,7 @@ type TemporaryQueueCallback = (
   playNextQueue: TrackItem[],
   upNextQueue: TrackItem[]
 ) => void
+type AndroidAutoConnectionCallback = (connected: boolean) => void
 
 /**
  * Internal subscription manager that allows multiple hooks to subscribe
@@ -33,7 +34,10 @@ class CallbackSubscriptionManager {
   private timedMetadataSubscribers = new Set<TimedMetadataCallback>()
   private temporaryQueueSubscribers = new Set<TemporaryQueueCallback>()
   private playlistsChangedSubscribers = new Set<() => void>()
+  private androidAutoConnectionSubscribers =
+    new Set<AndroidAutoConnectionCallback>()
   private isPlaylistsChangedRegistered = false
+  private isAndroidAutoConnectionRegistered = false
   private isPlaybackStateRegistered = false
   private isTrackChangeRegistered = false
   private isPlaybackProgressRegistered = false
@@ -272,6 +276,46 @@ class CallbackSubscriptionManager {
     }
   }
 
+  /**
+   * Subscribe to Android Auto connection changes
+   * @returns Unsubscribe function
+   */
+  subscribeToAndroidAutoConnection(
+    callback: AndroidAutoConnectionCallback
+  ): () => void {
+    this.androidAutoConnectionSubscribers.add(callback)
+    this.ensureAndroidAutoConnectionRegistered()
+
+    return () => {
+      this.androidAutoConnectionSubscribers.delete(callback)
+    }
+  }
+
+  private ensureAndroidAutoConnectionRegistered(): void {
+    if (this.isAndroidAutoConnectionRegistered) return
+
+    try {
+      TrackPlayer.onAndroidAutoConnectionChange((connected) => {
+        this.androidAutoConnectionSubscribers.forEach((subscriber) => {
+          try {
+            subscriber(connected)
+          } catch (error) {
+            console.error(
+              '[CallbackManager] Error in Android Auto connection subscriber:',
+              error
+            )
+          }
+        })
+      })
+      this.isAndroidAutoConnectionRegistered = true
+    } catch (error) {
+      console.error(
+        '[CallbackManager] Failed to register Android Auto connection callback:',
+        error
+      )
+    }
+  }
+
   /**
    * Subscribe to in-stream (timed) metadata events
    * @returns Unsubscribe function

package/src/hooks/useActualQueue.ts

@@ -73,6 +73,18 @@ export function useActualQueue(): UseActualQueueResult {
     }
   }, [])
 
+  // Skips involving temp tracks fire track-change and temporary-queue-change
+  // together; the gate collapses the burst into one getActualQueue() fetch
+  const fetchScheduled = useRef(false)
+  const scheduleUpdate = useCallback(() => {
+    if (fetchScheduled.current) return
+    fetchScheduled.current = true
+    queueMicrotask(() => {
+      fetchScheduled.current = false
+      updateQueue()
+    })
+  }, [updateQueue])
+
   const refreshQueue = useCallback(() => {
     if (!isMounted.current) return
     setIsLoading(true)
@@ -97,25 +109,25 @@ export function useActualQueue(): UseActualQueueResult {
   // track changes and temporary-queue edits do.
   useEffect(() => {
     return callbackManager.subscribeToTrackChange(() => {
-      updateQueue()
+      scheduleUpdate()
     })
-  }, [updateQueue])
+  }, [scheduleUpdate])
 
   // Update queue when playNext / upNext change (native pushes the new lists).
   useEffect(() => {
     return callbackManager.subscribeToTemporaryQueueChange(() => {
-      updateQueue()
+      scheduleUpdate()
     })
-  }, [updateQueue])
+  }, [scheduleUpdate])
 
   // Update queue when the playlist itself is edited (track added / removed / reordered).
   // Without this, a playlist mutation while paused would leave the queue stale until the
   // next track change — playback-state changes used to paper over it.
   useEffect(() => {
     return callbackManager.subscribeToPlaylistsChanged(() => {
-      updateQueue()
+      scheduleUpdate()
     })
-  }, [updateQueue])
+  }, [scheduleUpdate])
 
   return { queue, refreshQueue, isLoading }
 }

package/src/hooks/useAndroidAutoConnection.ts

@@ -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
@@ -15,15 +16,14 @@ export function useAndroidAutoConnection() {
   const [isConnected, setIsConnected] = useState<boolean>(false)
 
   useEffect(() => {
-    // Set initial state
     const initialState = TrackPlayer.isAndroidAutoConnected()
     setIsConnected(initialState)
 
-    // Listen for connection changes
-    TrackPlayer.onAndroidAutoConnectionChange((connected: boolean) => {
-      setIsConnected(connected)
-      console.log('🚗 Android Auto connection changed:', connected)
-    })
+    return callbackManager.subscribeToAndroidAutoConnection(
+      (connected: boolean) => {
+        setIsConnected(connected)
+      }
+    )
   }, [])
 
   return { isConnected }

package/src/hooks/useAudioDevices.ts

@@ -1,9 +1,14 @@
 import { useEffect, useState } from 'react'
-import { Platform } from 'react-native'
-import { NitroModules } from 'react-native-nitro-modules'
-import type { AudioDevices as AudioDevicesType } from '../specs/AudioDevices.nitro'
+import { AudioDevices } from '../index'
 import type { TAudioDevice } from '../specs/AudioDevices.nitro'
 
+function devicesEqual(a: TAudioDevice[], b: TAudioDevice[]): boolean {
+  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)
  *
@@ -30,34 +35,28 @@ export function useAudioDevices() {
   const [devices, setDevices] = useState<TAudioDevice[]>([])
 
   useEffect(() => {
-    if (Platform.OS !== 'android') {
+    if (!AudioDevices) {
       return undefined
     }
 
-    try {
-      const AudioDevices =
-        NitroModules.createHybridObject<AudioDevicesType>('AudioDevices')
-
-      // Get initial devices
-      const updateDevices = () => {
-        try {
-          const currentDevices = AudioDevices.getAudioDevices()
-          setDevices(currentDevices)
-        } catch (error) {
-          console.error('Error getting audio devices:', error)
-        }
+    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()
+    updateDevices()
 
-      // Poll for changes every 2 seconds
-      const interval = setInterval(updateDevices, 2000)
+    const interval = setInterval(updateDevices, 2000)
 
-      return () => clearInterval(interval)
-    } catch (error) {
-      console.error('Error setting up audio devices polling:', error)
-      return undefined
-    }
+    return () => clearInterval(interval)
   }, [])
 
   return { devices }