react-native-audio-browser 0.2.0-next.1 → 0.2.0-next.10

package/README.md

@@ -66,8 +66,8 @@ AudioBrowser.configureBrowser({
   tabs: [{ title: 'Browse', url: '/browse' }],
   routes: {
     // Every path under /browse is fetched from your API, on demand.
-    '/browse/**': { baseUrl: 'https://api.example.com' },
-  },
+    '/browse/**': { baseUrl: 'https://api.example.com' }
+  }
 })
 ```
 
@@ -79,7 +79,7 @@ Each route returns a page of children — a child with a `url` is browsable (ope
   "url": "/browse/jazz",
   "title": "Jazz",
   "children": [
-    { "title": "Smooth Floret FM", "url": "/browse/jazz/floret-fm" },           // url → open for children
+    { "title": "Smooth Floret FM", "url": "/browse/jazz/floret-fm" }, // url → open for children
     { "title": "The Stalk 88.5", "src": "https://stream.example.com/stalk.mp3" } // src → play this stream
   ]
 }
@@ -91,7 +91,9 @@ The player works standalone, too — no browse tree required:
 import AudioBrowser from 'react-native-audio-browser'
 
 await AudioBrowser.setupPlayer()
-AudioBrowser.setQueue([{ title: 'Track', artist: 'Artist', src: 'https://example.com/track.mp3' }])
+AudioBrowser.setQueue([
+  { title: 'Track', artist: 'Artist', src: 'https://example.com/track.mp3' }
+])
 AudioBrowser.play()
 ```
 
@@ -99,16 +101,16 @@ AudioBrowser.play()
 
 Reactive hooks for your in-app UI — they update automatically as playback, the queue, and browse state change. Call `setupPlayer()` once at startup, before rendering any component that uses them.
 
