react-native-nitro-player 1.4.2 → 1.4.4-alpha.0

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

@@ -8,6 +8,7 @@ import com.margelo.nitro.nitroplayer.Reason
 import com.margelo.nitro.nitroplayer.RepeatMode
 import com.margelo.nitro.nitroplayer.TrackPlayerState
 import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
+import com.margelo.nitro.nitroplayer.media.NitroPlayerPlaybackService
 
 /**
  * Playback control — all public functions are suspend and execute on the player thread
@@ -95,6 +96,7 @@ suspend fun TrackPlayerCore.configure(config: PlayerConfig) =
     withPlayerContext {
         config.androidAutoEnabled?.let { NitroPlayerMediaBrowserService.isAndroidAutoEnabled = it }
         config.lookaheadCount?.let { lookaheadCount = it.toInt() }
+        config.androidNotificationIcon?.let { NitroPlayerPlaybackService.notificationSmallIconResName = it }
         mediaSessionManager?.configure(config.androidAutoEnabled, config.carPlayEnabled, config.showInNotification)
     }
 

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

@@ -7,6 +7,7 @@ import android.os.IBinder
 import android.os.Looper
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.session.DefaultMediaNotificationProvider
 import androidx.media3.session.MediaSession
 import androidx.media3.session.MediaSessionService
 import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
@@ -29,11 +30,24 @@ class NitroPlayerPlaybackService : MediaSessionService() {
 
     companion object {
         const val ACTION_LOCAL_BIND = "com.margelo.nitro.nitroplayer.LOCAL_BIND"
+
+        @Volatile
+        var notificationSmallIconResName: String? = null
+            set(value) {
+                field = value
+                instance?.let { service ->
+                    service.mainHandler.post { service.applyNotificationSmallIcon() }
+                }
+            }
+
+        @Volatile
+        private var instance: NitroPlayerPlaybackService? = null
     }
 
     // ── Created in onCreate ────────────────────────────────────────────────
     private lateinit var player: ExoPlayer
     private var mediaSession: MediaSession? = null
+    private var notificationProvider: DefaultMediaNotificationProvider? = null
     private val mainHandler = Handler(Looper.getMainLooper())
 
     @Volatile
@@ -54,6 +68,7 @@ class NitroPlayerPlaybackService : MediaSessionService() {
     override fun onCreate() {
         super.onCreate()
         NitroPlayerLogger.log("PlaybackService") { "onCreate" }
+        instance = this
 
         // Build ExoPlayer on main looper (default)
         player = ExoPlayerBuilder.build(this)
@@ -65,12 +80,35 @@ class NitroPlayerPlaybackService : MediaSessionService() {
             .setCallback(MediaSessionCallbackFactory.create(this, playlistManager))
             .build()
 
-        // Explicitly register the session with the service so that
-        // MediaNotificationManager (created in super.onCreate()) can
-        // connect its internal MediaController and post notifications.
+        val provider = DefaultMediaNotificationProvider.Builder(this).build()
+        notificationProvider = provider
+        applyNotificationSmallIcon()
+        setMediaNotificationProvider(provider)
+
         addSession(mediaSession!!)
+    }
 
-        // Media3 automatically handles the notification via DefaultMediaNotificationProvider.
+    private fun applyNotificationSmallIcon() {
+        val name = notificationSmallIconResName ?: return
+        val provider = notificationProvider ?: return
+        val resId = resources.getIdentifier(name, "drawable", packageName)
+        if (resId == 0) {
+            NitroPlayerLogger.log("PlaybackService") {
+                "androidNotificationIcon '$name' not found in drawable resources — using default"
+            }
+            return
+        }
+        provider.setSmallIcon(resId)
+
+        // Live Refresh :)
+        val session = mediaSession
+        if (session != null && session.player.isPlaying) {
+            try {
+                onUpdateNotification(session, false)
+            } catch (e: Exception) {
+                NitroPlayerLogger.log("PlaybackService") { "notification refresh failed: ${e.message}" }
+            }
+        }
     }
 
     override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaSession? =
@@ -93,6 +131,8 @@ class NitroPlayerPlaybackService : MediaSessionService() {
 
     override fun onDestroy() {
         NitroPlayerLogger.log("PlaybackService") { "onDestroy" }
+        if (instance === this) instance = null
+        notificationProvider = null
         mediaSession?.release()
         mediaSession = null
         player.release()

package/ios/HybridTrackPlayer.swift

@@ -113,7 +113,6 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
   }
 
   // MARK: - Playback speed
-
   func setPlaybackSpeed(speed: Double) throws -> Promise<Void> {
     Promise.async { await self.core.setPlaybackSpeed(speed) }
   }

package/ios/core/TrackPlayerCore.swift

@@ -57,6 +57,10 @@ class TrackPlayerCore: NSObject {
   internal let preloadQueue = DispatchQueue(label: "com.nitroplayer.preload", qos: .utility)
   internal var didRequestUrlsForCurrentItem = false
 
+  // Follows http→https redirects that AVURLAsset otherwise silently drops (issue #111).
+  // Attached as the resource-loader delegate for cleartext-http assets only.
+  internal let redirectResolver = TrackPlayerRedirectResolver()
+
   // MARK: - Stall & network recovery
   // Whether the user/app wants playback ongoing (true after play(), false after pause()).
   internal var intendedToPlay = false
@@ -216,6 +220,7 @@ class TrackPlayerCore: NSObject {
       self.pathMonitor = nil
       self.preloadedAssets.removeAll()
       self.failedItemRetryCounts.removeAll()
+      self.redirectResolver.clear()
     }
   }
 

package/ios/core/TrackPlayerQueueBuild.swift

@@ -389,6 +389,20 @@ extension TrackPlayerCore {
     return options
   }
 
+  /// Builds the AVURLAsset for a track URL. Cleartext-`http` remote URLs are routed through
+  /// `redirectResolver` so AVFoundation follows http→https redirects it would otherwise drop
+  /// (issue #111). HTTPS and local URLs load natively, unchanged.
+  func makeAsset(for track: TrackItem, url: URL, isLocal: Bool) -> AVURLAsset {
+    let options = assetOptions(for: track, isLocal: isLocal)
+    guard !isLocal, let wrappedURL = TrackPlayerRedirectResolver.wrap(url) else {
+      return AVURLAsset(url: url, options: options)
+    }
+    redirectResolver.registerHeaders(httpHeaders(for: track), for: wrappedURL)
+    let asset = AVURLAsset(url: wrappedURL, options: options)
+    asset.resourceLoader.setDelegate(redirectResolver, queue: redirectResolver.queue)
+    return asset
+  }
+
   /// Creates a gapless-optimized AVPlayerItem with proper buffering configuration
   func createGaplessPlayerItem(for track: TrackItem, isPreload: Bool = false) -> AVPlayerItem? {
     let effectiveUrlString = DownloadManagerCore.shared.getEffectiveUrl(track: track)
@@ -427,7 +441,7 @@ extension TrackPlayerCore {
       asset = preloadedAsset
       NitroPlayerLogger.log("TrackPlayerCore", "🚀 Using preloaded asset for \(track.title)")
     } else {
-      asset = AVURLAsset(url: url, options: assetOptions(for: track, isLocal: isLocal))
+      asset = makeAsset(for: track, url: url, isLocal: isLocal)
     }
 
     let item = AVPlayerItem(asset: asset)
@@ -492,7 +506,7 @@ extension TrackPlayerCore {
           url = remoteUrl
         }
 
-        let asset = AVURLAsset(url: url, options: self.assetOptions(for: track, isLocal: isLocal))
+        let asset = self.makeAsset(for: track, url: url, isLocal: isLocal)
 
         asset.loadValuesAsynchronously(forKeys: Constants.preloadAssetKeys) { [weak self] in
           var allKeysLoaded = true

package/ios/core/TrackPlayerRedirectResolver.swift

@@ -0,0 +1,150 @@
+//
+//  TrackPlayerRedirectResolver.swift
+//  NitroPlayer
+//
+//  Created by Ritesh Shukla.
+//
+//  AVURLAsset does not reliably follow HTTP→HTTPS redirects: when a cleartext `http://`
+//  track URL answers with a 30x (e.g. a universal `308 → https://...` upgrade), AVFoundation
+//  silently drops the redirect and the item fails to load (issue #111). Unlike ExoPlayer's
+//  `setAllowCrossProtocolRedirects(true)`, AVFoundation exposes no such flag.
+//
+//  We work around it by giving such assets a sentinel URL scheme so AVFoundation has to ask
+//  this resource-loader delegate to load them. We then resolve the redirect chain ourselves
+//  with URLSession (which follows redirects) and hand AVFoundation a redirect to the final
+//  URL — after which it loads the media natively from the resolved location.
+//
+//  Only cleartext-`http` URLs are routed here. HTTPS assets are left untouched: AVFoundation
+//  follows same-scheme redirects on its own, so only the failing http path pays the extra
+//  resolution request. The app must still permit the initial cleartext connection via ATS
+//  (`NSAppTransportSecurity`); this delegate only fixes the redirect-following, not ATS.
+//
+
+import AVFoundation
+import Foundation
+
+final class TrackPlayerRedirectResolver: NSObject, AVAssetResourceLoaderDelegate {
+
+  /// Sentinel scheme prefix. A wrapped URL looks like `nitroredirect+http://host/path`.
+  private static let schemePrefix = "nitroredirect+"
+
+  /// Serial queue the resource-loader delegate methods (and our task bookkeeping) run on.
+  let queue = DispatchQueue(label: "com.nitroplayer.redirect", qos: .userInitiated)
+
+  private let session: URLSession
+
+  // In-flight resolution tasks, keyed by loading request, so a cancelled request cancels its
+  // task. Touched only on `queue` (delegate callbacks + the task completion is hopped onto it).
+  private var tasksByRequest: [ObjectIdentifier: URLSessionDataTask] = [:]
+
+  // Custom request headers (e.g. `Authorization`) per wrapped-URL, so the resolution request can
+  // authenticate when a server requires auth even to return the redirect. Written on the player
+  // queue (registerHeaders), read on `queue`; guarded by `headersLock`.
+  private var headersByURL: [String: [String: String]] = [:]
+  private let headersLock = NSLock()
+
+  override init() {
+    let config = URLSessionConfiguration.ephemeral
+    config.requestCachePolicy = .reloadIgnoringLocalCacheData
+    session = URLSession(configuration: config)
+    super.init()
+  }
+
+  // MARK: - URL wrapping
+
+  /// Wraps a cleartext-`http` URL in the sentinel scheme so AVFoundation routes it here.
+  /// Returns nil for anything else (https, file, custom schemes) — those load natively.
+  static func wrap(_ url: URL) -> URL? {
+    guard url.scheme?.lowercased() == "http",
+      var components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+    else { return nil }
+    components.scheme = schemePrefix + "http"
+    return components.url
+  }
+
+  /// Restores the real URL from a sentinel-wrapped URL.
+  private static func unwrap(_ url: URL) -> URL? {
+    guard let scheme = url.scheme?.lowercased(), scheme.hasPrefix(schemePrefix),
+      var components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+    else { return nil }
+    components.scheme = String(scheme.dropFirst(schemePrefix.count))
+    return components.url
+  }
+
+  // MARK: - Header registry
+
+  func registerHeaders(_ headers: [String: String]?, for wrappedURL: URL) {
+    guard let headers, !headers.isEmpty else { return }
+    headersLock.lock()
+    defer { headersLock.unlock() }
+    headersByURL[wrappedURL.absoluteString] = headers
+  }
+
+  /// Releases all registered headers. Call when the player is torn down.
+  func clear() {
+    headersLock.lock()
+    defer { headersLock.unlock() }
+    headersByURL.removeAll()
+  }
+
+  private func headers(for wrappedURL: URL) -> [String: String]? {
+    headersLock.lock()
+    defer { headersLock.unlock() }
+    return headersByURL[wrappedURL.absoluteString]
+  }
+
+  // MARK: - AVAssetResourceLoaderDelegate
+
+  func resourceLoader(
+    _ resourceLoader: AVAssetResourceLoader,
+    shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest
+  ) -> Bool {
+    guard let wrappedURL = loadingRequest.request.url,
+      let realURL = Self.unwrap(wrappedURL)
+    else { return false }
+
+    var request = URLRequest(url: realURL)
+    // HEAD is enough: we only need `response.url` after URLSession follows the redirect chain.
+    // Even if the resolved endpoint rejects HEAD (405), the post-redirect URL is still reported.
+    request.httpMethod = "HEAD"
+    headers(for: wrappedURL)?.forEach { request.setValue($1, forHTTPHeaderField: $0) }
+    loadingRequest.request.allHTTPHeaderFields?.forEach { request.setValue($1, forHTTPHeaderField: $0) }
+
+    let key = ObjectIdentifier(loadingRequest)
+    let task = session.dataTask(with: request) { [weak self] _, response, error in
+      self?.queue.async {
+        guard let self else { return }
+        self.tasksByRequest.removeValue(forKey: key)
+        guard !loadingRequest.isCancelled, !loadingRequest.isFinished else { return }
+
+        if let error {
+          NitroPlayerLogger.log("TrackPlayerCore", "❌ Redirect resolution failed for \(realURL): \(error.localizedDescription)")
+          loadingRequest.finishLoading(with: error)
+          return
+        }
+
+        // `response.url` is the final URL after URLSession followed all redirects.
+        let finalURL = response?.url ?? realURL
+        if finalURL != realURL {
+          NitroPlayerLogger.log("TrackPlayerCore", "↪️ Resolved redirect \(realURL) → \(finalURL)")
+        }
+        var redirect = URLRequest(url: finalURL)
+        self.headers(for: wrappedURL)?.forEach { redirect.setValue($1, forHTTPHeaderField: $0) }
+        loadingRequest.redirect = redirect
+        loadingRequest.response = HTTPURLResponse(
+          url: finalURL, statusCode: 302, httpVersion: "HTTP/1.1", headerFields: nil)
+        loadingRequest.finishLoading()
+      }
+    }
+    tasksByRequest[key] = task
+    task.resume()
+    return true
+  }
+
+  func resourceLoader(
+    _ resourceLoader: AVAssetResourceLoader,
+    didCancel loadingRequest: AVAssetResourceLoadingRequest
+  ) {
+    tasksByRequest.removeValue(forKey: ObjectIdentifier(loadingRequest))?.cancel()
+  }
+}

package/lib/types/PlayerQueue.d.ts

@@ -38,4 +38,5 @@ export interface PlayerConfig {
      * Higher values = more proactive loading, but more network requests
      */
     lookaheadCount?: number;
