@roitium/expo-orpheus 0.5.1 → 0.7.0

package/README.md

@@ -21,6 +21,10 @@ Orpheus 内部有两层缓存：
 
 Orpheus 集成了 Media3 的 DownloadManager，抛弃了原先 BBPlayer 中繁琐的下载实现。
 
+## 响度均衡
+
+默认启用，只对未缓存的 b 站音频生效
+
 ## 使用
 
 虽然该包是公开的，但仍然主要供 BBPlayer 内部使用。可能不会有完整的文档覆盖。我们欢迎你 fork 后自行修改使用。

package/android/src/main/java/expo/modules/orpheus/DownloadCache.kt

@@ -3,6 +3,7 @@ package expo.modules.orpheus
 import android.content.Context
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.database.StandaloneDatabaseProvider
+import androidx.media3.datasource.cache.LeastRecentlyUsedCacheEvictor
 import androidx.media3.datasource.cache.NoOpCacheEvictor
 import androidx.media3.datasource.cache.SimpleCache
 import java.io.File
@@ -10,6 +11,7 @@ import java.io.File
 @UnstableApi
 object DownloadCache {
     private var stableCache: SimpleCache? = null
+    private var lruCache: SimpleCache? = null
 
     @Synchronized
     fun getStableCache(context: Context): SimpleCache {
@@ -21,4 +23,15 @@ object DownloadCache {
         }
         return stableCache!!
     }
+
+    @Synchronized
+    fun  getLruCache(context: Context): SimpleCache {
+        if (lruCache == null) {
+            val cacheDir = File(context.cacheDir, "media_cache_lru")
+            val evictor = LeastRecentlyUsedCacheEvictor(256 * 1024 * 1024)
+            val databaseProvider = StandaloneDatabaseProvider(context)
+            lruCache = SimpleCache(cacheDir, evictor, databaseProvider)
+        }
+        return lruCache!!
+    }
 }

package/android/src/main/java/expo/modules/orpheus/ExpoOrpheusModule.kt

@@ -1,7 +1,6 @@
 package expo.modules.orpheus
 
 import android.content.ComponentName
-import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
 import android.util.Log
@@ -18,26 +17,24 @@ import androidx.media3.exoplayer.offline.DownloadManager
 import androidx.media3.exoplayer.offline.DownloadRequest
 import androidx.media3.exoplayer.offline.DownloadService
 import androidx.media3.session.MediaController
-import androidx.media3.session.SessionCommand
-import androidx.media3.session.SessionResult
 import androidx.media3.session.SessionToken
 import com.google.common.util.concurrent.ListenableFuture
-import com.google.common.util.concurrent.MoreExecutors
 import com.google.gson.Gson
-import expo.modules.kotlin.exception.CodedException
 import expo.modules.kotlin.functions.Queues
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 import expo.modules.orpheus.models.TrackRecord
 import expo.modules.orpheus.utils.DownloadUtil