-| Hook | Returns |
-| --- | --- |
-| `usePlayingState()` | `{ playing, buffering }` |
-| `useProgress()` | `{ position, duration, buffered }` (seconds) |
-| `useActiveTrack()` | the current `Track` |
-| `useNowPlaying()` | now-playing metadata |
-| `useQueue()` | the current queue |
-| `useRepeatMode()` / `useShuffle()` | repeat / shuffle state |
-| `useSleepTimer()` | sleep-timer state |
-| `useCarConnected()` | whether a car is connected |
+| Hook                                       | Returns                                                              |
+| ------------------------------------------ | -------------------------------------------------------------------- |
+| `usePlayingState()`                        | `{ playing, buffering }`                                             |
+| `useProgress()`                            | `{ position, duration, buffered }` (seconds)                         |
+| `useActiveTrack()`                         | the current `Track`                                                  |
+| `useNowPlaying()`                          | now-playing metadata                                                 |
+| `useQueue()`                               | the current queue                                                    |
+| `useRepeatMode()` / `useShuffle()`         | repeat / shuffle state                                               |
+| `useSleepTimer()`                          | sleep-timer state                                                    |
+| `useCarConnected()`                        | whether a car is connected                                           |
 | `usePath()` / `useTabs()` / `useContent()` | current browse path, tabs, and the resolved page at the current path |
 
 …and more — see the [Hooks guide](https://audiobrowser.dev/guide/hooks) and the [API Reference](https://audiobrowser.dev/api/).
@@ -118,18 +120,20 @@ import { View, Text, Button } from 'react-native'
 import AudioBrowser, {
   usePlayingState,
   useProgress,
-  useActiveTrack,
+  useActiveTrack
 } from 'react-native-audio-browser'
 
 function PlayerBar() {
-  const { playing } = usePlayingState()        // { playing, buffering }
+  const { playing } = usePlayingState() // { playing, buffering }
   const { position, duration } = useProgress() // in seconds
-  const track = useActiveTrack()               // Track | undefined
+  const track = useActiveTrack() // Track | undefined
 
   return (
     <View>
       <Text>{track?.title}</Text>
-      <Text>{Math.floor(position)} / {Math.floor(duration)}s</Text>
+      <Text>
+        {Math.floor(position)} / {Math.floor(duration)}s
+      </Text>
       <Button
         title={playing ? 'Pause' : 'Play'}
         onPress={() => AudioBrowser.togglePlayback()}

package/android/build.gradle

@@ -33,13 +33,19 @@ if (isNewArchitectureEnabled()) {
   apply plugin: "com.facebook.react"
 }
 
-ktfmt {  googleStyle()
+ktfmt {
+  googleStyle()
 }
 
 tasks.register("format") {
   dependsOn "ktfmtFormat"
 }
 
+// Fails instead of rewriting — what CI runs.
+tasks.register("formatCheck") {
+  dependsOn "ktfmtCheck"
+}
+
 def getExtOrDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["AudioBrowser_" + name]
 }
@@ -168,14 +174,10 @@ dependencies {
   implementation "androidx.core:core-ktx:1.13.1"
   // CarConnection: the documented Android Auto / Automotive connection signal
   implementation "androidx.car.app:app:1.4.0"
-  implementation "androidx.localbroadcastmanager:localbroadcastmanager:1.1.0"
   implementation "androidx.lifecycle:lifecycle-process:2.8.6"
   implementation 'androidx.media:media:1.7.0'
 
   implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.6")
-  implementation("androidx.activity:activity-compose:1.9.3")
-  implementation("androidx.compose.ui:ui")
-  implementation("androidx.compose.ui:ui-graphics")
 
   // Media3 dependencies for audio playback.
   // Version is configurable via rootProject.ext.media3Version or AudioBrowser_media3Version

package/android/gradle.properties

@@ -1,6 +1,6 @@
 AudioBrowser_kotlinVersion=2.1.20
 AudioBrowser_minSdkVersion=23
 AudioBrowser_targetSdkVersion=35
-AudioBrowser_compileSdkVersion=34
+AudioBrowser_compileSdkVersion=35
 AudioBrowser_ndkVersion=27.1.12297006
 AudioBrowser_media3Version=1.10.1

package/android/src/main/AndroidManifest.xml

@@ -23,7 +23,9 @@
                 <action android:name="androidx.media3.session.MediaSessionService" />
             </intent-filter>
 
-            <!-- For Android Auto support -->
+            <!-- Voice "play <query>". Any app can send it, but that is a subset of what an
+                 unauthenticated MediaController already has: onConnect admits everyone.
+                 Restrict connections there, not here. -->
             <intent-filter>
                 <action android:name="android.media.action.MEDIA_PLAY_FROM_SEARCH" />
                 <category android:name="android.intent.category.DEFAULT" />

package/android/src/main/java/com/audiobrowser/AudioBrowser.kt

@@ -84,14 +84,15 @@ import com.margelo.nitro.audiobrowser.Track
 import com.margelo.nitro.audiobrowser.TrackMetadata
 import com.margelo.nitro.core.Promise
 import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
 import kotlin.coroutines.suspendCoroutine
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.cancelChildren
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import timber.log.Timber
@@ -100,10 +101,54 @@ import timber.log.Timber
 @DoNotStrip
 class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
 
-  /** Called by Nitro when the JS object is destroyed (incl. JS runtime reloads). */
+  /**
+   * Nitro calls this only when JS calls `dispose()` explicitly — never on runtime teardown, which
+   * is what [AudioBrowserLifecycleModule] is for. Both routes land here.
+   *
+   * The Service outlives this object, so everything registered in `init` or on connect has to be
+   * undone. Left alone, the running [Player] goes on invoking callbacks into a dead JSI runtime,
+   * and every reload strands another ServiceConnection and lifecycle observer, each retaining a
+   * BrowserManager.
+   *
+   * Runs the teardown on main: the state below is written from main-thread coroutines
+   * ([onServiceConnected], [onServiceDisconnected]), while dispose itself arrives on the JS thread
+   * or the teardown callback's thread.
+   */
   override fun dispose() {
+    current.compareAndSet(this, null)
     systemVolumeMonitor.destroy()
     outputMonitor.destroy()
+    // Only when still ours: on a reload the replacement may already own the slot.
+    carConnectionTarget.compareAndSet(onCarConnectedChanged, null)
+
+    handler.post {
+      connectedService?.let { service ->
+        // Identity-guarded: both instances bind to the same singleton Service, so a late dispose
+        // must not strip the wiring a replacement has already installed.
+        if (service.player.getCallbacks() === callbacks) service.player.setCallbacks(null)
+        if (service.player.browser === this) {
+          service.player.browser = null
+          service.player.forgetBrowserRegistration()
+        }
+        if (service.onBatteryWarningPendingChanged === onBatteryWarningPending) {
+          service.onBatteryWarningPendingChanged = null
+        }
+      }
+      connectedService = null
+
+      // Dropping the reference disconnects nothing — the controller stays in the session's
+      // connected list, holding a binder and a listener.
+      mediaBrowserFuture?.let { MediaBrowser.releaseFuture(it) }
+      mediaBrowserFuture = null
+      setupPromise = null
+
+      serviceBinding.unbind(this)
+
+      ProcessLifecycleOwner.get().lifecycle.removeObserver(lifecycleObserver)
+      // After the observer removal, so this post is not the one dropped.
+      handler.removeCallbacksAndMessages(null)
+      mainScope.cancel()
+    }
     super.dispose()
   }
 
@@ -150,6 +195,13 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
   private var mediaBrowserFuture: ListenableFuture<MediaBrowser>? = null
   private var setupOptions = PlayerSetupOptions()
   private var connectedService: Service? = null
+
+  private val serviceBinding = ServiceBinding(context)
+
+  /** Held rather than inlined so [dispose] can tell its own wiring from a replacement's. */
+  private val onBatteryWarningPending: (Boolean) -> Unit = { pending ->
+    post { onBatteryWarningPendingChanged(BatteryWarningPendingChangedEvent(pending)) }
+  }
   private var setupPromise: ((Unit) -> Unit)? = null
 
   // Initial player state staged before the player exists — from setup options or the imperative
@@ -239,12 +291,14 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
     }
 
   init {
+    current.set(this)
+
     // Auto-bind to service if it's already running
     launchInScope {
       try {
         Timber.d("Attempting to auto-bind to existing AudioBrowserService from AudioBrowser")
         val intent = Intent(context, Service::class.java)
-        val bound = context.bindService(intent, this@AudioBrowser, Context.BIND_AUTO_CREATE)
+        val bound = serviceBinding.bind(intent, this@AudioBrowser)
         Timber.d("Auto-bind result: $bound")
 
         if (!bound) {
@@ -659,7 +713,7 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
       }
   }
 
-  override fun onSearch(query: String): Promise<Array<Track>> {
+  override fun search(query: String): Promise<Array<Track>> {
     return Promise.async(mainScope) {
       Timber.d("Searching for: $query")
       val searchResults = browserManager.search(query)
@@ -781,7 +835,7 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
   override var onCarConnectedChanged: (Boolean) -> Unit = {}
     set(value) {
       field = value
-      carConnectionTarget = value
+      carConnectionTarget.set(value)
       // Immediately notify current state (the car may have connected before
       // this JS runtime subscribed) — mirrors the iOS behavior.
       value(carConnected)
@@ -811,12 +865,7 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
       // Service not connected yet, bind to service
       suspendCoroutine<Unit> { continuation ->
         Timber.d("Binding to AudioBrowserService")
-        val bound =
-          context.bindService(
-            Intent(context, Service::class.java),
-            this@AudioBrowser,
-            Context.BIND_AUTO_CREATE,
-          )
+        val bound = serviceBinding.bind(Intent(context, Service::class.java), this@AudioBrowser)
 
         if (!bound) {
           continuation.resumeWithException(
@@ -852,7 +901,6 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
 
   override fun reset() = runBlockingOnMain {
     player.stop()
-    delay(300) // Allow playback to stop
     player.clear()
     // clear() while IDLE emits no engine event, so the state machine never
     // leaves STOPPED — a reset queue is "nothing loaded".
@@ -1175,13 +1223,7 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
         }
 
       // Wire up battery warning callback from service
-      connectedService?.onBatteryWarningPendingChanged = { pending ->
-        post {
-          this@AudioBrowser.onBatteryWarningPendingChanged(
-            BatteryWarningPendingChangedEvent(pending)
-          )
-        }
-      }
+      connectedService?.onBatteryWarningPendingChanged = onBatteryWarningPending
 
       val sessionToken = SessionToken(context, ComponentName(context, Service::class.java))
       mediaBrowserFuture = MediaBrowser.Builder(context, sessionToken).buildAsync()
@@ -1436,9 +1478,22 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
     // callback registers as the single notification target (mirrors the iOS
     // static + shared-instance pattern).
     @Volatile private var carConnected = false
-    @Volatile private var carConnectionTarget: ((Boolean) -> Unit)? = null
+    // Compare-and-set, not @Volatile: a disposing instance clears the slot only if it still owns
+    // it, and a replacement may be claiming it at the same moment.
+    private val carConnectionTarget = AtomicReference<((Boolean) -> Unit)?>(null)
     private var carConnectionObserverStarted = false
 
+    /**
+     * The instance the current JS runtime is using. Nitro hands out no registry, and the teardown
+     * callback has nothing to dispose without one.
+     */
+    private val current = AtomicReference<AudioBrowser?>(null)
+
+    /** Called by [AudioBrowserLifecycleModule] when the React instance is torn down. */
+    internal fun disposeCurrent() {
+      current.getAndSet(null)?.dispose()
+    }
+
     private fun startCarConnectionObserver(context: Context, handler: Handler) {
       // Posted to main: LiveData observation is main-thread only, and the
       // single-start guard is then only ever touched from one thread.
@@ -1449,7 +1504,7 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
           val connected = type != CarConnection.CONNECTION_TYPE_NOT_CONNECTED
           if (connected == carConnected) return@observeForever
           carConnected = connected
-          carConnectionTarget?.invoke(connected)
+          carConnectionTarget.get()?.invoke(connected)
         }
       }
     }

package/android/src/main/java/com/audiobrowser/AudioBrowserLifecycleModule.kt

@@ -0,0 +1,38 @@
+package com.audiobrowser
+
+import com.facebook.react.bridge.BaseJavaModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.turbomodule.core.interfaces.TurboModule
+import timber.log.Timber
+
+/**
+ * Tears the live [AudioBrowser] down when the React instance goes away.
+ *
+ * Nitro's `dispose()` is reachable only from an explicit `dispose()` call in JS — it is *not* run
+ * when the runtime is destroyed. Without this, a reload leaves the previous instance registered
+ * with the Service, the process lifecycle and the car-connection observer, so it stays reachable
+ * (and keeps receiving player callbacks over a dead JSI runtime) forever.
+ *
+ * [invalidate] is what React Native calls on instance teardown, so it is the hook that actually
+ * fires. The module exists only for that callback and exposes nothing to JS, so it has to be
+ * created without JS ever asking for it: `TurboModuleManager.invalidate` only invalidates modules
+ * in its holder map, and under bridgeless a module reaches that map eagerly only if it is *both*
+ * `needsEagerInit` and `isTurboModule`
+ * (`ReactPackageTurboModuleManagerDelegate.getEagerInitModuleNames`). Hence the marker interface —
+ * a plain legacy module is created solely on request from JS, which for this one never comes.
+ */
+internal class AudioBrowserLifecycleModule(reactContext: ReactApplicationContext) :
+  BaseJavaModule(reactContext), TurboModule {
+
+  override fun getName(): String = NAME
+
+  override fun invalidate() {
+    Timber.d("React instance going away — disposing the live AudioBrowser")
+    AudioBrowser.disposeCurrent()
+    super.invalidate()
+  }
+
+  companion object {
+    const val NAME: String = "AudioBrowserLifecycle"
+  }
+}

package/android/src/main/java/com/audiobrowser/AudioBrowserPackage.kt

@@ -3,14 +3,30 @@ package com.audiobrowser
 import com.facebook.react.TurboReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.margelo.nitro.audiobrowser.AudioBrowserOnLoad
 
 public class AudioBrowserPackage : TurboReactPackage() {
-  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+    if (name == AudioBrowserLifecycleModule.NAME) AudioBrowserLifecycleModule(reactContext)
+    else null
 
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
-    emptyMap()
+    mapOf(
+      AudioBrowserLifecycleModule.NAME to
+        ReactModuleInfo(
+          AudioBrowserLifecycleModule.NAME,
+          AudioBrowserLifecycleModule::class.java.name,
+          false, // canOverrideExistingModule
+          // Eager + TurboModule: nothing in JS imports this module, and its only job is the
+          // teardown callback, which never arrives if the module is never created. Both flags are
+          // required for that — see the note on the module.
+          true, // needsEagerInit
+          false, // isCxxModule
+          ReactModuleInfo.classIsTurboModule(AudioBrowserLifecycleModule::class.java),
+        )
+    )
   }
 
   companion object {

package/android/src/main/java/com/audiobrowser/ServiceBinding.kt

@@ -0,0 +1,48 @@
+package com.audiobrowser
+
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import timber.log.Timber
+
+/**
+ * Exactly-once bookkeeping for a [ServiceConnection].
+ *
+ * `bindService` may be called from more than one place — an auto-bind at construction and again
+ * from setup — but the binding must be released exactly once, and only if one was ever taken:
+ * [Context.unbindService] throws when the connection was never registered. Kept apart from the
+ * caller so the rule is one object's job, and so it can be tested without a JSI runtime.
+ */
+internal class ServiceBinding(private val context: Context) {
+
+  @Volatile
+  var isBound: Boolean = false
+    private set
+
+  /**
+   * Binds if not already bound, and returns whether a binding is held afterwards. A second call
+   * while bound is a no-op: Android would otherwise count the extra bind and expect a matching
+   * unbind.
+   */
+  fun bind(intent: Intent, connection: ServiceConnection): Boolean {
+    if (isBound) return true
+    // Marked bound whatever the result: Android registers the connection before it asks the
+    // ActivityManager, so a false return still leaves one to release — "regardless of the return
+    // value, you should later call unbindService()".
+    isBound = true
+    return context.bindService(intent, connection, Context.BIND_AUTO_CREATE)
+  }
+
+  /**
+   * Releases the binding if one is held. Safe to call repeatedly, and safe when the service has
+   * already died — [onServiceDisconnected][ServiceConnection.onServiceDisconnected] means the
+   * service went away, not that the binding did, so the unbind is still required.
+   */
+  fun unbind(connection: ServiceConnection) {
+    if (!isBound) return
+    isBound = false
+    // Throws if the binding is somehow already gone, which is the outcome we wanted anyway.
+    runCatching { context.unbindService(connection) }
+      .onFailure { Timber.w(it, "unbindService failed") }
+  }
+}

package/android/src/main/java/com/audiobrowser/browser/BrowserManager.kt

@@ -1,7 +1,5 @@
 package com.audiobrowser.browser
 
-import com.audiobrowser.util.artworkOf
-
 import android.util.LruCache
 import androidx.media3.common.MediaItem
 import androidx.media3.session.MediaSession
@@ -9,6 +7,7 @@ import com.audiobrowser.http.HttpClient
 import com.audiobrowser.http.RequestConfigBuilder
 import com.audiobrowser.util.BrowserPathHelper
 import com.audiobrowser.util.TrackFactory
+import com.audiobrowser.util.artworkOf
 import com.margelo.nitro.audiobrowser.ArtworkRequestConfig
 import com.margelo.nitro.audiobrowser.BrowserSourceCallbackParam
 import com.margelo.nitro.audiobrowser.FavoritesMatchMode

package/android/src/main/java/com/audiobrowser/browser/BrowserUrlResolution.kt

@@ -1,8 +1,7 @@
 package com.audiobrowser.browser
 
-import com.audiobrowser.util.url
-
 import com.audiobrowser.http.RequestConfigBuilder
+import com.audiobrowser.util.url
 import com.margelo.nitro.audiobrowser.ArtworkRequestConfig
 import com.margelo.nitro.audiobrowser.ImageContext
 import com.margelo.nitro.audiobrowser.ImageQueryParams

package/android/src/main/java/com/audiobrowser/browser/SectionScope.kt

@@ -4,9 +4,9 @@ import com.margelo.nitro.audiobrowser.ImageRowItem
 import com.margelo.nitro.audiobrowser.Track
 
 /**
- * Queue scope is the tapped section, not the whole page (ADR 0006): the
- * playback context a listener expects is the list they tapped in — a page
- * aggregating several sections must not leak next/previous across them.
+ * Queue scope is the tapped section, not the whole page (ADR 0006): the playback context a listener
+ * expects is the list they tapped in — a page aggregating several sections must not leak
+ * next/previous across them.
  */
 object SectionScope {
   sealed class Section {
@@ -14,15 +14,14 @@ object SectionScope {
     data class ImageRow(val items: List<ImageRowItem>) : Section()
 
     /**
-     * The contiguous `groupTitle` run around the tapped child (items with no
-     * group title form runs of their own).
+     * The contiguous `groupTitle` run around the tapped child (items with no group title form runs
+     * of their own).
      */
     data class Run(val tracks: List<Track>) : Section()
   }
 
   /**
-   * The section of [children] containing the playable [trackId], or null
-   * when the id is not found.
+   * The section of [children] containing the playable [trackId], or null when the id is not found.
    */
   fun section(children: List<Track>, trackId: String): Section? {
     for (child in children) {

package/android/src/main/java/com/audiobrowser/http/HttpClient.kt

@@ -1,5 +1,6 @@
 package com.audiobrowser.http
 
+import com.audiobrowser.BuildConfig
 import java.io.IOException
 import java.util.concurrent.TimeUnit
 import kotlinx.coroutines.Dispatchers
@@ -27,13 +28,29 @@ class HttpClient {
     isLenient = true
   }
 
-  private val loggingInterceptor =
+  /**
+   * Full request/response logging, for debug builds only.
+   *
+   * Timber is exposed as `api`, so whatever this logs reaches the host app's tree — a Crashlytics
+   * or Sentry breadcrumb tree included. That means credentials attached by the request-transform
+   * layer and every response body, so the interceptor is not installed in release at all: `BODY`
+   * also buffers and stringifies each response whether or not anything reads the log.
+   *
+   * The redactions apply in debug too. Logcat is shared in bug reports and screen shares.
+   */
+  private fun loggingInterceptor() =
     HttpLoggingInterceptor { message -> Timber.d(message) }
-      .apply { level = HttpLoggingInterceptor.Level.BODY }
+      .apply {
+        level = HttpLoggingInterceptor.Level.BODY
+        redactHeader("Authorization")
+        redactHeader("Proxy-Authorization")
+        redactHeader("Cookie")
+        redactHeader("Set-Cookie")
+      }
 
   private val client =
     OkHttpClient.Builder()
-      .addInterceptor(loggingInterceptor)
+      .apply { if (BuildConfig.DEBUG) addInterceptor(loggingInterceptor()) }
       .connectTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
       .readTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
       .writeTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)

package/android/src/main/java/com/audiobrowser/model/PlayerUpdateOptions.kt

@@ -3,11 +3,11 @@ package com.audiobrowser.model
 import com.margelo.nitro.audiobrowser.AndroidOptions
 import com.margelo.nitro.audiobrowser.AppKilledPlaybackBehavior
 import com.margelo.nitro.audiobrowser.NativeUpdateOptions
-import com.margelo.nitro.audiobrowser.NotificationButtonLayout
 import com.margelo.nitro.audiobrowser.Options
 import com.margelo.nitro.audiobrowser.PlayerCapabilities
+import com.margelo.nitro.audiobrowser.RemoteButtonLayout
 import com.margelo.nitro.audiobrowser.Variant_NullType_Double
-import com.margelo.nitro.audiobrowser.Variant_NullType_NotificationButtonLayout
+import com.margelo.nitro.audiobrowser.Variant_NullType_RemoteButtonLayout
 
 /**
  * Update options for the AudioBrowser that can be changed at runtime. These options control player
@@ -37,8 +37,8 @@ data class PlayerUpdateOptions(
       playbackRate = null,
     ),
 
-  // Notification button layout (null = derive from capabilities)
-  var notificationButtons: NotificationButtonLayout? = null,
+  // Ordered button layout (null = derive from capabilities)
+  var remoteButtonLayout: RemoteButtonLayout? = null,
 
   // Android-specific runtime options (all under android.* in JS)
   var appKilledPlaybackBehavior: AppKilledPlaybackBehavior =
@@ -66,12 +66,12 @@ data class PlayerUpdateOptions(
       // Update boolean options
       androidOptions.skipSilence?.let { skipSilence = it }
 
-      // Handle notificationButtons - variant allows distinguishing undefined from null
-      androidOptions.notificationButtons?.let { variant ->
-        notificationButtons =
+      // Handle remoteButtonLayout - variant allows distinguishing undefined from null
+      androidOptions.remoteButtonLayout?.let { variant ->
+        remoteButtonLayout =
           when (variant) {
-            is Variant_NullType_NotificationButtonLayout.First -> null
-            is Variant_NullType_NotificationButtonLayout.Second -> variant.value
+            is Variant_NullType_RemoteButtonLayout.First -> null
+            is Variant_NullType_RemoteButtonLayout.Second -> variant.value
           }
       }
     }
@@ -84,8 +84,8 @@ data class PlayerUpdateOptions(
         AndroidOptions(
           appKilledPlaybackBehavior = appKilledPlaybackBehavior,
           skipSilence = skipSilence,
-          notificationButtons =
-            notificationButtons?.let { Variant_NullType_NotificationButtonLayout.create(it) },
+          remoteButtonLayout =
+            remoteButtonLayout?.let { Variant_NullType_RemoteButtonLayout.create(it) },
         ),
       forwardJumpInterval = forwardJumpInterval,
       backwardJumpInterval = backwardJumpInterval,