+    androidNotificationIcon?: string;
 }

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

@@ -11,6 +11,7 @@
 #include "PlayerConfig.hpp"
 
 #include <optional>
+#include <string>
 
 namespace margelo::nitro::nitroplayer {
 
@@ -39,11 +40,14 @@ namespace margelo::nitro::nitroplayer {
       jni::local_ref<jni::JBoolean> showInNotification = this->getFieldValue(fieldShowInNotification);
       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");
+      jni::local_ref<jni::JString> androidNotificationIcon = this->getFieldValue(fieldAndroidNotificationIcon);
       return PlayerConfig(
         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,
-        lookaheadCount != nullptr ? std::make_optional(lookaheadCount->value()) : std::nullopt
+        lookaheadCount != nullptr ? std::make_optional(lookaheadCount->value()) : std::nullopt,
+        androidNotificationIcon != nullptr ? std::make_optional(androidNotificationIcon->toStdString()) : std::nullopt
       );
     }
 
@@ -53,7 +57,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>);
+      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>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -61,7 +65,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.lookaheadCount.has_value() ? jni::JDouble::valueOf(value.lookaheadCount.value()) : nullptr
+        value.lookaheadCount.has_value() ? jni::JDouble::valueOf(value.lookaheadCount.value()) : nullptr,
+        value.androidNotificationIcon.has_value() ? jni::make_jstring(value.androidNotificationIcon.value()) : nullptr
       );
     }
   };

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

