expo-gliph-player 1.3.13 → 1.3.15

package/android/src/main/java/com/gliphplayer/GliphPlayerModule.kt

@@ -148,33 +148,40 @@ class GliphPlayerModule(
     }
   }
 
-  @ReactMethod
-  override fun skip(index: Double, initialPosition: Double, promise: Promise) {
-    scope.launch {
-      try {
-        playerService?.skip(index.toInt(), if (initialPosition < 0) -1.0 else initialPosition)
-        promise.resolve(null)
-      } catch (e: Exception) { promise.reject("skip_error", e.message, e) }
+    @ReactMethod
+    override fun skip(index: Double, initialPosition: Double, autoPlay: Boolean, promise: Promise) {
+        scope.launch {
+            try {
+                val pos = if (initialPosition < 0) -1.0 else initialPosition
+                playerService?.skip(index.toInt(), pos, autoPlay)
+                promise.resolve(null)
+            } catch (e: Exception) {
+                promise.reject("skip_error", e.message, e)
+            }
+        }
     }
-  }
 
   @ReactMethod
-  override fun skipToNext(initialPosition: Double, promise: Promise) {
+  override fun skipToNext(initialPosition: Double, autoPlay: Boolean, promise: Promise) {
     scope.launch {
       try {
-        playerService?.skipToNext(if (initialPosition < 0) -1.0 else initialPosition)
+        playerService?.skipToNext(if (initialPosition < 0) -1.0 else initialPosition, autoPlay)
         promise.resolve(null)
-      } catch (e: Exception) { promise.reject("skip_error", e.message, e) }
+      } catch (e: Exception) {
+        promise.reject("skip_error", e.message, e)
+      }
     }
   }
 
   @ReactMethod
-  override fun skipToPrevious(initialPosition: Double, promise: Promise) {
+  override fun skipToPrevious(initialPosition: Double, autoPlay: Boolean, promise: Promise) {
     scope.launch {
       try {
-        playerService?.skipToPrevious(if (initialPosition < 0) -1.0 else initialPosition)
+        playerService?.skipToPrevious(if (initialPosition < 0) -1.0 else initialPosition, autoPlay)
         promise.resolve(null)
-      } catch (e: Exception) { promise.reject("skip_error", e.message, e) }
+      } catch (e: Exception) {
+        promise.reject("skip_error", e.message, e)
+      }
     }
   }
 
@@ -357,4 +364,4 @@ class GliphPlayerModule(
   }
 
   override fun getName() = NAME
-}
+}

package/android/src/main/java/com/gliphplayer/GliphPlayerService.kt

@@ -12,6 +12,7 @@ import android.os.IBinder
 import androidx.media3.common.*
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.DefaultLoadControl
 import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
 import androidx.media3.session.*
 import androidx.core.app.NotificationCompat
