@roitium/expo-orpheus 0.9.4 → 0.10.1

package/ios/ExpoOrpheus.podspec

@@ -0,0 +1,29 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoOrpheus'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = {
+    :ios => '15.1',
+    :tvos => '15.1'
+  }
+  s.swift_version  = '5.9'
+  s.source         = { git: 'https://github.com/bbplayer-app/orpheus.git' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES'
+  }
+  
+  s.source_files = "**/*.{h,m,swift}"
+end

package/ios/ExpoOrpheusModule.swift

@@ -0,0 +1,228 @@
+import ExpoModulesCore
+
+public class ExpoOrpheusModule: Module {
+    
+    private func setupEventListeners() {
+        let manager = OrpheusPlayerManager.shared
+        
+        manager.onPlaybackStateChanged = { [weak self] state in
+            self?.sendEvent("onPlaybackStateChanged", ["state": state.rawValue])
+        }
+        
+        manager.onTrackStarted = { [weak self] trackId, reason in
+            self?.sendEvent("onTrackStarted", ["trackId": trackId, "reason": reason.rawValue])
+        }
+        
+        manager.onPositionUpdate = { [weak self] position, duration, buffered in
+            self?.sendEvent("onPositionUpdate", [
+                "position": position,
+                "duration": duration,
+                "buffered": buffered
+            ])
+        }
+        
+        OrpheusDownloadManager.shared.onDownloadUpdated = { [weak self] task in
+            self?.sendEvent("onDownloadUpdated", [
+                "id": task.id,
+                "state": task.state.rawValue,
+                "percentDownloaded": task.percentDownloaded,
+                "bytesDownloaded": task.bytesDownloaded,
+                "contentLength": task.contentLength
+            ])
+        }
+        
+        manager.onPlayerError = { [weak self] errorMsg in
+            self?.sendEvent("onPlayerError", ["error": errorMsg])
+        }
+        
+        manager.onIsPlayingChanged = { [weak self] isPlaying in
+            self?.sendEvent("onIsPlayingChanged", ["status": isPlaying])
+        }
+    }
+    
+    public func definition() -> ModuleDefinition {
+        Name("Orpheus")
+        
+        // Events
+        Events(
+            "onPlaybackStateChanged",
+            "onTrackStarted",
+            "onTrackFinished",
+            "onPlayerError",
+            "onPositionUpdate",
+            "onIsPlayingChanged",
+            "onDownloadUpdated",
+            "onPlaybackSpeedChanged"
+        )
+        
+        OnCreate {
+            self.setupEventListeners()
+        }
+
+        // MARK: - Preferences
+        
+        Property("restorePlaybackPositionEnabled")
+            .get { GeneralStorage.shared.isRestoreEnabled }
+            .set { GeneralStorage.shared.isRestoreEnabled = $0 }
+        
+        Property("loudnessNormalizationEnabled")
+            .get { GeneralStorage.shared.isLoudnessNormalizationEnabled }
+            .set { GeneralStorage.shared.isLoudnessNormalizationEnabled = $0 }
+        
+        Property("autoplayOnStartEnabled")
+            .get { GeneralStorage.shared.isAutoplayOnStartEnabled }
+            .set { GeneralStorage.shared.isAutoplayOnStartEnabled = $0 }
+        
+    // MARK: - Getters
+    
+    AsyncFunction("getPosition") { () -> Double in
+        return OrpheusPlayerManager.shared.getPosition()
+    }
+    
+    AsyncFunction("getDuration") { () -> Double in
+        return OrpheusPlayerManager.shared.getDuration()
+    }
+    
+    AsyncFunction("getBuffered") { () -> Double in
+        return OrpheusPlayerManager.shared.getBufferedPosition()
+    }
+    
+    AsyncFunction("getIsPlaying") { () -> Bool in
+        return OrpheusPlayerManager.shared.isPlaying()
+    }
+    
+    AsyncFunction("getCurrentIndex") { () -> Int in
+        return OrpheusPlayerManager.shared.getCurrentIndex()
+    }
+    
+    AsyncFunction("getCurrentTrack") { () -> Track? in
+        return OrpheusPlayerManager.shared.getCurrentTrack()
+    }
+    
+    AsyncFunction("getQueue") { () -> [Track] in
+        return OrpheusPlayerManager.shared.getQueue()
+    }
+    
+    AsyncFunction("getIndexTrack") { (index: Int) -> Track? in
+        return OrpheusPlayerManager.shared.getTrack(at: index)
+    }
+    
+    AsyncFunction("getPlaybackSpeed") { () -> Double in
+        return Double(OrpheusPlayerManager.shared.getPlaybackSpeed())
+    }
+    
+    AsyncFunction("getRepeatMode") { () -> Int in
+        return OrpheusPlayerManager.shared.repeatMode.rawValue
+    }
+    
+    AsyncFunction("getShuffleMode") { () -> Bool in
+        return OrpheusPlayerManager.shared.shuffleMode
+    }
+    
+    // MARK: - Controls
+    
+    AsyncFunction("play") {
+        OrpheusPlayerManager.shared.play()
+    }
+
+    AsyncFunction("pause") {
+        OrpheusPlayerManager.shared.pause()
+    }
+    
+    AsyncFunction("skipToNext") {
+        OrpheusPlayerManager.shared.playNext()
+    }
+    
+    AsyncFunction("skipToPrevious") {
+        OrpheusPlayerManager.shared.skipToPrevious()
+    }
+    
+    AsyncFunction("seekTo") { (seconds: Double) in
+        OrpheusPlayerManager.shared.seek(to: seconds)
+    }
+    
+    AsyncFunction("skipTo") { (index: Int) in
+        OrpheusPlayerManager.shared.skipTo(index: index)
+    }
+    
+    AsyncFunction("addToEnd") { (tracks: [Track], startFromId: String?, clearQueue: Bool) in
+        OrpheusPlayerManager.shared.addToEnd(tracks: tracks, startFromId: startFromId, clearQueue: clearQueue)
+    }
+    
+    AsyncFunction("playNext") { (track: Track) in
+        OrpheusPlayerManager.shared.addToNext(track: track)
+    }
+    
+    AsyncFunction("removeTrack") { (index: Int) in
+        OrpheusPlayerManager.shared.removeTrack(at: index)
+    }
+    
+    AsyncFunction("clear") {
+         OrpheusPlayerManager.shared.clearQueue()
+    }
+    
+    AsyncFunction("setPlaybackSpeed") { (speed: Double) in
+        OrpheusPlayerManager.shared.setPlaybackSpeed(Float(speed))
+    }
+    
+    Function("setBilibiliCookie") { (cookie: String) in
+        BilibiliApi.shared.setCookie(cookie)
+    }
+    
+    Function("setShuffleMode") { (enabled: Bool) in
+        OrpheusPlayerManager.shared.setExecuteShuffleMode(enabled)
+    }
+    
+    Function("setRepeatMode") { (mode: Int) in
+        if let repeatMode = RepeatMode(rawValue: mode) {
+            OrpheusPlayerManager.shared.setExecuteRepeatMode(repeatMode)
+        }
+    }
+    
+    Function("setSleepTimer") { (durationMs: Double) in
+        OrpheusPlayerManager.shared.setSleepTimer(durationMs: durationMs)
+    }
+    
+    Function("getSleepTimerEndTime") { () -> Double? in
+        return OrpheusPlayerManager.shared.getSleepTimerEndTime()
+    }
+    
+    Function("cancelSleepTimer") {
+        OrpheusPlayerManager.shared.cancelSleepTimer()
+    }
+    
+    // MARK: - Downloads
+    
+    Function("downloadTrack") { (track: Track) in
+        OrpheusDownloadManager.shared.downloadTrack(track: track)
+    }
+    
+    Function("multiDownload") { (tracks: [Track]) in
+        OrpheusDownloadManager.shared.multiDownload(tracks: tracks)
+    }
+    
+    Function("removeDownload") { (id: String) in
+        OrpheusDownloadManager.shared.removeDownload(id: id)
+    }
+    
+    Function("removeAllDownloads") {
+        OrpheusDownloadManager.shared.removeAllDownloads()
+    }
+    
+    Function("getDownloads") { () -> [DownloadTask] in
+        return OrpheusDownloadManager.shared.getDownloads()
+    }
+    
+    Function("getDownloadStatusByIds") { (ids: [String]) -> [String: Int] in
+        return OrpheusDownloadManager.shared.getDownloadStatusByIds(ids: ids)
+    }
+    
+    Function("clearUncompletedDownloadTasks") {
+        OrpheusDownloadManager.shared.clearUncompletedTasks()
+    }
+    
+    Function("getUncompletedDownloadTasks") { () -> [DownloadTask] in
+         return OrpheusDownloadManager.shared.getUncompletedTasks()
+    }
+  }
+}