@@ -28,7 +28,10 @@ data class PlayerConfig(
   val showInNotification: Boolean?,
   @DoNotStrip
   @Keep
-  val lookaheadCount: Double?
+  val lookaheadCount: Double?,
+  @DoNotStrip
+  @Keep
+  val androidNotificationIcon: String?
 ) {
   /* primary constructor */
 
@@ -40,8 +43,8 @@ data class PlayerConfig(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(androidAutoEnabled: Boolean?, carPlayEnabled: Boolean?, showInNotification: Boolean?, lookaheadCount: Double?): PlayerConfig {
-      return PlayerConfig(androidAutoEnabled, carPlayEnabled, showInNotification, lookaheadCount)
+    private fun fromCpp(androidAutoEnabled: Boolean?, carPlayEnabled: Boolean?, showInNotification: Boolean?, lookaheadCount: Double?, androidNotificationIcon: String?): PlayerConfig {
+      return PlayerConfig(androidAutoEnabled, carPlayEnabled, showInNotification, lookaheadCount, androidNotificationIcon)
     }
   }
 }

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?) {
+  init(androidAutoEnabled: Bool?, carPlayEnabled: Bool?, showInNotification: Bool?, lookaheadCount: Double?, androidNotificationIcon: String?) {
     self.init({ () -> bridge.std__optional_bool_ in
       if let __unwrappedValue = androidAutoEnabled {
         return bridge.create_std__optional_bool_(__unwrappedValue)
@@ -43,6 +43,12 @@ public extension PlayerConfig {
       } else {
         return .init()
       }
+    }(), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = androidNotificationIcon {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
     }())
   }
 
@@ -93,4 +99,16 @@ public extension PlayerConfig {
       }
     }()
   }