-import expo.modules.orpheus.utils.Storage
+import expo.modules.orpheus.utils.GeneralStorage
+import expo.modules.orpheus.utils.LoudnessStorage
 import expo.modules.orpheus.utils.toMediaItem
 
 @UnstableApi
 class ExpoOrpheusModule : Module() {
+    // keep this controller only to make sure MediaLibraryService is init.
     private var controllerFuture: ListenableFuture<MediaController>? = null
 
-    private var controller: MediaController? = null
+    private var player: Player? = null
 
     private val mainHandler = Handler(Looper.getMainLooper())
 
@@ -51,6 +48,124 @@ class ExpoOrpheusModule : Module() {
 
     val gson = Gson()
 
+    private val playerListener = object : Player.Listener {
+
+        /**
+         * 核心：处理切歌、播放结束逻辑
+         */
+        override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
+            val newId = mediaItem?.mediaId ?: ""
+            Log.e("Orpheus", "onMediaItemTransition: $reason")
+
+            sendEvent(
+                "onTrackStarted", mapOf(
+                    "trackId" to newId,
+                    "reason" to reason
+                )
+            )
+
+            lastMediaId = newId
+            saveCurrentPosition()
+        }
+
+        override fun onTimelineChanged(timeline: Timeline, reason: Int) {
+            val p = player ?: return
+            val currentItem = p.currentMediaItem ?: return
+            val mediaId = currentItem.mediaId
+
+            val duration = p.duration
+            Log.d(
+                "Orpheus",
+                "onTimelineChanged: reason: $reason mediaId: $mediaId duration: $duration"
+            )
+
+            if (duration != C.TIME_UNSET && duration > 0) {
+                durationCache[mediaId] = duration
+            }
+        }
+
+        override fun onPositionDiscontinuity(
+            oldPosition: Player.PositionInfo,
+            newPosition: Player.PositionInfo,
+            reason: Int
+        ) {
+            val isAutoTransition = reason == Player.DISCONTINUITY_REASON_AUTO_TRANSITION
+            val isIndexChanged = oldPosition.mediaItemIndex != newPosition.mediaItemIndex
+            val lastMediaItem = oldPosition.mediaItem ?: return
+            val currentTime = System.currentTimeMillis()
+            if ((currentTime - lastTrackFinishedAt) < 200) {
+                return
+            }
+
+            Log.d(
+                "Orpheus",
+                "onPositionDiscontinuity: isAutoTransition:$isAutoTransition isIndexChanged: $isIndexChanged durationCache:$durationCache"
+            )
+
+            if (isAutoTransition || isIndexChanged) {
+
+                val duration = durationCache[lastMediaItem.mediaId] ?: return
+                lastTrackFinishedAt = currentTime
+
+                sendEvent(
+                    "onTrackFinished", mapOf(
+                        "trackId" to lastMediaItem.mediaId,
+                        "finalPosition" to oldPosition.positionMs / 1000.0,
+                        "duration" to duration / 1000.0,
+                    )
+                )
+            }
+        }
+
+        /**
+         * 处理播放状态改变
+         */
+        override fun onPlaybackStateChanged(state: Int) {
+            // state: 1=IDLE, 2=BUFFERING, 3=READY, 4=ENDED
+            sendEvent(
+                "onPlaybackStateChanged", mapOf(
+                    "state" to state
+                )
+            )
+
+            updateProgressRunnerState()
+        }
+
+        /**
+         * 处理播放/暂停状态
+         */
+        override fun onIsPlayingChanged(isPlaying: Boolean) {
+            sendEvent(
+                "onIsPlayingChanged", mapOf(
+                    "status" to isPlaying
+                )
+            )
+            updateProgressRunnerState()
+        }
+
+        /**
+         * 处理错误
+         */
+        override fun onPlayerError(error: PlaybackException) {
+            sendEvent(
+                "onPlayerError", mapOf(
+                    "code" to error.errorCode.toString(),
+                    "message" to (error.message ?: "Unknown Error")
+                )
+            )
+        }
+
+        override fun onRepeatModeChanged(repeatMode: Int) {
+            super.onRepeatModeChanged(repeatMode)
+            GeneralStorage.saveRepeatMode(repeatMode)
+        }
+
+        override fun onShuffleModeEnabledChanged(shuffleModeEnabled: Boolean) {
+            super.onShuffleModeEnabledChanged(shuffleModeEnabled)
+            GeneralStorage.saveShuffleMode(shuffleModeEnabled)
+        }
+    }
+
     @OptIn(UnstableApi::class)
     override fun definition() = ModuleDefinition {
         Name("Orpheus")
@@ -67,7 +182,8 @@ class ExpoOrpheusModule : Module() {
 
         OnCreate {
             val context = appContext.reactContext ?: return@OnCreate
-            Storage.initialize(context)
+            GeneralStorage.initialize(context)
+            LoudnessStorage.initialize(context)
             val sessionToken = SessionToken(
                 context,
                 ComponentName(context, OrpheusMusicService::class.java)
@@ -75,14 +191,16 @@ class ExpoOrpheusModule : Module() {
             controllerFuture = MediaController.Builder(context, sessionToken)
                 .setApplicationLooper(Looper.getMainLooper()).buildAsync()
 
-            controllerFuture?.addListener({
-                try {
-                    controller = controllerFuture?.get()
-                    setupListeners()
-                } catch (e: Exception) {
-                    e.printStackTrace()
+
+            OrpheusMusicService.addOnServiceReadyListener { service ->
+                mainHandler.post {
+                    if (this@ExpoOrpheusModule.player != service.player) {
+                        this@ExpoOrpheusModule.player?.removeListener(playerListener)
+                        this@ExpoOrpheusModule.player = service.player
+                        this@ExpoOrpheusModule.player?.addListener(playerListener)
+                    }
                 }
-            }, MoreExecutors.directExecutor())
+            }
 
             downloadManager = DownloadUtil.getDownloadManager(context)
             downloadManager?.addListener(downloadListener)
@@ -94,14 +212,18 @@ class ExpoOrpheusModule : Module() {
             mainHandler.removeCallbacks(downloadProgressRunnable)
             controllerFuture?.let { MediaController.releaseFuture(it) }
             downloadManager?.removeListener(downloadListener)
+            player?.removeListener(playerListener)
+            OrpheusMusicService.removeOnServiceReadyListener { }
+            player = null
+            Log.d("Orpheus", "Destroy media controller")
         }
 
         Constant("restorePlaybackPositionEnabled") {
-            Storage.isRestoreEnabled()
+            GeneralStorage.isRestoreEnabled()
         }
 
         Constant("loudnessNormalizationEnabled") {
-            Storage.isLoudnessNormalizationEnabled()
+            GeneralStorage.isLoudnessNormalizationEnabled()
         }
 
         Function("setBilibiliCookie") { cookie: String ->
@@ -109,144 +231,143 @@ class ExpoOrpheusModule : Module() {
         }
 
         Function("setLoudnessNormalizationEnabled") { enabled: Boolean ->
-            Storage.setLoudnessNormalizationEnabled(enabled)
+            GeneralStorage.setLoudnessNormalizationEnabled(enabled)
         }
 
         Function("setRestorePlaybackPositionEnabled") { enabled: Boolean ->
-            Storage.setRestoreEnabled(enabled)
+            GeneralStorage.setRestoreEnabled(enabled)
         }
 
         AsyncFunction("getPosition") {
-            checkController()
-            controller?.currentPosition?.toDouble()?.div(1000.0) ?: 0.0
+            checkPlayer()
+            player?.currentPosition?.toDouble()?.div(1000.0) ?: 0.0
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("getDuration") {
-            checkController()
-            val d = controller?.duration ?: C.TIME_UNSET
+            checkPlayer()
+            val d = player?.duration ?: C.TIME_UNSET
             if (d == C.TIME_UNSET) 0.0 else d.toDouble() / 1000.0
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("getBuffered") {
-            checkController()
-            controller?.bufferedPosition?.toDouble()?.div(1000.0) ?: 0.0
+            checkPlayer()
+            player?.bufferedPosition?.toDouble()?.div(1000.0) ?: 0.0
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("getIsPlaying") {
-            checkController()
-            controller?.isPlaying ?: false
+            checkPlayer()
+            player?.isPlaying ?: false
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("getCurrentIndex") {
-            checkController()
-            controller?.currentMediaItemIndex ?: -1
+            checkPlayer()
+            player?.currentMediaItemIndex ?: -1
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("getCurrentTrack") {
-            checkController()
-            val player = controller ?: return@AsyncFunction null
-            val currentItem = player.currentMediaItem ?: return@AsyncFunction null
+            checkPlayer()
+            val p = player ?: return@AsyncFunction null
+            val currentItem = p.currentMediaItem ?: return@AsyncFunction null
 
             mediaItemToTrackRecord(currentItem)
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("getShuffleMode") {
-            checkController()
-            controller?.shuffleModeEnabled
+            checkPlayer()
+            player?.shuffleModeEnabled
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("getIndexTrack") { index: Int ->
-            checkController()
-            val player = controller ?: return@AsyncFunction null
+            checkPlayer()
+            val p = player ?: return@AsyncFunction null
 
-            if (index < 0 || index >= player.mediaItemCount) {
+            if (index < 0 || index >= p.mediaItemCount) {
                 return@AsyncFunction null
             }
 
-            val item = player.getMediaItemAt(index)
+            val item = p.getMediaItemAt(index)
 
             mediaItemToTrackRecord(item)
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("play") {
-            checkController()
-            controller?.play()
+            checkPlayer()
+            player?.play()
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("pause") {
-            checkController()
-            controller?.pause()
+            checkPlayer()
+            player?.pause()
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("clear") {
-            checkController()
-            controller?.clearMediaItems()
+            checkPlayer()
+            player?.clearMediaItems()
             durationCache.clear()
-            DownloadUtil.itemVolumeMap.clear()
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("skipTo") { index: Int ->
             // 跳转到指定索引的开头
-            checkController()
-            controller?.seekTo(index, C.TIME_UNSET)
+            checkPlayer()
+            player?.seekTo(index, C.TIME_UNSET)
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("skipToNext") {
-            checkController()
-            if (controller?.hasNextMediaItem() == true) {
-                controller?.seekToNextMediaItem()
+            checkPlayer()
+            if (player?.hasNextMediaItem() == true) {
+                player?.seekToNextMediaItem()
             }
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("skipToPrevious") {
-            checkController()
-            if (controller?.hasPreviousMediaItem() == true) {
-                controller?.seekToPreviousMediaItem()
+            checkPlayer()
+            if (player?.hasPreviousMediaItem() == true) {
+                player?.seekToPreviousMediaItem()
             }
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("seekTo") { seconds: Double ->
-            checkController()
+            checkPlayer()
             val ms = (seconds * 1000).toLong()
-            controller?.seekTo(ms)
+            player?.seekTo(ms)
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("setRepeatMode") { mode: Int ->
-            checkController()
+            checkPlayer()
             // mode: 0=OFF, 1=TRACK, 2=QUEUE
             val repeatMode = when (mode) {
                 1 -> Player.REPEAT_MODE_ONE
                 2 -> Player.REPEAT_MODE_ALL
                 else -> Player.REPEAT_MODE_OFF
             }
-            controller?.repeatMode = repeatMode
+            player?.repeatMode = repeatMode
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("setShuffleMode") { enabled: Boolean ->
-            checkController()
-            controller?.shuffleModeEnabled = enabled
+            checkPlayer()
+            player?.shuffleModeEnabled = enabled
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("getRepeatMode") {
-            checkController()
-            controller?.repeatMode
+            checkPlayer()
+            player?.repeatMode
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("removeTrack") { index: Int ->
-            checkController()
-            if (index >= 0 && index < (controller?.mediaItemCount ?: 0)) {
-                controller?.removeMediaItem(index)
+            checkPlayer()
+            if (index >= 0 && index < (player?.mediaItemCount ?: 0)) {
+                player?.removeMediaItem(index)
             }
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("getQueue") {
-            checkController()
-            val player = controller ?: return@AsyncFunction emptyList<TrackRecord>()
-            val count = player.mediaItemCount
+            checkPlayer()
+            val p = player ?: return@AsyncFunction emptyList<TrackRecord>()
+            val count = p.mediaItemCount
             val queue = ArrayList<TrackRecord>(count)
 
             for (i in 0 until count) {
-                val item = player.getMediaItemAt(i)
+                val item = p.getMediaItemAt(i)
                 queue.add(mediaItemToTrackRecord(item))
             }
 
@@ -254,59 +375,31 @@ class ExpoOrpheusModule : Module() {
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("setSleepTimer") { durationMs: Long ->
-            checkController()
-            val command = SessionCommand(CustomCommands.CMD_START_TIMER, Bundle.EMPTY)
-            val args = Bundle().apply {
-                putLong(CustomCommands.KEY_DURATION, durationMs)
-            }
-
-            controller?.sendCustomCommand(command, args)
+            OrpheusMusicService.instance?.startSleepTimer(durationMs)
             return@AsyncFunction null
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("getSleepTimerEndTime") {
-            checkController()
-
-            val command = SessionCommand(CustomCommands.CMD_GET_REMAINING, Bundle.EMPTY)
-            val future = controller!!.sendCustomCommand(command, Bundle.EMPTY)
-
-            val result = try {
-                future.get()
-            } catch (e: Exception) {
-                throw CodedException("ERR_EXECUTION_FAILED", e.message, e)
-            }
-
-            if (result.resultCode == SessionResult.RESULT_SUCCESS) {
-                val extras = result.extras
-                if (extras.containsKey(CustomCommands.KEY_STOP_TIME)) {
-                    val stopTime = extras.getLong(CustomCommands.KEY_STOP_TIME)
-                    return@AsyncFunction stopTime
-                }
-            }
-
-            return@AsyncFunction null
+            return@AsyncFunction OrpheusMusicService.instance?.getSleepTimerRemaining()
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("cancelSleepTimer") {
-            checkController()
-            val command = SessionCommand(CustomCommands.CMD_CANCEL_TIMER, Bundle.EMPTY)
-            controller?.sendCustomCommand(command, Bundle.EMPTY)
+            OrpheusMusicService.instance?.cancelSleepTimer()
             return@AsyncFunction null
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("addToEnd") { tracks: List<TrackRecord>, startFromId: String?, clearQueue: Boolean? ->
-            checkController()
+            checkPlayer()
             val mediaItems = tracks.map { track ->
                 track.toMediaItem(gson)
             }
-            val player = controller ?: return@AsyncFunction
+            val p = player ?: return@AsyncFunction
             if (clearQueue == true) {
-                player.clearMediaItems()
+                p.clearMediaItems()
                 durationCache.clear()
-                DownloadUtil.itemVolumeMap.clear()
             }
-            val initialSize = player.mediaItemCount
-            player.addMediaItems(mediaItems)
+            val initialSize = p.mediaItemCount
+            p.addMediaItems(mediaItems)
 
             if (!startFromId.isNullOrEmpty()) {
                 val relativeIndex = tracks.indexOfFirst { it.id == startFromId }
@@ -314,50 +407,50 @@ class ExpoOrpheusModule : Module() {
                 if (relativeIndex != -1) {
                     val targetIndex = initialSize + relativeIndex
 
-                    player.seekTo(targetIndex, C.TIME_UNSET)
-                    player.prepare()
-                    player.play()
+                    p.seekTo(targetIndex, C.TIME_UNSET)
+                    p.prepare()
+                    p.play()
 
                     return@AsyncFunction
                 }
             }
 
-            if (player.playbackState == Player.STATE_IDLE) {
-                player.prepare()
+            if (p.playbackState == Player.STATE_IDLE) {
+                p.prepare()
             }
         }.runOnQueue(Queues.MAIN)
 
         AsyncFunction("playNext") { track: TrackRecord ->
-            checkController()
-            val player = controller ?: return@AsyncFunction
+            checkPlayer()
+            val p = player ?: return@AsyncFunction
 
             val mediaItem = track.toMediaItem(gson)
-            val targetIndex = player.currentMediaItemIndex + 1
+            val targetIndex = p.currentMediaItemIndex + 1
 
             var existingIndex = -1
-            for (i in 0 until player.mediaItemCount) {
-                if (player.getMediaItemAt(i).mediaId == track.id) {
+            for (i in 0 until p.mediaItemCount) {
+                if (p.getMediaItemAt(i).mediaId == track.id) {
                     existingIndex = i
                     break
                 }
             }
 
             if (existingIndex != -1) {
-                if (existingIndex == player.currentMediaItemIndex) {
+                if (existingIndex == p.currentMediaItemIndex) {
                     return@AsyncFunction
                 }
-                val safeTargetIndex = targetIndex.coerceAtMost(player.mediaItemCount)
+                val safeTargetIndex = targetIndex.coerceAtMost(p.mediaItemCount)
 
-                player.moveMediaItem(existingIndex, safeTargetIndex)
+                p.moveMediaItem(existingIndex, safeTargetIndex)
 
             } else {
-                val safeTargetIndex = targetIndex.coerceAtMost(player.mediaItemCount)
+                val safeTargetIndex = targetIndex.coerceAtMost(p.mediaItemCount)
 
-                player.addMediaItem(safeTargetIndex, mediaItem)
+                p.addMediaItem(safeTargetIndex, mediaItem)
             }
 
-            if (player.playbackState == Player.STATE_IDLE) {
-                player.prepare()
+            if (p.playbackState == Player.STATE_IDLE) {
+                p.prepare()
             }
         }.runOnQueue(Queues.MAIN)
 
@@ -554,139 +647,19 @@ class ExpoOrpheusModule : Module() {
         }
     }
 
-    private fun setupListeners() {
-        controller?.addListener(object : Player.Listener {
-
-            /**
-             * 核心：处理切歌、播放结束逻辑
-             */
-            override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
-                val newId = mediaItem?.mediaId ?: ""
-                Log.e("Orpheus", "onMediaItemTransition: $reason")
-
-                sendEvent(
-                    "onTrackStarted", mapOf(
-                        "trackId" to newId,
-                        "reason" to reason
-                    )
-                )
-
-                lastMediaId = newId
-                saveCurrentPosition()
-            }
-
-            override fun onTimelineChanged(timeline: Timeline, reason: Int) {
-                val player = controller ?: return
-                val currentItem = player.currentMediaItem ?: return
-                val mediaId = currentItem.mediaId
-
-                val duration = player.duration
-                Log.d(
-                    "Orpheus",
-                    "onTimelineChanged: reason: $reason mediaId: $mediaId duration: $duration"
-                )
-
-                if (duration != C.TIME_UNSET && duration > 0) {
-                    durationCache[mediaId] = duration
-                }
-            }
-
-            override fun onPositionDiscontinuity(
-                oldPosition: Player.PositionInfo,
-                newPosition: Player.PositionInfo,
-                reason: Int
-            ) {
-                val isAutoTransition = reason == Player.DISCONTINUITY_REASON_AUTO_TRANSITION
-                val isIndexChanged = oldPosition.mediaItemIndex != newPosition.mediaItemIndex
-                val lastMediaItem = oldPosition.mediaItem ?: return
-                val currentTime = System.currentTimeMillis()
-                if ((currentTime - lastTrackFinishedAt) < 200) {
-                    return
-                }
-
-                Log.d(
-                    "Orpheus",
-                    "onPositionDiscontinuity: isAutoTransition:$isAutoTransition isIndexChanged: $isIndexChanged durationCache:$durationCache"
-                )
-
-                if (isAutoTransition || isIndexChanged) {
-
-                    val duration = durationCache[lastMediaItem.mediaId] ?: return
-                    lastTrackFinishedAt = currentTime
-
-                    sendEvent(
-                        "onTrackFinished", mapOf(
-                            "trackId" to lastMediaItem.mediaId,
-                            "finalPosition" to oldPosition.positionMs / 1000.0,
-                            "duration" to duration / 1000.0,
-                        )
-                    )
-                }
-            }
-
-            /**
-             * 处理播放状态改变
-             */
-            override fun onPlaybackStateChanged(state: Int) {
-                // state: 1=IDLE, 2=BUFFERING, 3=READY, 4=ENDED
-                sendEvent(
-                    "onPlaybackStateChanged", mapOf(
-                        "state" to state
-                    )
-                )
-
-                updateProgressRunnerState()
-            }
-
-            /**
-             * 处理播放/暂停状态
-             */
-            override fun onIsPlayingChanged(isPlaying: Boolean) {
-                sendEvent(
-                    "onIsPlayingChanged", mapOf(
-                        "status" to isPlaying
-                    )
-                )
-                updateProgressRunnerState()
-            }
-
-            /**
-             * 处理错误
-             */
-            override fun onPlayerError(error: PlaybackException) {
-                sendEvent(
-                    "onPlayerError", mapOf(
-                        "code" to error.errorCode.toString(),
-                        "message" to (error.message ?: "Unknown Error")
-                    )
-                )
-            }
-
-            override fun onRepeatModeChanged(repeatMode: Int) {
-                super.onRepeatModeChanged(repeatMode)
-                Storage.saveRepeatMode(repeatMode)
-            }
-
-            override fun onShuffleModeEnabledChanged(shuffleModeEnabled: Boolean) {
-                super.onShuffleModeEnabledChanged(shuffleModeEnabled)
-                Storage.saveShuffleMode(shuffleModeEnabled)
-            }
-        })
-    }
-
     private val progressSendEventRunnable = object : Runnable {
         override fun run() {
-            val player = controller ?: return
+            val p = player ?: return
 
-            if (player.isPlaying) {
-                val currentMs = player.currentPosition
-                val durationMs = player.duration
+            if (p.isPlaying) {
+                val currentMs = p.currentPosition
+                val durationMs = p.duration
 
                 sendEvent(
                     "onPositionUpdate", mapOf(
                         "position" to currentMs / 1000.0,
                         "duration" to if (durationMs == C.TIME_UNSET) 0.0 else durationMs / 1000.0,
-                        "buffered" to player.bufferedPosition / 1000.0
+                        "buffered" to p.bufferedPosition / 1000.0
                     )
                 )
             }
@@ -703,9 +676,9 @@ class ExpoOrpheusModule : Module() {
     }
 
     private fun updateProgressRunnerState() {
-        val player = controller
+        val p = player
         // 如果正在播放且状态是 READY，则开始轮询
-        if (player != null && player.isPlaying && player.playbackState == Player.STATE_READY) {
+        if (p != null && p.isPlaying && p.playbackState == Player.STATE_READY) {
             mainHandler.removeCallbacks(progressSendEventRunnable)
             mainHandler.removeCallbacks(progressSaveRunnable)
             mainHandler.post(progressSaveRunnable)
@@ -739,17 +712,17 @@ class ExpoOrpheusModule : Module() {
     }
 
     private fun saveCurrentPosition() {
-        val player = controller ?: return
-        if (player.playbackState != Player.STATE_IDLE) {
-            Storage.savePosition(
-                player.currentMediaItemIndex,
-                player.currentPosition
+        val p = player ?: return
+        if (p.playbackState != Player.STATE_IDLE) {
+            GeneralStorage.savePosition(
+                p.currentMediaItemIndex,
+                p.currentPosition
             )
         }
     }
 
-    private fun checkController() {
-        if (controller == null) {
+    private fun checkPlayer() {
+        if (player == null) {
             throw ControllerNotInitializedException()
         }
     }

package/android/src/main/java/expo/modules/orpheus/OrpheusMusicService.kt

@@ -2,27 +2,24 @@ package expo.modules.orpheus
 
 import android.app.PendingIntent
 import android.content.Intent
-import android.os.Bundle
+import android.util.Log
 import androidx.annotation.OptIn
 import androidx.core.net.toUri
 import androidx.media3.common.AudioAttributes
 import androidx.media3.common.C
 import androidx.media3.common.Player
 import androidx.media3.common.Timeline
-import androidx.media3.common.util.Log
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.exoplayer.ExoPlayer
 import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
 import androidx.media3.session.MediaLibraryService
 import androidx.media3.session.MediaSession
-import androidx.media3.session.SessionCommand
-import androidx.media3.session.SessionResult
 import com.google.common.util.concurrent.Futures
 import com.google.common.util.concurrent.ListenableFuture
-import expo.modules.orpheus.bilibili.VolumeData
 import expo.modules.orpheus.utils.DownloadUtil
 import expo.modules.orpheus.utils.SleepTimeController
-import expo.modules.orpheus.utils.Storage
+import expo.modules.orpheus.utils.GeneralStorage
+import expo.modules.orpheus.utils.LoudnessStorage
 import expo.modules.orpheus.utils.calculateLoudnessGain
 import expo.modules.orpheus.utils.fadeInTo
 import kotlinx.coroutines.Job
@@ -33,17 +30,40 @@ import kotlin.math.abs
 
 class OrpheusMusicService : MediaLibraryService() {
 
-    private var player: ExoPlayer? = null
+    var player: ExoPlayer? = null
     private var mediaSession: MediaLibrarySession? = null
     private var sleepTimerManager: SleepTimeController? = null
     private var volumeFadeJob: Job? = null
     private var scope = MainScope()
 
+    companion object {
+        var instance: OrpheusMusicService? = null
+            private set(value) {
+                field = value
+                if (value != null) {
+                    listeners.forEach { it(value) }
+                }
+            }
+
+        private val listeners = mutableListOf<(OrpheusMusicService) -> Unit>()
+
+        fun addOnServiceReadyListener(listener: (OrpheusMusicService) -> Unit) {
+            instance?.let { listener(it) }
+            listeners.add(listener)
+        }
+
+        fun removeOnServiceReadyListener(listener: (OrpheusMusicService) -> Unit) {
+            listeners.remove(listener)
+        }
+    }
+
     @OptIn(UnstableApi::class)
     override fun onCreate() {
         super.onCreate()
+        instance = this
 
-        Storage.initialize(this)
+        GeneralStorage.initialize(this)
+        LoudnessStorage.initialize(this)
 
 
         val dataSourceFactory = DownloadUtil.getPlayerDataSourceFactory(this)
@@ -93,18 +113,8 @@ class OrpheusMusicService : MediaLibraryService() {
             .setSessionActivity(contentIntent)
             .build()
 
-        restorePlayerState(Storage.isRestoreEnabled())
+        restorePlayerState(GeneralStorage.isRestoreEnabled())
         sleepTimerManager = SleepTimeController(player!!)
-
-        // 当有新的响度数据时，如果是当前这首歌的就直接应用，否则是预加载，等待 onMediaItemTransition 处理
-        scope.launch {
-            DownloadUtil.volumeResolvedEvent.collect { (uri, volumeData) ->
-                val currentUri = player?.currentMediaItem?.localConfiguration?.uri?.toString()
-                if (currentUri == uri) {
-                    applyVolumeForCurrentItem(volumeData)
-                }
-            }
-        }
     }
 
     override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaLibrarySession? {
@@ -113,6 +123,7 @@ class OrpheusMusicService : MediaLibraryService() {
 
     override fun onDestroy() {
         scope.cancel()
+        instance = null
 
         mediaSession?.run {
             player.release()
@@ -122,71 +133,30 @@ class OrpheusMusicService : MediaLibraryService() {
         super.onDestroy()
     }
 
+    fun startSleepTimer(durationMs: Long) {
+        sleepTimerManager?.start(durationMs)
+    }
+
+    fun cancelSleepTimer() {
+        sleepTimerManager?.cancel()
+    }
+
+    fun getSleepTimerRemaining(): Long? {
+        return sleepTimerManager?.getStopTimeMs()
+    }
+
     var callback: MediaLibrarySession.Callback = @UnstableApi
     object : MediaLibrarySession.Callback {
-        private val customCommands = listOf(
-            SessionCommand(CustomCommands.CMD_START_TIMER, Bundle.EMPTY),
-            SessionCommand(CustomCommands.CMD_CANCEL_TIMER, Bundle.EMPTY),
-            SessionCommand(CustomCommands.CMD_GET_REMAINING, Bundle.EMPTY)
-        )
 
         @OptIn(UnstableApi::class)
         override fun onConnect(
             session: MediaSession,
             controller: MediaSession.ControllerInfo
         ): MediaSession.ConnectionResult {
-            val availableCommandsBuilder =
-                MediaSession.ConnectionResult.DEFAULT_SESSION_COMMANDS.buildUpon()
-
-            for (command in customCommands) {
-                availableCommandsBuilder.add(command)
-            }
-
             return MediaSession.ConnectionResult.AcceptedResultBuilder(session)
-                .setAvailableSessionCommands(availableCommandsBuilder.build())
                 .build()
         }
 
-        override fun onCustomCommand(
-            session: MediaSession,
-            controller: MediaSession.ControllerInfo,
-            customCommand: SessionCommand,
-            args: Bundle
-        ): ListenableFuture<SessionResult> {
-
-            Log.d("Orpheus", "onCustomCommand: ${customCommand.customAction}")
-
-            when (customCommand.customAction) {
-                CustomCommands.CMD_START_TIMER -> {
-                    val durationMs = args.getLong(CustomCommands.KEY_DURATION)
-                    sleepTimerManager?.start(durationMs)
-                    return Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS))
-                }
-
-                CustomCommands.CMD_CANCEL_TIMER -> {
-                    sleepTimerManager?.cancel()
-                    return Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS))
-                }
-
-                CustomCommands.CMD_GET_REMAINING -> {
-                    val stopTime = sleepTimerManager?.getStopTimeMs()
-                    val resultBundle = Bundle()
-                    if (stopTime != null) {
-                        resultBundle.putLong(CustomCommands.KEY_STOP_TIME, stopTime)
-                    }
-
-                    return Futures.immediateFuture(
-                        SessionResult(
-                            SessionResult.RESULT_SUCCESS,
-                            resultBundle
-                        )
-                    )
-                }
-            }
-
-            return super.onCustomCommand(session, controller, customCommand, args)
-        }
-
         /**
          * 修复 UnsupportedOperationException 的关键！
          * 当系统尝试恢复播放（比如从“最近播放”卡片点击）时触发。
@@ -209,15 +179,15 @@ class OrpheusMusicService : MediaLibraryService() {
     private fun restorePlayerState(restorePosition: Boolean) {
         val player = player ?: return
 
-        val restoredItems = Storage.restoreQueue()
+        val restoredItems = GeneralStorage.restoreQueue()
 
         if (restoredItems.isNotEmpty()) {
             player.setMediaItems(restoredItems)
 
-            val savedIndex = Storage.getSavedIndex()
-            val savedPosition = Storage.getSavedPosition()
-            val savedShuffleMode = Storage.getShuffleMode()
-            val savedRepeatMode = Storage.getRepeatMode()
+            val savedIndex = GeneralStorage.getSavedIndex()
+            val savedPosition = GeneralStorage.getSavedPosition()
+            val savedShuffleMode = GeneralStorage.getShuffleMode()
+            val savedRepeatMode = GeneralStorage.getRepeatMode()
 
             if (savedIndex >= 0 && savedIndex < restoredItems.size) {
                 player.seekTo(savedIndex, if (restorePosition) savedPosition else C.TIME_UNSET)
@@ -235,7 +205,6 @@ class OrpheusMusicService : MediaLibraryService() {
 
     private fun setupListeners() {
         player?.addListener(object : Player.Listener {
-
             @OptIn(UnstableApi::class)
             override fun onMediaItemTransition(
                 mediaItem: androidx.media3.common.MediaItem?,
@@ -244,10 +213,8 @@ class OrpheusMusicService : MediaLibraryService() {
                 saveCurrentQueue()
                 val uri = mediaItem?.localConfiguration?.uri?.toString() ?: return
 
-                val volumeData = DownloadUtil.itemVolumeMap[uri]
-                if (volumeData != null) {
-                    applyVolumeForCurrentItem(volumeData)
-                }
+                val volumeData = LoudnessStorage.getLoudnessData(uri)
+                applyVolumeForCurrentItem(volumeData)
             }
 
             override fun onTimelineChanged(timeline: Timeline, reason: Int) {
@@ -260,21 +227,20 @@ class OrpheusMusicService : MediaLibraryService() {
         val player = player ?: return
         val queue = List(player.mediaItemCount) { i -> player.getMediaItemAt(i) }
         if (queue.isNotEmpty()) {
-            Storage.saveQueue(queue)
+            GeneralStorage.saveQueue(queue)
         }
     }
 
     @OptIn(UnstableApi::class)
-    private fun applyVolumeForCurrentItem(volumeData: VolumeData) {
+    private fun applyVolumeForCurrentItem(measuredI: Double) {
+        Log.d("LoudnessNormalization", "measuredI: $measuredI")
         val player = player ?: return
         volumeFadeJob?.cancel()
-        val isLoudnessNormalizationEnabled = Storage.isLoudnessNormalizationEnabled()
+        val isLoudnessNormalizationEnabled = GeneralStorage.isLoudnessNormalizationEnabled()
         if (!isLoudnessNormalizationEnabled) return
         val gain = run {
-            val measured = volumeData.measuredI
-            val target = volumeData.targetI
-
-            if (measured == 0.0) 1.0f else calculateLoudnessGain(measured, target)
+            val target = -14.0 // bilibili 的这个值似乎是固定的
+            if (measuredI == 0.0) 1.0f else calculateLoudnessGain(measuredI, target)
         }
 
         val targetVol = 1.0f * gain

package/android/src/main/java/expo/modules/orpheus/utils/DownloadUtil.kt

@@ -1,6 +1,7 @@
 package expo.modules.orpheus.utils
 
 import android.content.Context
+import android.util.Log
 import androidx.core.net.toUri
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.database.StandaloneDatabaseProvider
@@ -35,15 +36,6 @@ object DownloadUtil {
 
     private var downloadNotificationHelper: DownloadNotificationHelper? = null
 
-    var itemVolumeMap: MutableMap<String, VolumeData> = mutableMapOf()
-
-    private val _volumeResolvedEvent = MutableSharedFlow<Pair<String, VolumeData>>(
-        replay = 0,
-        extraBufferCapacity = 1,
-        onBufferOverflow = BufferOverflow.DROP_OLDEST
-    )
-    val volumeResolvedEvent = _volumeResolvedEvent.asSharedFlow()
-
     @Synchronized
     fun getDownloadManager(context: Context): DownloadManager {
         if (downloadManager == null) {
@@ -68,10 +60,16 @@ object DownloadUtil {
             val upstreamFactory = getUpstreamFactory()
 
             val downloadCache = DownloadCache.getStableCache(context)
+            val lruCache = DownloadCache.getLruCache(context)
+
+            val cacheFactory = CacheDataSource.Factory()
+                .setCache(lruCache)
+                .setUpstreamDataSourceFactory(upstreamFactory)
+                .setFlags(CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR)
 
             val downloadFactory = CacheDataSource.Factory()
                 .setCache(downloadCache)
-                .setUpstreamDataSourceFactory(upstreamFactory)
+                .setUpstreamDataSourceFactory(cacheFactory)
                 .setFlags(CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR)
                 .setCacheWriteDataSinkFactory(null)
 
@@ -109,10 +107,6 @@ object DownloadUtil {
         return downloadNotificationHelper!!
     }
 
-    suspend fun emitVolumeEvent(uri: String, data: VolumeData) {
-        _volumeResolvedEvent.emit(uri to data)
-    }
-
     private class BilibiliResolver :
         ResolvingDataSource.Resolver {
         override fun resolveDataSpec(dataSpec: DataSpec): DataSpec {
@@ -132,10 +126,8 @@ object DownloadUtil {
                     )
                     // 在这里保存响度均衡数据，并且直接发一个事件，在 OrpheusMusicService 监听
                     if (volume !== null) {
-                        itemVolumeMap[dataSpec.uri.toString()] = volume
-                        CoroutineScope(Dispatchers.IO).launch {
-                            emitVolumeEvent(dataSpec.uri.toString(), volume)
-                        }
+                        Log.d("LoudnessNormalization", "uri: ${dataSpec.uri}, measuredI: ${volume.measuredI}")
+                        LoudnessStorage.setLoudnessData(dataSpec.uri.toString(), volume.measuredI)
                     }
 
                     val headers = HashMap<String, String>()

package/android/src/main/java/expo/modules/orpheus/utils/{Storage.kt → GeneralStorage.kt}

@@ -11,7 +11,7 @@ import com.tencent.mmkv.MMKV
 import expo.modules.orpheus.models.TrackRecord
 
 @OptIn(UnstableApi::class)
-object Storage {
+object GeneralStorage {
     private var kv: MMKV? = null
     private val gson = Gson()
     private const val KEY_RESTORE_POSITION_ENABLED = "config_restore_position_enabled"

package/android/src/main/java/expo/modules/orpheus/utils/LoudnessStorage.kt

@@ -0,0 +1,40 @@
+package expo.modules.orpheus.utils
+
+import android.content.Context
+import android.util.Log
+import com.tencent.mmkv.MMKV
+
+object LoudnessStorage {
+    private var kv: MMKV? = null
+
+
+    @Synchronized
+    fun initialize(context: Context) {
+        if (kv == null) {
+            MMKV.initialize(context)
+            kv = MMKV.mmkvWithID("loudness_normalization_store")
+        }
+    }
+
+    private val safeKv: MMKV
+        get() = kv ?: throw IllegalStateException("LoudnessStorage not initialized")
+
+    fun setLoudnessData(key: String, measuredI: Double) {
+        try {
+            Log.d("LoudnessNormalization", "setLoudnessData: $key, $measuredI")
+            safeKv.encode(key, measuredI)
+        } catch (e: Exception) {
+            Log.e("LoudnessStorage", "Failed to set loudness data", e)
+        }
+    }
+
+    fun getLoudnessData(key: String): Double {
+        try {
+            Log.d("LoudnessNormalization", "getLoudnessData: $key")
+            return safeKv.decodeDouble(key)
+        } catch (e: Exception) {
+            Log.e("LoudnessStorage", "Failed to get loudness data", e)
+            return 0.0
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@roitium/expo-orpheus",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "A player for bbplayer",
   "main": "build/index.js",
   "types": "build/index.d.ts",