react-native-queue-player 1.0.0

package/android/build.gradle

@@ -0,0 +1,257 @@
+buildscript {
+  ext.QueuePlayer = [
+    kotlinVersion: "2.1.21",
+    media3Version: "1.10.0",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return QueuePlayer[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/queueplayer+autolinking.gradle'
+
+apply plugin: "com.facebook.react"
+
+// Native .so's the consuming React Native app already ships — kept out of the
+// published AAR so the consumer's copies win (avoids duplicate-.so merge
+// conflicts). The self-instrumenting androidTest APK has no host app, so it
+// must keep its own libc++_shared.so (our native libs link against it); the
+// androidComponents block below re-includes it for that variant only.
+def consumerProvidedNativeLibs = [
+  "**/libc++_shared.so",
+  "**/libfbjni.so",
+  "**/libjsi.so",
+  "**/libfolly_json.so",
+  "**/libfolly_runtime.so",
+  "**/libglog.so",
+  "**/libhermes.so",
+  "**/libhermes-executor-debug.so",
+  "**/libhermes_executor.so",
+  "**/libreactnative.so",
+  "**/libreactnativejni.so",
+  "**/libturbomodulejsijni.so",
+  "**/libreact_nativemodule_core.so",
+  "**/libjscexecutor.so"
+]
+def resourceExcludes = ["META-INF", "META-INF/**"]
+
+android {
+  namespace "com.margelo.nitro.queueplayer"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+    testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = resourceExcludes + consumerProvidedNativeLibs
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation project(":react-native-nitro-modules")
+
+  // Media3 ExoPlayer — Android audio engine. Pinned to 1.10.0 (current
+  // stable, Mar 2026). 1.10 keeps cache + audio/wake-lock APIs stable
+  // and only deprecates MetadataRetriever (we don't use it).
+  implementation "androidx.media3:media3-exoplayer:${getExtOrDefault('media3Version')}"
+
+  // Lookahead cache: SimpleCache + LRU evictor live in media3-datasource;
+  // StandaloneDatabaseProvider lives in media3-database. Both are pulled
+  // transitively by media3-exoplayer today but declared explicitly so
+  // the dependency surface is self-documenting and survives a future
+  // media3-exoplayer slim-down.
+  implementation "androidx.media3:media3-datasource:${getExtOrDefault('media3Version')}"
+  implementation "androidx.media3:media3-database:${getExtOrDefault('media3Version')}"
+
+  // MediaSession + MediaSessionService — foreground-service playback
+  // with system-driven media-style notification, plus the bridge to
+  // external controllers (Android Auto, Wear, Assistant, hardware
+  // media buttons) via the standard MediaSessionService action.
+  implementation "androidx.media3:media3-session:${getExtOrDefault('media3Version')}"
+
+  // CastPlayer: a Player backed by the Cast SDK RemoteMediaClient. Bound
+  // as the MediaSession's player during a Chromecast session so the
+  // system media notification + lockscreen follow the receiver's
+  // metadata/transport. Reads the receiver queue via a MediaItemConverter.
+  implementation "androidx.media3:media3-cast:${getExtOrDefault('media3Version')}"
+
+  // Proactive lookahead writer: CacheWriter is dispatched on a coroutine
+  // scope so prefetch + cancellation play nicely with queue mutation
+  // churn. coroutines-android is pulled transitively by RN today;
+  // explicit declaration keeps the dependency surface honest.
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2"
+
+  // Cast — local HTTP server for Chromecast / future DLNA / Sonos
+  // backends to stream consumer-supplied `file://` URLs (offline
+  // content the host app downloaded). Not related to the lookahead
+  // cache (which stays fully native, simple, and streaming-focused).
+  // Ktor CIO is the smallest viable embedded HTTP server with
+  // proper Range / HEAD / Content-Length support.
+  implementation "io.ktor:ktor-server-core:3.2.3"
+  implementation "io.ktor:ktor-server-cio:3.2.3"
+  implementation "io.ktor:ktor-server-partial-content:3.2.3"
+  implementation "io.ktor:ktor-server-auto-head-response:3.2.3"
+
+  // Cast — Google Cast SDK + MediaRouter (used for both Cast
+  // discovery and the picker surface). mediarouter 1.8.0-beta01
+  // explicitly pinned: Cast 22.x rebased on new connect/disconnect
+  // APIs that the stable 1.7.x mediarouter doesn't expose.
+  implementation "com.google.android.gms:play-services-cast-framework:22.3.1"
+  implementation "androidx.mediarouter:mediarouter:1.8.1"
+
+  // AirPlay — self-installing backend via androidx.startup
+  // `InitializationProvider`; the AAR's mere presence on the classpath
+  // causes discovery to be available without host-app setup.
+  implementation "androidx.startup:startup-runtime:1.2.0"
+
+  // AirPlay — process-lifecycle observer pauses NSD discovery while the
+  // app is fully backgrounded so multicast scans don't burn battery.
+  // Pinned to 2.8.7 — 2.10's stricter `LifecycleRegistry` rejection
+  // ("State is 'DESTROYED' and cannot be moved to 'CREATED'") fires
+  // inside Robolectric 4.11.1's `ServiceController.destroy()` because
+  // `MediaSessionService`'s `ServiceLifecycleDispatcher` posts a
+  // post-super ON_STOP runnable AFTER the test driver has already
+  // moved the lifecycle to DESTROYED. The failure is in the
+  // Robolectric/lifecycle interop, not our code (our PlaybackService
+  // extends MediaLibraryService, not LifecycleService, and we never
+  // push our own LifecycleRegistry transitions). Re-attempt after
+  // bumping Robolectric to a release with explicit 2.10+ ServiceController
+  // support.
+  implementation "androidx.lifecycle:lifecycle-process:2.8.7"
+  implementation "androidx.lifecycle:lifecycle-common:2.8.7"
+
+  // JUnit + Robolectric test stack. Unit tests for pure Kotlin logic
+  // go under src/test/java/; instrumentation tests (if/when we add
+  // them) go under src/androidTest/java/.
+  testImplementation "junit:junit:4.13.2"
+  testImplementation "org.robolectric:robolectric:4.11.1"
+  testImplementation "androidx.test.ext:junit:1.1.5"
+  testImplementation "androidx.test:core:1.5.0"
+  // Coroutines test scaffolding: TestScope + advanceUntilIdle for the
+  // LookaheadCacheWriter orchestration tests.
+  testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.2"
+
+  // Instrumented tests (src/androidTest/java/) run on a device/emulator —
+  // the only place the native .so can be loaded + the JNI exercised.
+  androidTestImplementation "androidx.test.ext:junit:1.1.5"
+  androidTestImplementation "androidx.test:runner:1.5.2"
+}
+
+android {
+  testOptions {
+    unitTests {
+      includeAndroidResources = true
+    }
+  }
+}
+
+// Robolectric Test task hardening: disable Gradle's task-output cache
+// + up-to-date check on every Test task in this module. Without this,
+// a flaky-but-passed run can be replayed from cache on subsequent
+// invocations, hiding the real signal. The pair is required:
+//   - `outputs.upToDateWhen { false }` defeats the incremental skip.
+//   - `outputs.cacheIf { false }` defeats the build-cache replay
+//     for both local + remote (org) build caches.
+// Both are needed because Gradle's two reuse mechanisms (incremental
+// up-to-date + cross-machine build cache) are independent gates.
+//
+// `tasks.withType(Test).configureEach` matches `org.gradle.api.tasks
+// .testing.Test` (JVM/Robolectric) ONLY — AGP's
+// `DeviceProviderInstrumentTestTask` (connectedAndroidTest) is a
+// different supertype and is unaffected. Downstream consumers who
+// run `:react-native-queue-player:test` under their own remote build
+// cache will always get a full rerun rather than a cache replay;
+// acceptable cost for a deterministic test signal.
+tasks.withType(Test).configureEach {
+  outputs.upToDateWhen { false }
+  outputs.cacheIf { false }
+}
+
+// The androidTest APK self-instruments (no host RN app), so it must ship the
+// libc++_shared.so our native libs link against — otherwise dlopen fails with
+// UnsatisfiedLinkError on the device. Re-include it for the androidTest
+// component only; the published AAR keeps excluding it (consumer provides it).
+androidComponents {
+  onVariants(selector().all()) { variant ->
+    def test = variant.androidTest
+    if (test != null) {
+      test.packaging.jniLibs.excludes.set(consumerProvidedNativeLibs - ["**/libc++_shared.so"])
+      test.packaging.resources.excludes.set(resourceExcludes)
+      test.packaging.jniLibs.pickFirsts.add("**/libc++_shared.so")
+    }
+  }
+}

package/android/src/androidTest/java/com/margelo/nitro/queueplayer/SignalsmithStretchNativeTest.kt

@@ -0,0 +1,136 @@
+package com.margelo.nitro.queueplayer
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.math.PI
+import kotlin.math.abs
+import kotlin.math.sin
+
+/**
+ * On-device smoke test for the Signalsmith Stretch JNI binding. Runs on a
+ * device/emulator — the native .so cannot be loaded on the JVM, so this is an
+ * instrumented test, not Robolectric. Proves the library loads, a stretcher
+ * can be created, and process()/flush() honour the requested frame counts and
+ * produce audible output.
+ */
+@RunWith(AndroidJUnit4::class)
+class SignalsmithStretchNativeTest {
+
+  private val sampleRate = 48000f
+  private val channels = 2
+
+  private fun directFloatBuffer(frames: Int): ByteBuffer =
+    ByteBuffer.allocateDirect(frames * channels * 4).order(ByteOrder.nativeOrder())
+
+  // Fill `buf` with `frames` of a stereo 440 Hz sine at amplitude 0.5.
+  private fun fillSine(buf: ByteBuffer, frames: Int) {
+    val floats = buf.asFloatBuffer()
+    for (i in 0 until frames) {
+      val s = (0.5 * sin(2.0 * PI * 440.0 * i / sampleRate)).toFloat()
+      floats.put(i * channels, s)
+      floats.put(i * channels + 1, s)
+    }
+  }
+
+  // Peak absolute sample over the frame range [fromFrame, toFrame).
+  private fun maxAbs(buf: ByteBuffer, fromFrame: Int, toFrame: Int): Float {
+    val floats = buf.asFloatBuffer()
+    var peak = 0f
+    for (i in fromFrame * channels until toFrame * channels) {
+      peak = maxOf(peak, abs(floats.get(i)))
+    }
+    return peak
+  }
+
+  @Test
+  fun processAtUnityRatioProducesAudibleOutput() {
+    val n = 48000
+    val input = directFloatBuffer(n).also { fillSine(it, n) }
+    val output = directFloatBuffer(n)
+    val stretch = SignalsmithStretchNative.create(channels, sampleRate)
+    try {
+      assertEquals(n, stretch.process(input, n, output, n))
+      // The first outputLatency frames are priming; the tail is the delayed
+      // signal and must be audibly non-silent.
+      assertTrue("output tail is silent", maxAbs(output, n / 2, n) > 0.05f)
+    } finally {
+      stretch.release()
+    }
+  }
+
+  @Test
+  fun processAtStretchRatioProducesRequestedFrames() {
+    val inN = 48000
+    val outN = 72000 // 1.5x slowdown — ratio is outFrames/inFrames
+    val input = directFloatBuffer(inN).also { fillSine(it, inN) }
+    val output = directFloatBuffer(outN)
+    val stretch = SignalsmithStretchNative.create(channels, sampleRate)
+    try {
+      assertEquals(outN, stretch.process(input, inN, output, outN))
+      assertTrue("stretched tail is silent", maxAbs(output, outN / 2, outN) > 0.05f)
+    } finally {
+      stretch.release()
+    }
+  }
+
+  @Test
+  fun outputLatencyIsPositiveAndFlushDrainsTail() {
+    val n = 48000
+    val input = directFloatBuffer(n).also { fillSine(it, n) }
+    val output = directFloatBuffer(n)
+    val stretch = SignalsmithStretchNative.create(channels, sampleRate)
+    try {
+      stretch.process(input, n, output, n)
+      val latency = stretch.outputLatency()
+      assertTrue("expected positive output latency", latency > 0)
+      val tail = directFloatBuffer(latency)
+      assertEquals(latency, stretch.flush(tail, latency))
+      // The drained tail is attenuated vs the body, so use a lower floor than
+      // the process() assertions — but still meaningfully above silence.
+      assertTrue("flushed tail is silent", maxAbs(tail, 0, latency) > 0.01f)
+    } finally {
+      stretch.release()
+    }
+  }
+
+  @Test
+  fun resetAllowsReuseAfterProcessing() {
+    val n = 24000
+    val input = directFloatBuffer(n).also { fillSine(it, n) }
+    val output = directFloatBuffer(n)
+    val stretch = SignalsmithStretchNative.create(channels, sampleRate)
+    try {
+      stretch.process(input, n, output, n)
+      stretch.reset()
+      assertEquals(n, stretch.process(input, n, output, n))
+      assertTrue("post-reset output is silent", maxAbs(output, n / 2, n) > 0.05f)
+    } finally {
+      stretch.release()
+    }
+  }
+
+  @Test(expected = IllegalStateException::class)
+  fun createWithZeroChannelsThrows() {
+    SignalsmithStretchNative.create(0, sampleRate)
+  }
+
+  @Test
+  fun processRejectsUndersizedOutputBuffer() {
+    val n = 4096
+    val input = directFloatBuffer(n).also { fillSine(it, n) }
+    val tooSmall = directFloatBuffer(n / 2)
+    val stretch = SignalsmithStretchNative.create(channels, sampleRate)
+    try {
+      // Asking for n out frames into a buffer sized for n/2 must be rejected
+      // (return 0) rather than writing past the buffer.
+      assertEquals(0, stretch.process(input, n, tooSmall, n))
+    } finally {
+      stretch.release()
+    }
+  }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,173 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+  <!-- Cast requires INTERNET + ACCESS_NETWORK_STATE + ACCESS_WIFI_STATE
+       for mDNS discovery over the LAN and for the SDK to establish its
+       control channel. androidx.mediarouter also reads WiFi state. -->
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+  <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+
+  <!-- AirPlay discovery uses NsdManager (mDNS multicast). The
+       MulticastLock acquired by AirPlayDiscovery requires this permission
+       so the radio doesn't filter inbound multicast packets out of the
+       Wi-Fi receive queue while the screen is on. -->
+  <uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE" />
+
+  <!-- Android 16+ Local Network Protections: apps TARGETING SDK 37+ need
+       this runtime permission to reach LAN devices (mDNS Cast / AirPlay
+       discovery). Declared so it merges into consumer apps; below target
+       SDK 37 LAN access is unrestricted and the permission is effectively
+       granted. Host apps targeting SDK 37+ request the runtime grant from
+       their Activity, the same way they request POST_NOTIFICATIONS. -->
+  <uses-permission android:name="android.permission.ACCESS_LOCAL_NETWORK" />
+
+  <!-- ExoPlayer.setWakeMode(C.WAKE_MODE_NETWORK) holds a CPU +
+       Wifi wake lock while streaming so backgrounded playback
+       doesn't stutter on deep-sleep transitions. Consumer apps
+       will see this permission merged in from the library
+       manifest. -->
+  <uses-permission android:name="android.permission.WAKE_LOCK" />
+
+  <!-- Foreground service hosting the playback session. Required on
+       Android 14+ (API 34) per the foreground-service-types policy:
+       a media-playback service must declare both the generic
+       FOREGROUND_SERVICE permission and the typed
+       FOREGROUND_SERVICE_MEDIA_PLAYBACK permission, plus the
+       service's `android:foregroundServiceType="mediaPlayback"`. -->
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
+
+  <!-- Android 13+ (API 33): user must grant POST_NOTIFICATIONS for
+       the media-style notification to render. Consumer apps request
+       the runtime permission; the library declares the manifest
+       entry so it merges in regardless of consumer config. -->
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+  <application>
+    <!-- Android Auto descriptor pointer. Auto's `CarApiClient`
+         scans installed packages for this meta-data + reads the
+         referenced XML to decide whether to surface the app in
+         the head-unit launcher. The `media` capability is the
+         unified declaration for browsable + playable audio
+         (no separate "media library" capability exists). Phone-
+         projected Auto only — AAOS uses a separate
+         `com.android.automotive` meta-data + descriptor that the
+         lib does NOT declare. -->
+    <meta-data
+        android:name="com.google.android.gms.car.application"
+        android:resource="@xml/automotive_app_desc" />
+
+    <!-- PlaybackService owns the ExoPlayer + MediaLibrarySession.
+         Bound in-process by TrackPlayer (the Nitro Hybrid) via
+         ACTION_LOCAL_BIND. Cross-process bindings:
+
+           - androidx.media3.session.MediaLibraryService — the
+             primary action for Media3-aware controllers (Android
+             Auto, Assistant) that want browse + search.
+           - android.media.browse.MediaBrowserService — legacy
+             platform API that some Bluetooth car kits (older
+             head units) still use as a fallback discovery
+             mechanism. Not deprecated.
+           - android.intent.action.MEDIA_BUTTON — OS-routed media-
+             key intents when the MediaButtonReceiver below forwards
+             them, OR when the OS starts the service directly on a
+             hardware media-key press from a deep-sleep state.
+
+         The `androidx.media3.session.MediaSessionService` action is
+         intentionally NOT declared. MediaLibraryService extends
+         MediaSessionService so the service resolves either action,
+         but per androidx/media#1774 maintainer thread declaring both
+         can cause Android Auto's bind probe to resolve via MSS
+         first + see a connection without library commands, which
+         logs `MediaBrowserService: No root for client` and triggers
+         a bind/unbind retry storm. Sticking to the MLS action +
+         legacy MediaBrowserService is the canonical pattern per
+         the androidx/media#1774 maintainer guidance.
+
+         exported=true is required for cross-process binders
+         (system controllers + the receiver path) to reach the
+         service. -->
+    <service
+        android:name="com.margelo.nitro.queueplayer.PlaybackService"
+        android:foregroundServiceType="mediaPlayback"
+        android:exported="true">
+      <intent-filter>
+        <action android:name="androidx.media3.session.MediaLibraryService" />
+        <action android:name="android.media.browse.MediaBrowserService" />
+        <action android:name="android.intent.action.MEDIA_BUTTON" />
+      </intent-filter>
+    </service>
+
+    <!-- Exported ContentProvider that serves locally-cached artwork
+         files (`file://` URIs on the phone's private storage) to
+         cross-process media controllers — Android Auto's gearhead,
+         Wear, Assistant. Without this, AA's Now Playing surface
+         renders a blank cover for any TrackItem whose artworkUrl is
+         a private `file://`: gearhead's ContentResolver runs in a
+         different process and Media3 does not currently issue URI
+         permission grants for connected controllers (androidx/media
+         issue #2331). The provider exposes each locally-cached
+         file via a stable `content://` token URI that gearhead can
+         read with the auto-granted URI permission.
+
+         The authority is templated per consumer app via
+         `${applicationId}` so multiple RNQP-using apps on the same
+         device don't conflict. -->
+    <provider
+        android:name="com.margelo.nitro.queueplayer.ArtworkContentProvider"
+        android:authorities="${applicationId}.rnqp.artwork"
+        android:exported="true"
+        android:grantUriPermissions="true" />
+
+    <!-- Manifest-registered MediaButtonReceiver routes hardware media
+         keys, Bluetooth/AVRCP transport, and lock-screen tile presses
+         to PlaybackService when the app is not in the foreground or
+         the service has been killed. Media3 starts the service as a
+         foreground service and forwards the key event as
+         ACTION_MEDIA_BUTTON; the service consumes it through the
+         media-button dispatch path. Requires the
+         MediaSession.Callback#onPlaybackResumption override the
+         service installs so resumption succeeds when no session is
+         currently bound. -->
+    <receiver
+        android:name="androidx.media3.session.MediaButtonReceiver"
+        android:exported="true">
+      <intent-filter>
+        <action android:name="android.intent.action.MEDIA_BUTTON" />
+      </intent-filter>
+    </receiver>
+
+    <!-- Cast SDK reflectively instantiates ChromecastOptionsProvider
+         via this meta-data the first time `CastContext.getSharedInstance`
+         is called. Required — without it, getSharedInstance throws. -->
+    <meta-data
+        android:name="com.google.android.gms.cast.framework.OPTIONS_PROVIDER_CLASS_NAME"
+        android:value="com.margelo.nitro.queueplayer.cast.chromecast.ChromecastOptionsProvider" />
+
+    <!-- MediaTransferReceiver — required by Cast SDK 21+ for the
+         Stream Transfer / output-switcher surface on Android 13+.
+         tools:node="merge" coexists with host-app declarations. -->
+    <receiver
+        android:name="androidx.mediarouter.media.MediaTransferReceiver"
+        android:exported="false"
+        tools:node="merge" />
+
+    <!-- androidx.startup InitializationProvider — runs the AirPlay
+         backend initializer at process start. AirPlayBackendInitializer
+         registers AirPlayBackend with CastBackends and installs the
+         ProcessLifecycleOwner observer that pauses NSD discovery while
+         backgrounded. tools:node="merge" coexists with the consumer
+         app's own InitializationProvider meta-data list. -->
+    <provider
+        android:name="androidx.startup.InitializationProvider"
+        android:authorities="${applicationId}.androidx-startup"
+        android:exported="false"
+        tools:node="merge">
+      <meta-data
+          android:name="com.margelo.nitro.queueplayer.cast.airplay.AirPlayBackendInitializer"
+          android:value="androidx.startup" />
+    </provider>
+  </application>
+
+</manifest>