@@ -52,16 +53,12 @@ class GliphPlayerService : MediaLibraryService() {
   private val binder = LocalBinder()
 
   override fun onBind(intent: Intent?): IBinder? {
-    // MediaLibraryService.onBind handles media browser connections.
-    // For our local binding from GliphPlayerModule, we return our LocalBinder.
-    // We must check the action to distinguish the two callers.
     val action = intent?.action
     if (action == null ||
         action == "com.gliphplayer.BIND_LOCAL" ||
         action == Intent.ACTION_MAIN) {
       return binder
     }
-    // Let MediaLibraryService handle MediaBrowser / MediaSession connections
     return super.onBind(intent)
   }
 
@@ -75,7 +72,6 @@ class GliphPlayerService : MediaLibraryService() {
   private var progressJob: Job? = null
   private var options: ReadableMap? = null
 
-  // Internal queue (mirrors ExoPlayer's playlist)
   private val queue = java.util.Collections.synchronizedList(mutableListOf<ReadableMap>())
 
   // ── Helpers ─────────────────────────────────────────────────────────────────
@@ -96,7 +92,6 @@ class GliphPlayerService : MediaLibraryService() {
 
   override fun onCreate() {
     super.onCreate()
-    // 1. Create high-importance notification channel
     if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
       val channel = android.app.NotificationChannel(
         CHANNEL_ID,
@@ -111,7 +106,6 @@ class GliphPlayerService : MediaLibraryService() {
       manager.createNotificationChannel(channel)
     }
 
-    // 2. Immediate Foregrounding with a safe system icon
     val initialNotification = NotificationCompat.Builder(this, CHANNEL_ID)
       .setSmallIcon(android.R.drawable.ic_media_play)
       .setContentTitle("Gliph Player")
@@ -126,7 +120,6 @@ class GliphPlayerService : MediaLibraryService() {
       startForeground(NOTIFICATION_ID, initialNotification)
     }
 
-    // 3. Initialize player
     initPlayer()
   }
 
@@ -135,8 +128,8 @@ class GliphPlayerService : MediaLibraryService() {
     when (intent?.action) {
       ACTION_PLAY -> play()
       ACTION_PAUSE -> pause()
-      ACTION_SKIP_NEXT -> skipToNext(-1.0)
-      ACTION_SKIP_PREVIOUS -> skipToPrevious(-1.0)
+      ACTION_SKIP_NEXT -> skipToNext(-1.0, true)
+      ACTION_SKIP_PREVIOUS -> skipToPrevious(-1.0, true)
       ACTION_STOP -> {
         stop()
         stopSelf()
@@ -171,38 +164,39 @@ class GliphPlayerService : MediaLibraryService() {
   // ── Init ────────────────────────────────────────────────────────────────────
 
   private fun initPlayer(opts: ReadableMap? = null) {
-    // ── Fix #4: Buffer values from JS are in SECONDS (Double).
-    // ExoPlayer's DefaultLoadControl expects MILLISECONDS (Long).
-    // We convert here so callers never accidentally buffer for 1000 seconds.
-    //
-    // JS API contract (all values in seconds):
-    //   minBuffer    — minimum seconds to buffer before playback starts (default 15s)
-    //   maxBuffer    — maximum seconds to buffer ahead (default 50s)
-    //   playBuffer   — seconds buffered before playback resumes after stall (default 2.5s)
-    //   backBuffer   — seconds of audio to keep behind current position (default 0s)
-    val minBufferMs  = (getDouble(opts, "minBuffer", 15.0)  * 1000).toInt()
-    val maxBufferMs  = (getDouble(opts, "maxBuffer", 50.0)  * 1000).toInt()
-    val playBufferMs = (getDouble(opts, "playBuffer", 2.5)   * 1000).toInt()
-    val backBufferMs = (getDouble(opts, "backBuffer", 0.0)   * 1000).toInt()
-
-    val loadControl = androidx.media3.exoplayer.DefaultLoadControl.Builder()
-      .setBufferDurationsMs(minBufferMs, maxBufferMs, playBufferMs, playBufferMs)
-      .setBackBuffer(backBufferMs, /* retainBackBufferFromKeyframe= */ false)
-      .build()
+    val playBufferSec = getDouble(opts, "playBuffer", 2.5)
+    val minBufferSec  = getDouble(opts, "minBuffer", 15.0)
+    val maxBufferSec  = getDouble(opts, "maxBuffer", 50.0)
+    val backBufferSec = getDouble(opts, "backBuffer", 0.0)
+
+    val playBufferMs = (playBufferSec * 1000).toInt()    // 2500ms
+    var minBufferMs  = (minBufferSec  * 1000).toInt()    // 15000ms
+    val maxBufferMs  = (maxBufferSec  * 1000).toInt()    // 50000ms
+    val backBufferMs = (backBufferSec * 1000).toInt()    // 0ms
+
+    if (minBufferMs < playBufferMs) {
+        Log.w("GliphPlayer", "minBufferMs ($minBufferMs) < playBufferMs ($playBufferMs), adjusting...")
+        minBufferMs = playBufferMs
+    }
+
+    val loadControl = DefaultLoadControl.Builder()
+        .setBufferDurationsMs(minBufferMs, maxBufferMs, playBufferMs, playBufferMs)
+        .setBackBuffer(backBufferMs, false)
+        .build()
 
     player = ExoPlayer.Builder(this)
-      .setMediaSourceFactory(DefaultMediaSourceFactory(this))
-      .setLoadControl(loadControl)
-      .setHandleAudioBecomingNoisy(true)
-      .setWakeMode(C.WAKE_MODE_NETWORK)
-      .setAudioAttributes(
-        AudioAttributes.Builder()
-          .setUsage(C.USAGE_MEDIA)
-          .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
-          .build(),
-        /* handleAudioFocus= */ true
-      )
-      .build()
+        .setMediaSourceFactory(DefaultMediaSourceFactory(this))
+        .setLoadControl(loadControl)
+        .setHandleAudioBecomingNoisy(true)
+        .setWakeMode(C.WAKE_MODE_NETWORK)
+        .setAudioAttributes(
+            AudioAttributes.Builder()
+                .setUsage(C.USAGE_MEDIA)
+                .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
+                .build(),
+            true
+        )
+        .build()
 
     player.addListener(playerListener)
 
@@ -313,10 +307,6 @@ class GliphPlayerService : MediaLibraryService() {
     Log.d("GliphPlayer", "setupPlayer called with opts: $opts")
     options = opts
 
-    // ── Fix #5: Android-specific options (appKilledPlaybackBehavior, audioUsage,
-    // audioContentType) are applied HERE at setup time, not in updateOptions.
-    // This avoids Codegen type mismatches and ensures the ExoPlayer AudioAttributes
-    // are configured before the first track is loaded.
     val androidOpts = if (opts.hasKey("android")) opts.getMap("android") else null
     val audioUsageStr = getString(androidOpts, "audioUsage", null)
     val audioUsage = when (audioUsageStr) {
@@ -324,24 +314,22 @@ class GliphPlayerService : MediaLibraryService() {
       "alarm"              -> C.USAGE_ALARM
       "notification"       -> C.USAGE_NOTIFICATION
       "game"               -> C.USAGE_GAME
-      else                 -> C.USAGE_MEDIA  // default: music
+      else                 -> C.USAGE_MEDIA
     }
     val audioContentTypeStr = getString(androidOpts, "audioContentType", null)
     val audioContentType = when (audioContentTypeStr) {
       "speech"       -> C.AUDIO_CONTENT_TYPE_SPEECH
       "sonification" -> C.AUDIO_CONTENT_TYPE_SONIFICATION
       "movie"        -> C.AUDIO_CONTENT_TYPE_MOVIE
-      else           -> C.AUDIO_CONTENT_TYPE_MUSIC  // default
+      else           -> C.AUDIO_CONTENT_TYPE_MUSIC
     }
 
-    // Re-init player with the correct buffer settings and audio attributes
     if (::player.isInitialized) {
       player.release()
       mediaSession.release()
     }
     initPlayer(opts)
 
-    // Apply audio attributes after init (ExoPlayer allows this before first play)
     player.setAudioAttributes(
       AudioAttributes.Builder()
         .setUsage(audioUsage)
@@ -366,6 +354,38 @@ class GliphPlayerService : MediaLibraryService() {
     }
   }
 
+  // ── 🆕 HELPER: Отправка события об изменении активного трека ──────────────
+
+  private fun emitActiveTrackChanged(lastIndex: Int = -1) {
+    val newIndex = player.currentMediaItemIndex
+    val map = Arguments.createMap()
+    map.putInt("index", newIndex)
+    map.putInt("lastIndex", if (lastIndex >= 0) lastIndex else newIndex)
+    map.putDouble("lastPosition", player.currentPosition / 1000.0)
+
+    if (newIndex >= 0 && newIndex < queue.size) {
+      map.putMap("track", Arguments.makeNativeMap(queue[newIndex].toHashMap()))
+    } else {
+      map.putNull("track")
+    }
+
+    if (lastIndex >= 0 && lastIndex < queue.size) {
+      map.putMap("lastTrack", Arguments.makeNativeMap(queue[lastIndex].toHashMap()))
+    } else {
+      map.putNull("lastTrack")
+    }
+
+    eventEmitter?.invoke("playback-active-track-changed", map)
+  }
+
+  // ── 🆕 HELPER: Отправка состояния ──────────────────────────────────────────
+
+  private fun emitPlaybackState(state: String) {
+    val map = Arguments.createMap()
+    map.putString("state", state)
+    eventEmitter?.invoke("playback-state", map)
+  }
+
   // ── Queue management ────────────────────────────────────────────────────────
 
   fun add(tracks: ReadableArray, insertBeforeIndex: Int): Int {
@@ -375,11 +395,13 @@ class GliphPlayerService : MediaLibraryService() {
       insertBeforeIndex
     }
 
+    val wasEmpty = queue.isEmpty()
     val mediaItems = mutableListOf<MediaItem>()
+
     for (i in 0 until tracks.size()) {
       val track = tracks.getMap(i) ?: continue
       Log.d("GliphPlayer", "Adding track: ${track.getString("title")} (URL: ${track.getString("url")})")
-      queue.add(startIndex + (i), track)
+      queue.add(startIndex + i, track)
       mediaItems.add(buildMediaItem(track))
     }
 
@@ -389,6 +411,10 @@ class GliphPlayerService : MediaLibraryService() {
       player.addMediaItems(insertBeforeIndex, mediaItems)
     }
 
+    if (wasEmpty && queue.isNotEmpty()) {
+      emitActiveTrackChanged()
+    }
+
     updateMediaNotification()
     return startIndex
   }
@@ -416,24 +442,57 @@ class GliphPlayerService : MediaLibraryService() {
     }
   }
 
-  fun skip(index: Int, initialPosition: Double) {
-    player.seekTo(index, if (initialPosition >= 0) (initialPosition * 1000).toLong() else C.TIME_UNSET)
-    player.play()
-  }
+    fun skip(index: Int, initialPosition: Double, autoPlay: Boolean = true) {
+        val lastIndex = player.currentMediaItemIndex
+
+        if (index < 0 || index >= queue.size) {
+            Log.e("GliphPlayer", "skip: index $index out of bounds")
+            return
+        }
+
+        player.seekTo(index, if (initialPosition >= 0) (initialPosition * 1000).toLong() else C.TIME_UNSET)
 
-  fun skipToNext(initialPosition: Double) {
+        if (autoPlay) {
+            player.playWhenReady = true
+
+            if (player.playbackState == Player.STATE_IDLE) {
+                player.prepare()
+            }
+
+            player.play()
+            emitPlaybackState("playing")
+        }
+
+        emitActiveTrackChanged(lastIndex)
+    }
+
+  fun skipToNext(initialPosition: Double, autoPlay: Boolean = true) {
     if (player.hasNextMediaItem()) {
+      val lastIndex = player.currentMediaItemIndex
       player.seekToNextMediaItem()
       if (initialPosition >= 0) player.seekTo((initialPosition * 1000).toLong())
-      player.play()
+
+      if (autoPlay) {
+        player.play()
+      }
+
+      emitActiveTrackChanged(lastIndex)
+      emitPlaybackState(if (autoPlay) "playing" else "paused")
     }
   }
 
-  fun skipToPrevious(initialPosition: Double) {
+  fun skipToPrevious(initialPosition: Double, autoPlay: Boolean = true) {
     if (player.hasPreviousMediaItem()) {
+      val lastIndex = player.currentMediaItemIndex
       player.seekToPreviousMediaItem()
       if (initialPosition >= 0) player.seekTo((initialPosition * 1000).toLong())
-      player.play()
+
+      if (autoPlay) {
+        player.play()
+      }
+
+      emitActiveTrackChanged(lastIndex)
+      emitPlaybackState(if (autoPlay) "playing" else "paused")
     }
   }
 
@@ -451,23 +510,47 @@ class GliphPlayerService : MediaLibraryService() {
       player.prepare()
     }
     player.play()
+
+    emitPlaybackState("playing")
+
+    if (player.currentMediaItemIndex >= 0 && player.currentMediaItemIndex < queue.size) {
+      emitActiveTrackChanged()
+    }
+
     updateMediaNotification()
   }
 
   fun pause() {
     player.pause()
+
+    emitPlaybackState("paused")
+
     updateMediaNotification()
   }
 
   fun stop() {
     player.stop()
+
+    emitPlaybackState("stopped")
+
     updateMediaNotification()
   }
 
   fun reset() {
+    val lastIndex = player.currentMediaItemIndex
     player.stop()
     player.clearMediaItems()
     queue.clear()
+
+    val map = Arguments.createMap()
+    map.putInt("index", -1)
+    map.putNull("track")
+    map.putInt("lastIndex", lastIndex)
+    map.putDouble("lastPosition", 0.0)
+    eventEmitter?.invoke("playback-active-track-changed", map)
+
+    emitPlaybackState("none")
+
     updateMediaNotification()
   }
 
@@ -577,10 +660,8 @@ class GliphPlayerService : MediaLibraryService() {
     if (index < 0 || index >= queue.size) return
     val existing = queue[index].toHashMap()
     metadata.toHashMap().forEach { (k, v) -> existing[k] = v }
-    // Rebuild the queue entry (ReadableMap is immutable, so we use a WritableMap)
     val updated = Arguments.makeNativeMap(existing)
     queue[index] = updated
-    // Update ExoPlayer media item metadata
     player.replaceMediaItem(index, buildMediaItem(updated))
     updateMediaNotification()
   }
@@ -598,7 +679,6 @@ class GliphPlayerService : MediaLibraryService() {
     val updated = Arguments.makeNativeMap(existing)
     queue[currentIndex] = updated
 
-    // Update the live MediaItem in the player
     val currentItem = player.currentMediaItem ?: return
     val newMetadata = currentItem.mediaMetadata.buildUpon()
       .also { builder ->
@@ -614,13 +694,11 @@ class GliphPlayerService : MediaLibraryService() {
   }
 
   fun updateOptions(opts: ReadableMap) {
-    // Merge new options with existing ones to avoid wiping out buffer settings
     val merged = Arguments.createMap()
     options?.let { merged.merge(it) }
     merged.merge(opts)
     options = merged
 
-    // Restart progress updates if the interval changed
     if (opts.hasKey("progressUpdateEventInterval")) {
       startProgressUpdates()
     }
@@ -676,7 +754,6 @@ class GliphPlayerService : MediaLibraryService() {
       .setMediaId(track.getString("id") ?: url)
       .setMediaMetadata(metadata)
       .also { builder ->
-        // Custom headers
         val headers = track.getMap("headers")
         if (headers != null) {
           val headersMap = headers.toHashMap().mapValues { it.value.toString() }
@@ -701,15 +778,14 @@ class GliphPlayerService : MediaLibraryService() {
     private var lastIndex = -1
 
     override fun onPlaybackStateChanged(playbackState: Int) {
-      emitPlaybackState()
+      emitPlaybackState(mapPlayerState())
       updateMediaNotification()
+
       if (playbackState == Player.STATE_ENDED) {
-        // Emit track ended for the last item in the queue if it just finished
         val map = Arguments.createMap()
         map.putInt("index", player.currentMediaItemIndex)
         eventEmitter?.invoke("playback-track-ended", map)
 
-        // Then emit queue ended
         val queueMap = Arguments.createMap()
         queueMap.putInt("index", player.currentMediaItemIndex)
         queueMap.putDouble("position", player.currentPosition / 1000.0)
@@ -718,13 +794,13 @@ class GliphPlayerService : MediaLibraryService() {
     }
 
     override fun onIsPlayingChanged(isPlaying: Boolean) {
-      emitPlaybackState()
+      emitPlaybackState(mapPlayerState())
       updateMediaNotification()
     }
 
     override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
-      // If we transitioned to a new item, the previous one "ended" its playback
-      if (reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO || reason == Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT) {
+      if (reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO ||
+          reason == Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT) {
         val endedMap = Arguments.createMap()
         endedMap.putInt("index", lastIndex)
         eventEmitter?.invoke("playback-track-ended", endedMap)
@@ -758,9 +834,8 @@ class GliphPlayerService : MediaLibraryService() {
       map.putString("code", "playback_error_${error.errorCode}")
       map.putString("message", error.message ?: "Unknown playback error")
       eventEmitter?.invoke("playback-error", map)
-      emitPlaybackState()
+      emitPlaybackState("error")
 
-      // Optional auto-skip recovery
       val autoSkip = options?.getMap("android")?.let { androidMap ->
           androidMap.hasKey("autoSkipOnError") && androidMap.getBoolean("autoSkipOnError")
       } ?: false
@@ -770,12 +845,6 @@ class GliphPlayerService : MediaLibraryService() {
         player.play()
       }
     }
-
-    private fun emitPlaybackState() {
-      val map = Arguments.createMap()
-      map.putString("state", mapPlayerState())
-      eventEmitter?.invoke("playback-state", map)
-    }
   }
 
   // ── MediaSession callback ───────────────────────────────────────────────────
@@ -787,11 +856,10 @@ class GliphPlayerService : MediaLibraryService() {
       controller: MediaSession.ControllerInfo,
       mediaItems: MutableList<MediaItem>
     ): com.google.common.util.concurrent.ListenableFuture<MutableList<MediaItem>> {
-      // Resolve URIs for Android Auto / external controllers
       val resolved = mediaItems.map { item ->
         item.buildUpon().setUri(item.requestMetadata.mediaUri).build()
       }.toMutableList()
       return com.google.common.util.concurrent.Futures.immediateFuture(resolved)
     }
   }
-}
+}