package/ios/GeneralStorage.swift

@@ -0,0 +1,98 @@
+import Foundation
+
+class GeneralStorage {
+    static let shared = GeneralStorage()
+    
+    private let defaults = UserDefaults.standard
+    
+    private let KEY_SAVED_QUEUE = "saved_queue_json_list"
+    private let KEY_SAVED_INDEX = "saved_index"
+    private let KEY_SAVED_POSITION = "saved_position"
+    private let KEY_SAVED_REPEAT_MODE = "saved_repeat_mode"
+    private let KEY_SAVED_SHUFFLE_MODE = "saved_shuffle_mode"
+    
+    private let KEY_RESTORE_ENABLED = "restorePlaybackPositionEnabled"
+    private let KEY_LOUDNESS_ENABLED = "loudnessNormalizationEnabled"
+    private let KEY_AUTOPLAY_ENABLED = "autoplayOnStartEnabled"
+    private let KEY_DESKTOP_LYRICS_SHOWN = "isDesktopLyricsShown" // Not really used in iOS but following pattern
+    private let KEY_DESKTOP_LYRICS_LOCKED = "isDesktopLyricsLocked"
+    
+    // MARK: - Preferences
+    
+    var isRestoreEnabled: Bool {
+        get { return defaults.bool(forKey: KEY_RESTORE_ENABLED) }
+        set { defaults.set(newValue, forKey: KEY_RESTORE_ENABLED) }
+    }
+    
+    var isLoudnessNormalizationEnabled: Bool {
+        get { return defaults.bool(forKey: KEY_LOUDNESS_ENABLED) }
+        set { defaults.set(newValue, forKey: KEY_LOUDNESS_ENABLED) }
+    }
+    
+    var isAutoplayOnStartEnabled: Bool {
+        get { return defaults.bool(forKey: KEY_AUTOPLAY_ENABLED) }
+        set { defaults.set(newValue, forKey: KEY_AUTOPLAY_ENABLED) }
+    }
+    
+    // MARK: - Playback State
+    
+    func saveQueue(_ queue: [Track]) {
+        do {
+            let jsonList = try queue.compactMap { track -> String? in
+                let dict = track.dictionaryRepresentation
+                let data = try JSONSerialization.data(withJSONObject: dict, options: [])
+                return String(data: data, encoding: .utf8)
+            }
+            defaults.set(jsonList, forKey: KEY_SAVED_QUEUE)
+        } catch {
+
+        }
+    }
+    
+    func getSavedQueue() -> [Track] {
+        guard let jsonList = defaults.stringArray(forKey: KEY_SAVED_QUEUE) else { return [] }
+        
+        var restoredQueue: [Track] = []
+        for jsonStr in jsonList {
+            if let data = jsonStr.data(using: .utf8),
+               let dict = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any],
+               let track = Track(dictionary: dict) {
+                restoredQueue.append(track)
+            }
+        }
+        return restoredQueue
+    }
+    
+    func savePosition(index: Int, positionSec: Double) {
+        defaults.set(index, forKey: KEY_SAVED_INDEX)
+        
+        if !positionSec.isNaN && !positionSec.isInfinite {
+             let positionMs = Int64(positionSec * 1000)
+             defaults.set(positionMs, forKey: KEY_SAVED_POSITION)
+        }
+    }
+    
+    func getSavedIndex() -> Int {
+        return defaults.integer(forKey: KEY_SAVED_INDEX)
+    }
+    
+    func getSavedPosition() -> Double {
+        return defaults.double(forKey: KEY_SAVED_POSITION) / 1000.0
+    }
+    
+    func saveRepeatMode(_ mode: Int) {
+        defaults.set(mode, forKey: KEY_SAVED_REPEAT_MODE)
+    }
+    
+    func getSavedRepeatMode() -> Int {
+        return defaults.integer(forKey: KEY_SAVED_REPEAT_MODE)
+    }
+    
+    func saveShuffleMode(_ enabled: Bool) {
+        defaults.set(enabled, forKey: KEY_SAVED_SHUFFLE_MODE)
+    }
+    
+    func getSavedShuffleMode() -> Bool {
+        return defaults.bool(forKey: KEY_SAVED_SHUFFLE_MODE)
+    }
+}