+  
+  @inline(__always)
+  var androidNotificationIcon: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__androidNotificationIcon) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__androidNotificationIcon)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
 }

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

@@ -31,6 +31,7 @@
 
 
 #include <optional>
+#include <string>
 
 namespace margelo::nitro::nitroplayer {
 
@@ -43,10 +44,11 @@ namespace margelo::nitro::nitroplayer {
     std::optional<bool> carPlayEnabled     SWIFT_PRIVATE;
     std::optional<bool> showInNotification     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): androidAutoEnabled(androidAutoEnabled), carPlayEnabled(carPlayEnabled), showInNotification(showInNotification), lookaheadCount(lookaheadCount) {}
+    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) {}
 
   public:
     friend bool operator==(const PlayerConfig& lhs, const PlayerConfig& rhs) = default;
@@ -65,7 +67,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, "lookaheadCount")))
+        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")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitroplayer::PlayerConfig& arg) {
@@ -74,6 +77,7 @@ namespace margelo::nitro {
       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, "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;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -88,6 +92,7 @@ namespace margelo::nitro {
       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, "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.4.2",
+  "version": "1.4.4-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/types/PlayerQueue.ts

@@ -49,4 +49,6 @@ export interface PlayerConfig {
    * Higher values = more proactive loading, but more network requests
    */
   lookaheadCount?: number
+
+  androidNotificationIcon?: string
 }