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

package/android/src/main/java/com/margelo/nitro/nitroplayer/HybridTrackPlayer.kt

@@ -178,6 +178,11 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
         listenerIds += "onAndroidAutoConnectionChange" to id
     }
 
+    override fun appStartedWithNotification(callback: (track: TrackItem) -> Unit) {
+        val id = core.addOnNotificationLaunchListener(callback)
+        listenerIds += "appStartedWithNotification" to id
+    }
+
     override fun onTracksNeedUpdate(callback: (tracks: Array<TrackItem>, lookahead: Double) -> Unit) {
         val id =
             core.addOnTracksNeedUpdateListener { tracks, lookahead ->
@@ -213,6 +218,7 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
                 "onTracksNeedUpdate" -> core.removeOnTracksNeedUpdateListener(id)
                 "onTemporaryQueueChange" -> core.removeOnTemporaryQueueChangeListener(id)
                 "onTimedMetadata" -> core.removeOnTimedMetadataListener(id)
+                "appStartedWithNotification" -> core.removeOnNotificationLaunchListener(id)
             }
         }
         listenerIds.clear()

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerCore.kt

@@ -2,13 +2,17 @@
 
 package com.margelo.nitro.nitroplayer.core
 
+import android.app.Activity
+import android.app.Application
 import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
 import android.content.ServiceConnection
+import android.os.Bundle
 import android.os.Handler
 import android.os.IBinder
 import android.os.Looper
+import com.facebook.react.bridge.ReactApplicationContext
 import com.margelo.nitro.nitroplayer.Reason
 import com.margelo.nitro.nitroplayer.RepeatMode
 import com.margelo.nitro.nitroplayer.TimedMetadata
@@ -95,6 +99,8 @@ class TrackPlayerCore private constructor(
         ListenerRegistry<(TimedMetadata) -> Unit>()
     internal val onCastStateChangeListeners =
         ListenerRegistry<(com.margelo.nitro.nitroplayer.CastState, String?) -> Unit>()
+    internal val onNotificationLaunchListeners =
+        ListenerRegistry<(TrackItem) -> Unit>()
 
     // ── Google Cast ──────────────────────────────────────────────────────────
 
@@ -390,4 +396,57 @@ class TrackPlayerCore private constructor(
     fun addOnCastStateChangeListener(cb: (com.margelo.nitro.nitroplayer.CastState, String?) -> Unit): Long = onCastStateChangeListeners.add(cb)
 
     fun removeOnCastStateChangeListener(id: Long): Boolean = onCastStateChangeListeners.remove(id)
+
+    // ── Notification-launch detection ─────────────────────────────────────
+
+    private var notificationLaunchDetectionRegistered = false
+
+    fun addOnNotificationLaunchListener(cb: (TrackItem) -> Unit): Long {
+        val id = onNotificationLaunchListeners.add(cb)
+        handler.post {
+            registerNotificationLaunchDetection()
+            checkNotificationLaunch((context as? ReactApplicationContext)?.currentActivity)
+        }
+        return id
+    }
+
+    fun removeOnNotificationLaunchListener(id: Long): Boolean = onNotificationLaunchListeners.remove(id)
+
+    private fun registerNotificationLaunchDetection() {
+        if (notificationLaunchDetectionRegistered) return
+        notificationLaunchDetectionRegistered = true
+        val app = context.applicationContext as? Application ?: return
+        app.registerActivityLifecycleCallbacks(
+            object : Application.ActivityLifecycleCallbacks {
+                override fun onActivityResumed(activity: Activity) = checkNotificationLaunch(activity)
+
+                override fun onActivityCreated(
+                    activity: Activity,
+                    savedInstanceState: Bundle?,
+                ) {}
+
+                override fun onActivityStarted(activity: Activity) {}
+
+                override fun onActivityPaused(activity: Activity) {}
+
+                override fun onActivityStopped(activity: Activity) {}
+
+                override fun onActivitySaveInstanceState(
+                    activity: Activity,
+                    outState: Bundle,
+                ) {}
+
+                override fun onActivityDestroyed(activity: Activity) {}
+            },
+        )
+    }
+
+    // Must run on the main looper — reads the player and mutates the activity intent
+    internal fun checkNotificationLaunch(activity: Activity?) {
+        val intent = activity?.intent ?: return
+        if (!intent.getBooleanExtra(NitroPlayerPlaybackService.EXTRA_STARTED_FROM_NOTIFICATION, false)) return
+        val track = getCurrentTrack() ?: return
+        intent.removeExtra(NitroPlayerPlaybackService.EXTRA_STARTED_FROM_NOTIFICATION)
+        onNotificationLaunchListeners.forEach { it(track) }
+    }
 }

package/android/src/main/java/com/margelo/nitro/nitroplayer/media/PlaybackService.kt

@@ -1,5 +1,6 @@
 package com.margelo.nitro.nitroplayer.media
 
+import android.app.PendingIntent
 import android.content.Intent
 import android.os.Binder
 import android.os.Handler
@@ -32,6 +33,7 @@ class NitroPlayerPlaybackService : MediaSessionService() {
 
     companion object {
         const val ACTION_LOCAL_BIND = "com.margelo.nitro.nitroplayer.LOCAL_BIND"
+        const val EXTRA_STARTED_FROM_NOTIFICATION = "com.margelo.nitro.nitroplayer.STARTED_FROM_NOTIFICATION"
 
         @Volatile
         var notificationSmallIconResName: String? = null
@@ -84,6 +86,7 @@ class NitroPlayerPlaybackService : MediaSessionService() {
         mediaSession = MediaSession
             .Builder(this, player)
             .setCallback(MediaSessionCallbackFactory.create(this, playlistManager))
+            .apply { buildSessionActivity()?.let { setSessionActivity(it) } }
             .build()
 
         val provider = DefaultMediaNotificationProvider.Builder(this).build()
@@ -119,6 +122,18 @@ class NitroPlayerPlaybackService : MediaSessionService() {
         }
     }
 
+    // Content intent for the notification tap — newer Android has no fallback without it
+    private fun buildSessionActivity(): PendingIntent? {
+        val launch = packageManager.getLaunchIntentForPackage(packageName) ?: return null
+        launch.putExtra(EXTRA_STARTED_FROM_NOTIFICATION, true)
+        return PendingIntent.getActivity(
+            this,
+            0,
+            launch,
+            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
+        )
+    }
+
     private fun applyNotificationSmallIcon() {
         val name = notificationSmallIconResName ?: return
         val provider = notificationProvider ?: return

package/ios/HybridTrackPlayer.swift

@@ -188,6 +188,10 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
     // No-op on iOS
   }
 
+  func appStartedWithNotification(callback: @escaping (_ track: TrackItem) -> Void) throws {
+    // No-op on iOS — Now Playing controls never launch the app
+  }
+
   func isAndroidAutoConnected() throws -> Bool { false }
 
   // MARK: - Event listeners (v2 — store IDs for cleanup)

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>;

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/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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "1.6.0-alpha.1",
+  "version": "1.6.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/specs/TrackPlayer.nitro.ts

@@ -102,6 +102,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>