react-native-queue-player 1.1.2 → 2.0.0

package/android/src/main/cpp/airplay_jni.cpp

@@ -174,14 +174,6 @@ static struct raopcl_s *toRaop(jlong handle) {
 // JNI methods
 // ---------------------------------------------------------------------------
 
-static jstring nativeVersion(JNIEnv *env, jclass) {
-    return env->NewStringUTF("libraop-0.2.0");
-}
-
-static jboolean nativeInitSsl(JNIEnv *, jclass) {
-    return cross_ssl_load() ? JNI_TRUE : JNI_FALSE;
-}
-
 /**
  * Open a RAOP session.  Returns a handle (pointer-as-long) or 0 on failure.
  *
@@ -356,34 +348,7 @@ static jint nativeRingAvailable(JNIEnv *, jclass, jlong handle) {
     return static_cast<jint>(avail);
 }
 
-// -- Legacy methods (still needed for pause/flush/volume/metadata) --
-
-static jboolean nativeAcceptFrames(JNIEnv *, jclass, jlong handle) {
-    auto *r = toRaop(handle);
-    return (r && raopcl_accept_frames(r)) ? JNI_TRUE : JNI_FALSE;
-}
-
-static jboolean nativeSendChunk(JNIEnv *env, jclass,
-                                jlong handle,
-                                jbyteArray data, jint offset, jint length) {
-    auto *r = toRaop(handle);
-    if (!r) return JNI_FALSE;
-
-    jbyte *buf = env->GetByteArrayElements(data, nullptr);
-    if (!buf) return JNI_FALSE;
-
-    uint64_t playtime = 0;
-    // Fix: length is bytes, send_chunk expects frames (bytes / 4 for stereo S16)
-    bool ok = raopcl_send_chunk(
-        r,
-        reinterpret_cast<uint8_t *>(buf + offset),
-        static_cast<int>(length / 4),
-        &playtime
-    );
-
-    env->ReleaseByteArrayElements(data, buf, JNI_ABORT);
-    return ok ? JNI_TRUE : JNI_FALSE;
-}
+// -- Transport control --
 
 static void nativePause(JNIEnv *, jclass, jlong handle) {
     auto *r = toRaop(handle);
@@ -409,6 +374,8 @@ static jboolean nativeFlush(JNIEnv *, jclass, jlong handle) {
     return (r && raopcl_flush(r)) ? JNI_TRUE : JNI_FALSE;
 }
 
+// -- Volume & progress --
+
 static jboolean nativeSetVolume(JNIEnv *, jclass, jlong handle, jfloat vol) {
     auto *r = toRaop(handle);
     return (r && raopcl_set_volume(r, vol)) ? JNI_TRUE : JNI_FALSE;
@@ -422,41 +389,20 @@ static jboolean nativeSetProgressMs(JNIEnv *, jclass, jlong handle,
         static_cast<uint32_t>(duration))) ? JNI_TRUE : JNI_FALSE;
 }
 
-static jlong nativeGetProgressMs(JNIEnv *, jclass, jlong handle) {
-    auto *r = toRaop(handle);
-    return r ? static_cast<jlong>(raopcl_get_progress_ms(r)) : 0;
-}
+// -- State queries --
 
 static jboolean nativeIsConnected(JNIEnv *, jclass, jlong handle) {
     auto *r = toRaop(handle);
     return (r && raopcl_is_connected(r)) ? JNI_TRUE : JNI_FALSE;
 }
 
-static jboolean nativeIsPlaying(JNIEnv *, jclass, jlong handle) {
-    auto *r = toRaop(handle);
-    return (r && raopcl_is_playing(r)) ? JNI_TRUE : JNI_FALSE;
-}
-
-static jint nativeGetState(JNIEnv *, jclass, jlong handle) {
-    auto *r = toRaop(handle);
-    return r ? static_cast<jint>(raopcl_state(r)) : 0;
-}
-
-static jint nativeGetLatency(JNIEnv *, jclass, jlong handle) {
-    auto *r = toRaop(handle);
-    return r ? static_cast<jint>(raopcl_latency(r)) : 0;
-}
-
-static jint nativeGetSampleRate(JNIEnv *, jclass, jlong handle) {
-    auto *r = toRaop(handle);
-    return r ? static_cast<jint>(raopcl_sample_rate(r)) : 0;
-}
-
 static jboolean nativeKeepalive(JNIEnv *, jclass, jlong handle) {
     auto *r = toRaop(handle);
     return (r && raopcl_keepalive(r)) ? JNI_TRUE : JNI_FALSE;
 }
 
+// -- Configuration --
+
 static jint nativeGetLastRtspStatus(JNIEnv *, jclass, jlong handle) {
     auto *r = toRaop(handle);
     return r ? static_cast<jint>(raopcl_last_rtsp_status(r)) : 0;
@@ -484,6 +430,8 @@ static void nativeSetPassword(JNIEnv *env, jclass, jlong handle, jstring jPasswd
     }
 }
 
+// -- Metadata --
+
 static jboolean nativeSetDaap(JNIEnv *env, jclass, jlong handle,
                               jstring jTitle, jstring jArtist, jstring jAlbum) {
     auto *r = toRaop(handle);
@@ -533,8 +481,6 @@ static jboolean nativeSetArtwork(JNIEnv *env, jclass, jlong handle,
 // RegisterNatives table
 // ---------------------------------------------------------------------------
 static const JNINativeMethod sMethods[] = {
-    {"nativeVersion",       "()Ljava/lang/String;",                 reinterpret_cast<void *>(nativeVersion)},
-    {"nativeInitSsl",       "()Z",                                  reinterpret_cast<void *>(nativeInitSsl)},
     {"nativeOpen",          "(Ljava/lang/String;IIIIIZIIIF)J",      reinterpret_cast<void *>(nativeOpen)},
     {"nativeConnect",       "(JLjava/lang/String;I)Z",              reinterpret_cast<void *>(nativeConnect)},
     {"nativeDisconnect",    "(J)Z",                                 reinterpret_cast<void *>(nativeDisconnect)},
@@ -542,19 +488,12 @@ static const JNINativeMethod sMethods[] = {
     {"nativeFeedPcm",       "(J[BII)I",                             reinterpret_cast<void *>(nativeFeedPcm)},
     {"nativeBytesSent",     "(J)J",                                 reinterpret_cast<void *>(nativeBytesSent)},
     {"nativeRingAvailable", "(J)I",                                 reinterpret_cast<void *>(nativeRingAvailable)},
-    {"nativeAcceptFrames",  "(J)Z",                                 reinterpret_cast<void *>(nativeAcceptFrames)},
-    {"nativeSendChunk",     "(J[BII)Z",                             reinterpret_cast<void *>(nativeSendChunk)},
     {"nativePause",         "(J)V",                                 reinterpret_cast<void *>(nativePause)},
     {"nativeStop",          "(J)V",                                 reinterpret_cast<void *>(nativeStop)},
     {"nativeFlush",         "(J)Z",                                 reinterpret_cast<void *>(nativeFlush)},
     {"nativeSetVolume",     "(JF)Z",                                reinterpret_cast<void *>(nativeSetVolume)},
     {"nativeSetProgressMs", "(JII)Z",                               reinterpret_cast<void *>(nativeSetProgressMs)},
-    {"nativeGetProgressMs", "(J)J",                                 reinterpret_cast<void *>(nativeGetProgressMs)},
     {"nativeIsConnected",   "(J)Z",                                 reinterpret_cast<void *>(nativeIsConnected)},
-    {"nativeIsPlaying",     "(J)Z",                                 reinterpret_cast<void *>(nativeIsPlaying)},
-    {"nativeGetState",      "(J)I",                                 reinterpret_cast<void *>(nativeGetState)},
-    {"nativeGetLatency",    "(J)I",                                 reinterpret_cast<void *>(nativeGetLatency)},
-    {"nativeGetSampleRate", "(J)I",                                 reinterpret_cast<void *>(nativeGetSampleRate)},
     {"nativeKeepalive",     "(J)Z",                                 reinterpret_cast<void *>(nativeKeepalive)},
     {"nativeGetLastRtspStatus", "(J)I",                              reinterpret_cast<void *>(nativeGetLastRtspStatus)},
     {"nativeSetPassword",   "(JLjava/lang/String;)V",               reinterpret_cast<void *>(nativeSetPassword)},
@@ -576,13 +515,22 @@ jint JNI_OnLoad(JavaVM *vm, void * /* reserved */) {
 
     jclass clazz = env->FindClass(sClassName);
     if (clazz == nullptr) {
-        __android_log_print(ANDROID_LOG_WARN, TAG,
-            "AirplayJNI class not loaded yet — RegisterNatives deferred");
-        return JNI_VERSION_1_6;
+        /* Leaves a pending NoClassDefFoundError. Clear it and fail the load
+         * outright: nothing retries registration, so reporting success here
+         * would leave the Kotlin object reporting AirPlay 1 as available with
+         * no natives bound, and the first call would throw
+         * UnsatisfiedLinkError. Failing makes System.loadLibrary throw, and
+         * AirplayJNI's initialiser catches that and sets isAvailable false. */
+        env->ExceptionClear();
+        __android_log_print(ANDROID_LOG_ERROR, TAG,
+            "AirplayJNI class not found — AirPlay 1 unavailable");
+        return JNI_ERR;
     }
 
     if (env->RegisterNatives(clazz, sMethods,
             sizeof(sMethods) / sizeof(sMethods[0])) < 0) {
+        /* An unresolved table entry leaves a pending NoSuchMethodError. */
+        env->ExceptionClear();
         __android_log_print(ANDROID_LOG_ERROR, TAG, "RegisterNatives failed");
         return JNI_ERR;
     }

package/android/src/main/java/com/margelo/nitro/queueplayer/AirPlayEngine.kt

@@ -66,10 +66,11 @@ internal class AirPlayEngine(
 
   private val playerListener = object : Player.Listener {
     override fun onPlaybackStateChanged(playbackState: Int) {
-      delegate?.onStateMaybeChanged(this@AirPlayEngine, playWhenReadyReason = null)
+      // End signal before the generic state callback, as in GaplessEngine.
       if (playbackState == Player.STATE_ENDED) {
         delegate?.onPlaybackEnded(this@AirPlayEngine)
       }
+      delegate?.onStateMaybeChanged(this@AirPlayEngine, playWhenReadyReason = null)
     }
 
     override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) {
@@ -129,15 +130,6 @@ internal class AirPlayEngine(
 
   // --- PlaybackEngine — lifecycle ---
 
-  override suspend fun prepare(
-    mediaItems: List<MediaItem>,
-    startIndex: Int,
-    startPositionMs: Long,
-  ) {
-    exoPlayer.setMediaItems(mediaItems, startIndex, startPositionMs)
-    exoPlayer.prepare()
-  }
-
   override fun release() {
     if (released) return
     released = true
@@ -168,6 +160,11 @@ internal class AirPlayEngine(
     startIndex: Int,
     startPositionMs: Long,
   ) {
+    if (items.isEmpty()) {
+      // Draining is not pausing: `playWhenReady` survives an empty playlist,
+      // so the next queue seated on this player would start on contact.
+      exoPlayer.pause()
+    }
     exoPlayer.setMediaItems(items, startIndex, startPositionMs)
     // ExoPlayer is IDLE after construction; prepare() is required before any
     // subsequent play() can take effect (mirrors GaplessEngine).
@@ -272,12 +269,6 @@ internal class AirPlayEngine(
 
   // ReplayGain absent on the AirPlay engine — interface defaults
   // (currentReplayGainData() = null, currentReplayGainActive() = false) apply.
-
-  // --- PlaybackEngine — handoff ---
-
-  override suspend fun handoff(to: PlaybackEngine, atTrackBoundary: Boolean) {
-    throw NotImplementedError("PlaybackEngine.handoff is not supported by AirPlayEngine")
-  }
 }
 
 /**

package/android/src/main/java/com/margelo/nitro/queueplayer/CacheMimeTypes.kt

@@ -3,7 +3,7 @@ package com.margelo.nitro.queueplayer
 import java.net.URI
 
 /**
- * MIME-type plumbing for the lookahead cache. Mirrors iOS's
+ * MIME-type handling for the lookahead cache. Mirrors iOS's
  * `LookaheadCache.extensionFromMimeType` / `extensionFromUrl` —
  * lets the Android cache record the same Content-Type signal so
  * Media3 can be told the format up front via

package/android/src/main/java/com/margelo/nitro/queueplayer/CastManager.kt

@@ -526,12 +526,8 @@ class CastManager : HybridCastManagerSpec() {
     }
     airplayScope.launch {
       try {
-        val session = backend.submitPairingPin(pin)
-        val pendingId = activeAirplaySession.get()?.let { /* keep existing */ null }
-        val receiverId = pendingId ?: lastConnectedAirplayReceiverId() ?: ""
-        if (receiverId.isNotEmpty()) {
-          installAirplaySession(session, receiverId)
-        }
+        val paired = backend.submitPairingPin(pin)
+        installAirplaySession(paired.session, paired.receiverId)
         promise.resolve(Unit)
       } catch (t: Throwable) {
         promise.reject(t)
@@ -540,14 +536,6 @@ class CastManager : HybridCastManagerSpec() {
     return promise
   }
 
-  /// Look up the most recently visible AirPlay receiver that pair-setup
-  /// would have stashed against. The pending pair's receiverId isn't
-  /// directly accessible from the public backend surface; lookup via
-  /// the discovered snapshot is good enough — the user pairs the device
-  /// they just saw in the picker.
-  private fun lastConnectedAirplayReceiverId(): String? =
-    airplayReceivers.firstOrNull()?.id
-
   override fun getLocalNetworkPermissionState(): CastLocalNetworkPermission =
     localNetworkPermissionState()
 

package/android/src/main/java/com/margelo/nitro/queueplayer/CellularTransportMonitor.kt

@@ -0,0 +1,77 @@
+package com.margelo.nitro.queueplayer
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+
+/**
+ * Reports whether the default network is cellular, and fires when that
+ * changes.
+ *
+ * Prefetch downloads whole upcoming tracks, so a consumer that has turned
+ * `allowsCellularAccess` off needs the window to empty the moment the device
+ * hands off to cellular — otherwise a download started on Wi-Fi keeps pulling
+ * over the metered link until some unrelated event reschedules. Reading the
+ * transport per reschedule instead would put a synchronous binder call on the
+ * app looper on every skip and track advance.
+ *
+ * A VPN carries its underlying network's transports alongside `TRANSPORT_VPN`,
+ * so a cellular-backed VPN still reads as cellular here.
+ *
+ * Unknown connectivity reads as not-cellular, so a missing service or a
+ * revoked callback never silently stops prefetch.
+ */
+internal class CellularTransportMonitor(private val context: Context) {
+
+  /**
+   * Fired when [isOnCellular] flips, on the ConnectivityManager callback
+   * thread — a listener that touches main-confined state has to hop.
+   */
+  var onTransportChanged: (() -> Unit)? = null
+
+  @Volatile
+  var isOnCellular: Boolean = false
+    private set
+
+  private var registered = false
+
+  private val callback = object : ConnectivityManager.NetworkCallback() {
+    override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) {
+      update(caps.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR))
+    }
+
+    override fun onLost(network: Network) {
+      update(false)
+    }
+  }
+
+  fun start() {
+    if (registered) return
+    val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
+      ?: return
+    // The registration can throw (`TooManyRequestsException` once a process
+    // holds 100 callbacks); prefetch then runs without cellular awareness
+    // rather than `configure()` failing.
+    if (runCatching { cm.registerDefaultNetworkCallback(callback) }.isFailure) return
+    registered = true
+    // Seed from the active network: the first reschedule can land before the
+    // first callback does.
+    val caps = cm.activeNetwork?.let { cm.getNetworkCapabilities(it) }
+    isOnCellular = caps?.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) == true
+  }
+
+  fun stop() {
+    if (!registered) return
+    val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
+    registered = false
+    isOnCellular = false
+    cm?.let { runCatching { it.unregisterNetworkCallback(callback) } }
+  }
+
+  private fun update(onCellular: Boolean) {
+    if (onCellular == isOnCellular) return
+    isOnCellular = onCellular
+    onTransportChanged?.invoke()
+  }
+}