@roitium/expo-orpheus 0.1.0

package/.eslintrc.js

@@ -0,0 +1,5 @@
+module.exports = {
+  root: true,
+  extends: ['universe/native', 'universe/web'],
+  ignorePatterns: ['build'],
+};

package/README.md

@@ -0,0 +1,11 @@
+# Orpheus
+
+**BBPlayer 内部音频模块**
+
+这是一个为 BBPlayer 项目构建的高性能定制音频播放库。旨在替代 `react-native-track-player`，以提供与 Android Media3 (ExoPlayer) 更紧密的集成，并针对 Bilibili 音频流逻辑提供了原生层支持。
+
+## 与 B 站集成
+
+通过 `Orpheus.setBilibiliCookie()` 设置 cookie，稍后会自动用于音频流请求。（不设置也行，只是无法获取高码率的音频）
+
+Orpheus 通过特殊的 uri 识别来自 bilibili 的资源，格式为 `orpheus://bilibili?bvid=xxx&cid=111&quality=30280&dolby=0&hires=0`，若不提供 cid 则默认请求第一个分 p。quality 参考 b 站 api。

package/android/build.gradle

@@ -0,0 +1,51 @@
+apply plugin: 'com.android.library'
+
+group = 'expo.modules.orpheus'
+version = '0.1.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useExpoPublishing()
+
+// If you want to use the managed Android SDK versions from expo-modules-core, set this to true.
+// The Android SDK versions will be bumped from time to time in SDK releases and may introduce breaking changes in your module code.
+// Most of the time, you may like to manage the Android SDK versions yourself.
+def useManagedAndroidSdkVersions = false
+if (useManagedAndroidSdkVersions) {
+  useDefaultAndroidSdkVersions()
+} else {
+  buildscript {
+    // Simple helper that allows the root project to override versions declared by this library.
+    ext.safeExtGet = { prop, fallback ->
+      rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+  }
+  project.android {
+    compileSdkVersion safeExtGet("compileSdkVersion", 36)
+    defaultConfig {
+      minSdkVersion safeExtGet("minSdkVersion", 24)
+      targetSdkVersion safeExtGet("targetSdkVersion", 36)
+    }
+  }
+}
+
+android {
+  namespace "expo.modules.orpheus"
+  defaultConfig {
+    versionCode 1
+    versionName "0.1.0"
+  }
+  lintOptions {
+    abortOnError false
+  }
+}
+
+dependencies {
+    implementation "androidx.media3:media3-exoplayer:1.8.0"
+    implementation "androidx.media3:media3-session:1.8.0"
+    implementation "com.squareup.retrofit2:retrofit:3.1.0-SNAPSHOT"
+    implementation "com.google.code.gson:gson:2.13.2"
+    implementation "com.squareup.retrofit2:converter-gson:3.1.0-SNAPSHOT"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,21 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <application>
+        <service
+            android:name=".OrpheusService"
+            android:enabled="true"
+            android:exported="true"
+            android:foregroundServiceType="mediaPlayback">
+            <intent-filter>
+                <action android:name="androidx.media3.session.MediaLibraryService" />
+                <action android:name="android.media.browse.MediaBrowserService" />
+            </intent-filter>
+        </service>
+    </application>
+</manifest>

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

@@ -0,0 +1,365 @@
+package expo.modules.orpheus
+
+import android.content.ComponentName
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import androidx.core.net.toUri
+import androidx.media3.common.C
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.PlaybackException
+import androidx.media3.common.Player
+import androidx.media3.session.MediaController
+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.functions.Queues
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class ExpoOrpheusModule : Module() {
+    companion object {
+        val TAG = "Orpheus"
+    }
+
+    private var controllerFuture: ListenableFuture<MediaController>? = null
+
+    private var controller: MediaController? = null
+
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    // 记录上一首歌曲的 ID，用于在切歌时发送给 JS
+    private var lastMediaId: String? = null
+
+    val gson = Gson()
+
+    override fun definition() = ModuleDefinition {
+        Name("Orpheus")
+
+        Events(
+            "onPlaybackStateChanged",
+            "onTrackTransition",
+            "onPlayerError",
+            "onPositionUpdate",
+            "onIsPlayingChanged"
+        )
+
+        OnCreate {
+            val context = appContext.reactContext ?: return@OnCreate
+            val sessionToken = SessionToken(
+                context,
+                ComponentName(context, OrpheusService::class.java)
+            )
+            controllerFuture = MediaController.Builder(context, sessionToken)
+                .setApplicationLooper(Looper.getMainLooper()).buildAsync()
+
+            controllerFuture?.addListener({
+                try {
+                    controller = controllerFuture?.get()
+                    setupListeners()
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+            }, MoreExecutors.directExecutor())
+        }
+
+        OnDestroy {
+            stopProgressUpdater()
+            controllerFuture?.let { MediaController.releaseFuture(it) }
+        }
+
+        AsyncFunction("getPosition") {
+            controller?.currentPosition?.toDouble()?.div(1000.0) ?: 0.0
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("getDuration") {
+            val d = controller?.duration ?: C.TIME_UNSET
+            if (d == C.TIME_UNSET) 0.0 else d.toDouble() / 1000.0
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("getIsPlaying") {
+            controller?.isPlaying ?: false
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("getCurrentIndex") {
+            controller?.currentMediaItemIndex ?: -1
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("getCurrentTrack") {
+            val player = controller ?: return@AsyncFunction null
+            val currentItem = player.currentMediaItem ?: return@AsyncFunction null
+
+            mediaItemToTrackRecord(currentItem)
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("getShuffleMode") {
+            controller?.shuffleModeEnabled
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("getIndexTrack") { index: Int ->
+            val player = controller ?: return@AsyncFunction null
+
+            if (index < 0 || index >= player.mediaItemCount) {
+                return@AsyncFunction null
+            }
+
+            val item = player.getMediaItemAt(index)
+
+            mediaItemToTrackRecord(item)
+        }.runOnQueue(Queues.MAIN)
+
+        Function("setBilibiliCookie") { cookie: String ->
+            OrpheusConfig.bilibiliCookie = cookie
+        }
+
+        AsyncFunction("play") {
+            val player = controller
+            if (player != null) {
+                // 获取 player 真正归属的 Looper
+                val playerLooper = player.applicationLooper
+
+                if (Looper.myLooper() == playerLooper) {
+                    player.play()
+                } else {
+                    Handler(playerLooper).post {
+                        player.play()
+                    }
+                }
+            }
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("pause") {
+            controller?.pause()
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("clear") {
+            controller?.clearMediaItems()
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("skipTo") { index: Int ->
+            // 跳转到指定索引的开头
+            controller?.seekTo(index, C.TIME_UNSET)
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("skipToNext") {
+            if (controller?.hasNextMediaItem() == true) {
+                controller?.seekToNextMediaItem()
+            }
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("skipToPrevious") {
+            if (controller?.hasPreviousMediaItem() == true) {
+                controller?.seekToPreviousMediaItem()
+            }
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("seekTo") { seconds: Double ->
+            val ms = (seconds * 1000).toLong()
+            controller?.seekTo(ms)
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("setRepeatMode") { mode: Int ->
+            // 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
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("setShuffleMode") { enabled: Boolean ->
+            controller?.shuffleModeEnabled = enabled
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("getQueue") {
+            val player = controller ?: return@AsyncFunction emptyList<TrackRecord>()
+            val count = player.mediaItemCount
+            val queue = ArrayList<TrackRecord>(count)
+
+            for (i in 0 until count) {
+                val item = player.getMediaItemAt(i)
+                queue.add(mediaItemToTrackRecord(item))
+            }
+
+            return@AsyncFunction queue
+        }.runOnQueue(Queues.MAIN)
+
+        AsyncFunction("add") { tracks: List<TrackRecord> ->
+            // 1. 【后台线程】执行：JSON 转换、Metadata 构建 (耗时操作在这里做，不卡 UI)
+            // 这里不需要改，继续在当前线程跑
+            val mediaItems = tracks.mapNotNull { track ->
+                try {
+                    val trackJson = gson.toJson(track)
+                    val extras = Bundle()
+                    extras.putString("track_json", trackJson)
+
+                    val artUri =
+                        if (!track.artwork.isNullOrEmpty()) track.artwork!!.toUri() else null
+
+                    val metadata = MediaMetadata.Builder()
+                        .setTitle(track.title)
+                        .setArtist(track.artist)
+                        .setArtworkUri(artUri)
+                        .setExtras(extras)
+                        .build()
+
+                    MediaItem.Builder()
+                        .setMediaId(track.id)
+                        .setUri(track.url ?: "")
+                        .setMediaMetadata(metadata)
+                        .build()
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                    null
+                }
+            }
+
+            val player = controller
+            if (player != null) {
+                // 获取 player 真正归属的 Looper
+                val playerLooper = player.applicationLooper
+
+                if (Looper.myLooper() == playerLooper) {
+                    player.addMediaItems(mediaItems)
+                    if (player.playbackState == Player.STATE_IDLE) {
+                        player.prepare()
+                    }
+                } else {
+                    Handler(playerLooper).post {
+                        player.addMediaItems(mediaItems)
+                        if (player.playbackState == Player.STATE_IDLE) {
+                            player.prepare()
+                        }
+                    }
+                }
+            }
+        }.runOnQueue(Queues.MAIN)
+    }
+
+    private fun setupListeners() {
+        controller?.addListener(object : Player.Listener {
+
+            /**
+             * 核心：处理切歌、播放结束逻辑
+             */
+            override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
+                val currentTrackId = mediaItem?.mediaId ?: ""
+                Player.MEDIA_ITEM_TRANSITION_REASON_AUTO
+
+                sendEvent(
+                    "onTrackTransition", mapOf(
+                        "currentTrackId" to currentTrackId,
+                        "previousTrackId" to lastMediaId, // 上一首歌是什么
+                        "reason" to reason
+                    )
+                )
+
+                // 更新本地记录，为下一次切歌做准备
+                lastMediaId = currentTrackId
+            }
+
+            /**
+             * 处理播放状态改变
+             */
+            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")
+                    )
+                )
+            }
+        })
+    }
+
+    private val progressRunnable = object : Runnable {
+        override fun run() {
+            val player = controller ?: return
+
+            if (player.isPlaying) {
+                val currentMs = player.currentPosition
+                val durationMs = player.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
+                    )
+                )
+            }
+
+            mainHandler.postDelayed(this, 200)
+        }
+    }
+
+    private fun updateProgressRunnerState() {
+        val player = controller
+        // 如果正在播放且状态是 READY，则开始轮询
+        if (player != null && player.isPlaying && player.playbackState == Player.STATE_READY) {
+            startProgressUpdater()
+        } else {
+            stopProgressUpdater()
+        }
+    }
+
+    private fun startProgressUpdater() {
+        mainHandler.removeCallbacks(progressRunnable)
+        mainHandler.post(progressRunnable)
+    }
+
+    private fun stopProgressUpdater() {
+        mainHandler.removeCallbacks(progressRunnable)
+    }
+
+    private fun mediaItemToTrackRecord(item: MediaItem): TrackRecord {
+        val extras = item.mediaMetadata.extras
+        val trackJson = extras?.getString("track_json")
+
+        if (trackJson != null) {
+            try {
+                return gson.fromJson(trackJson, TrackRecord::class.java)
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+
+        val track = TrackRecord()
+        track.id = item.mediaId
+        track.url = item.localConfiguration?.uri?.toString() ?: ""
+        track.title = item.mediaMetadata.title?.toString()
+        track.artist = item.mediaMetadata.artist?.toString()
+        track.artwork = item.mediaMetadata.artworkUri?.toString()
+
+        return track
+    }
+}

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

@@ -0,0 +1,46 @@
+package expo.modules.orpheus
+
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+import okhttp3.Response
+import retrofit2.Retrofit
+import retrofit2.converter.gson.GsonConverterFactory
+import java.util.concurrent.TimeUnit
+
+object NetworkModule {
+    private const val BASE_URL = "https://api.bilibili.com"
+
+    private val client: OkHttpClient by lazy {
+        OkHttpClient.Builder()
+            .connectTimeout(10, TimeUnit.SECONDS)
+            .readTimeout(10, TimeUnit.SECONDS)
+            .writeTimeout(10, TimeUnit.SECONDS)
+
+            .addInterceptor(BilibiliHeaderInterceptor())
+            .build()
+    }
+
+    val retrofit: Retrofit by lazy {
+        Retrofit.Builder()
+            .baseUrl(BASE_URL)
+            .client(client)
+            .addConverterFactory(GsonConverterFactory.create()) // 自动 JSON 解析
+            .build()
+    }
+
+    private class BilibiliHeaderInterceptor : Interceptor {
+        override fun intercept(chain: Interceptor.Chain): Response {
+            val originalRequest = chain.request()
+
+            val newRequest = originalRequest.newBuilder()
+                .header(
+                    "User-Agent",
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+                )
+                .header("Referer", "https://www.bilibili.com/")
+                .build()
+
+            return chain.proceed(newRequest)
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+package expo.modules.orpheus
+
+object OrpheusConfig {
+    var bilibiliCookie: String? = null
+}

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

@@ -0,0 +1,142 @@
+package expo.modules.orpheus
+
+import androidx.annotation.OptIn
+import androidx.core.net.toUri
+import androidx.media3.common.AudioAttributes
+import androidx.media3.common.C
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.DataSpec
+import androidx.media3.datasource.DefaultHttpDataSource
+import androidx.media3.datasource.ResolvingDataSource
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
+import androidx.media3.session.MediaLibraryService
+import androidx.media3.session.MediaSession
+import com.google.common.util.concurrent.Futures
+import com.google.common.util.concurrent.ListenableFuture
+import expo.modules.orpheus.bilibili.BilibiliRepository
+import java.io.IOException
+
+class OrpheusService : MediaLibraryService() {
+
+    private var player: ExoPlayer? = null
+    private var mediaSession: MediaLibrarySession? = null
+
+    @OptIn(UnstableApi::class)
+    override fun onCreate() {
+        super.onCreate()
+        val httpDataSourceFactory = DefaultHttpDataSource.Factory()
+            .setUserAgent("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36")
+            .setAllowCrossProtocolRedirects(true)
+
+        val resolvingDataSourceFactory = ResolvingDataSource.Factory(
+            httpDataSourceFactory,
+            object : ResolvingDataSource.Resolver {
+                // TODO: maybe we need to add a cache?
+                override fun resolveDataSpec(dataSpec: DataSpec): DataSpec {
+                    val uri = dataSpec.uri
+
+                    // orpheus://bilibili?bvid=bv123124&cid=114514&quality=30280&dolby=0&hires=0
+                    if (uri.scheme == "orpheus" && uri.host == "bilibili") {
+                        try {
+                            val bvid = uri.getQueryParameter("bvid")
+                            val cid = uri.getQueryParameter("cid")?.toLongOrNull()
+                            val quality = uri.getQueryParameter("quality")?.toIntOrNull() ?: 30280
+                            val enableDolby = uri.getQueryParameter("dolby") == "1"
+                            val enableHiRes = uri.getQueryParameter("hires") == "1"
+
+                            if (bvid == null) {
+                                throw IOException("Invalid Bilibili Params: bvid=$bvid, cid=$cid")
+                            }
+
+                            val realUrl = BilibiliRepository.resolveAudioUrl(
+                                bvid = bvid,
+                                cid = cid,
+                                audioQuality = quality,
+                                enableDolby = enableDolby,
+                                enableHiRes = enableHiRes,
+                                cookie = OrpheusConfig.bilibiliCookie
+                            )
+
+                            val headers = HashMap<String, String>()
+                            headers["Referer"] = "https://www.bilibili.com/"
+
+                            return dataSpec.buildUpon()
+                                .setUri(realUrl.toUri())
+                                .setHttpRequestHeaders(headers)
+                                .build()
+                        } catch (e: Exception) {
+                            throw IOException("Resolve Url Failed: ${e.message}", e)
+                        }
+                    }
+
+                    return dataSpec
+                }
+            }
+        )
+
+        val mediaSourceFactory = DefaultMediaSourceFactory(this)
+            .setDataSourceFactory(resolvingDataSourceFactory)
+
+        player = ExoPlayer.Builder(this)
+            .setMediaSourceFactory(mediaSourceFactory)
+            .setAudioAttributes(
+                AudioAttributes.Builder()
+                    .setUsage(C.USAGE_MEDIA)
+                    .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
+                    .build(),
+                true
+            )
+            .build()
+
+        mediaSession = MediaLibrarySession.Builder(this, player!!, callback)
+            .setId("OrpheusSession")
+            .build()
+    }
+
+    override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaLibrarySession? {
+        return mediaSession
+    }
+
+    override fun onDestroy() {
+        mediaSession?.run {
+            player.release()
+            release()
+            mediaSession = null
+        }
+        super.onDestroy()
+    }
+
+    var callback: MediaLibrarySession.Callback = @UnstableApi
+    object : MediaLibrarySession.Callback {
+        @OptIn(UnstableApi::class)
+        override fun onConnect(
+            session: MediaSession,
+            controller: MediaSession.ControllerInfo
+        ): MediaSession.ConnectionResult {
+            val sessionCommands = MediaSession.ConnectionResult.DEFAULT_SESSION_COMMANDS.buildUpon()
+                .build()
+
+            return MediaSession.ConnectionResult.AcceptedResultBuilder(session)
+                .setAvailableSessionCommands(sessionCommands)
+                .build()
+        }
+
+        /**
+         * 修复 UnsupportedOperationException 的关键！
+         * 当系统尝试恢复播放（比如从“最近播放”卡片点击）时触发。
+         */
+        override fun onPlaybackResumption(
+            mediaSession: MediaSession,
+            controller: MediaSession.ControllerInfo
+        ): ListenableFuture<MediaSession.MediaItemsWithStartPosition> {
+            return Futures.immediateFuture(
+                MediaSession.MediaItemsWithStartPosition(
+                    emptyList(), // 没有媒体项
+                    C.INDEX_UNSET, // 索引未定
+                    C.TIME_UNSET   // 进度未定
+                )
+            )
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+package expo.modules.orpheus
+
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+class TrackRecord : Record {
+    @Field
+    var id: String = ""
+
+    @Field
+    var url: String = ""
+
+    @Field
+    var title: String? = null
+
+    @Field
+    var artist: String? = null
+
+    @Field
+    var artwork: String? = null
+
+    // unit: second
+    @Field
+    var duration: Double? = null
+
+    // @Field
+    // var loudness: Map<String, Any>? = null
+}