@javascriptcommon/react-native-track-player 1.2.23 → 4.1.5

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/AudioSessionController/AudioSessionController.swift

@@ -0,0 +1,135 @@
+//
+//  AudioSessionController.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 19/03/2018.
+//
+
+import Foundation
+import AVFoundation
+
+public enum InterruptionType: Equatable {
+    case began
+    case ended(shouldResume: Bool)
+}
+
+#if os(iOS)
+
+public protocol AudioSessionControllerDelegate: AnyObject {
+    func handleInterruption(type: InterruptionType)
+}
+
+/**
+ Simple controller for the `AVAudioSession`. If you need more advanced options, just use the `AVAudioSession` directly.
+ - warning: Do not combine usage of this and `AVAudioSession` directly, chose one.
+ */
+public class AudioSessionController {
+    
+    public static let shared = AudioSessionController()
+    
+    private let audioSession: AudioSession
+    private let notificationCenter: NotificationCenter = NotificationCenter.default
+    private var _isObservingForInterruptions: Bool = false
+    
+    /**
+     True if another app is currently playing audio.
+     */
+    public var isOtherAudioPlaying: Bool {
+        audioSession.isOtherAudioPlaying
+    }
+    
+    /**
+     True if the audiosession is active.
+     
+     - warning: This will only be correct if the audiosession is activated through this class!
+     */
+    public var audioSessionIsActive: Bool = false
+    
+    /**
+     Wheter notifications for interruptions are being observed or not.
+     This is enabled by default.
+     Set this to false to disable the behaviour.
+     */
+    public var isObservingForInterruptions: Bool {
+        get { _isObservingForInterruptions }
+        set {
+            if newValue == _isObservingForInterruptions {
+                return
+            }
+            
+            if newValue {
+                registerForInterruptionNotification()
+            }
+            else {
+                unregisterForInterruptionNotification()
+            }
+        }
+    }
+    
+    public weak var delegate: AudioSessionControllerDelegate?
+    
+    init(audioSession: AudioSession = AVAudioSession.sharedInstance()) {
+        self.audioSession = audioSession
+        registerForInterruptionNotification()
+    }
+    
+    public func activateSession() throws {
+        do {
+            try audioSession.setActive(true, options: [])
+            audioSessionIsActive = true
+        }
+        catch let error { throw error }
+    }
+    
+    public func deactivateSession() throws {
+        do {
+            try audioSession.setActive(false, options: [])
+            audioSessionIsActive = false
+        }
+        catch let error { throw error }
+    }
+    
+    public func set(category: AVAudioSession.Category) throws {
+        try audioSession.setCategory(category, mode: audioSession.mode, options: audioSession.categoryOptions)
+    }
+    
+    // MARK: - Interruptions
+    
+    private func registerForInterruptionNotification() {
+        notificationCenter.addObserver(self,
+                                       selector: #selector(handleInterruption),
+                                       name: AVAudioSession.interruptionNotification,
+                                       object: nil)
+        _isObservingForInterruptions = true
+    }
+    
+    private func unregisterForInterruptionNotification() {
+        notificationCenter.removeObserver(self, name: AVAudioSession.interruptionNotification, object: nil)
+        _isObservingForInterruptions = false
+    }
+    
+    @objc func handleInterruption(notification: Notification) {
+        guard let userInfo = notification.userInfo,
+            let typeValue = userInfo[AVAudioSessionInterruptionTypeKey] as? UInt,
+            let type = AVAudioSession.InterruptionType(rawValue: typeValue) else {
+                return
+        }
+        
+        switch type {
+        case .began:
+            delegate?.handleInterruption(type: .began)
+        case .ended:
+            guard let typeValue = userInfo[AVAudioSessionInterruptionOptionKey] as? UInt else {
+                delegate?.handleInterruption(type: .ended(shouldResume: false))
+                return
+            }
+            
+            let options = AVAudioSession.InterruptionOptions(rawValue: typeValue)
+            delegate?.handleInterruption(type: .ended(shouldResume: options.contains(.shouldResume)))
+        @unknown default: return
+        }
+    }
+    
+}
+
+#endif

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/AudioTap.swift

@@ -0,0 +1,96 @@
+//
+//  AudioTap.swift
+//
+//
+//  Created by Brandon Sneed on 3/31/24.
+//
+
+import Foundation
+import AVFoundation
+
+/**
+ Subclass this and set the AudioPlayer's `audioTap` property to start receiving the
+ audio stream.
+ */
+open class AudioTap {
+    // Called at tap initialization for a given player item. Use this to setup anything you might need.
+    open func initialize() { print("audioTap: initialize") }
+    // Called at teardown of the internal tap.  Use this to reset any memory buffers you have created, etc.
+    open func finalize() { print("audioTap: finalize") }
+    // Called just before playback so you can perform setup based on the stream description.
+    open func prepare(description: AudioStreamBasicDescription) { print("audioTap: prepare") }
+    // Called just before finalize.
+    open func unprepare() { print("audioTap: unprepare") }
+    /**
+     Called periodically during audio stream              – playback.
+     
+     Example:
+     
+     ```
+     func process(numberOfFrames: Int, buffer: UnsafeMutableAudioBufferListPointer) {
+         for channel in buffer {
+             // process audio samples here
+             //memset(channel.mData, 0, Int(channel.mDataByteSize))
+         }
+     }
+     ```
+    */
+    open func process(numberOfFrames: Int, buffer: UnsafeMutableAudioBufferListPointer) { print("audioTap: process") }
+}
+
+extension AVPlayerWrapper {
+    internal func attachTap(_ tap: AudioTap?, to item: AVPlayerItem) {
+        guard let tap else { return }
+        guard let track = item.asset.tracks(withMediaType: .audio).first else {
+            return
+        }
+        
+        let audioMix = AVMutableAudioMix()
+        let params = AVMutableAudioMixInputParameters(track: track)
+        
+        // we need to retain this pointer so it doesn't disappear out from under us.
+        // we'll then let it go after we finalize.  If the tap changed upstream, we
+        // aren't going to pick up the new one until after this player item goes away.
+        let client = UnsafeMutableRawPointer(Unmanaged.passRetained(tap).toOpaque())
+        
+        var callbacks = MTAudioProcessingTapCallbacks(version: kMTAudioProcessingTapCallbacksVersion_0, clientInfo: client)
+        { tapRef, clientInfo, tapStorageOut in
+            // initial tap setup
+            guard let clientInfo else { return }
+            tapStorageOut.pointee = clientInfo
+            let audioTap = Unmanaged<AudioTap>.fromOpaque(clientInfo).takeUnretainedValue()
+            audioTap.initialize()
+        } finalize: { tapRef in
+            // clean up
+            let audioTap = Unmanaged<AudioTap>.fromOpaque(MTAudioProcessingTapGetStorage(tapRef)).takeUnretainedValue()
+            audioTap.finalize()
+            // we're done, we can let go of the pointer we retained.
+            Unmanaged.passUnretained(audioTap).release()
+        } prepare: { tapRef, maxFrames, processingFormat in
+            // allocate memory for sound processing
+            let audioTap = Unmanaged<AudioTap>.fromOpaque(MTAudioProcessingTapGetStorage(tapRef)).takeUnretainedValue()
+            audioTap.prepare(description: processingFormat.pointee)
+        } unprepare: { tapRef in
+            // deallocate memory for sound processing
+            let audioTap = Unmanaged<AudioTap>.fromOpaque(MTAudioProcessingTapGetStorage(tapRef)).takeUnretainedValue()
+            audioTap.unprepare()
+        } process: { tapRef, numberFrames, flags, bufferListInOut, numberFramesOut, flagsOut in
+            guard noErr == MTAudioProcessingTapGetSourceAudio(tapRef, numberFrames, bufferListInOut, flagsOut, nil, numberFramesOut) else {
+                return
+            }
+            
+            // process sound data
+            let audioTap = Unmanaged<AudioTap>.fromOpaque(MTAudioProcessingTapGetStorage(tapRef)).takeUnretainedValue()
+            audioTap.process(numberOfFrames: numberFrames, buffer: UnsafeMutableAudioBufferListPointer(bufferListInOut))
+        }
+        
+        var tapRef: MTAudioProcessingTap?
+        let error = MTAudioProcessingTapCreate(kCFAllocatorDefault, &callbacks, kMTAudioProcessingTapCreationFlag_PreEffects, &tapRef)
+        assert(error == noErr)
+        
+        params.audioTapProcessor = tapRef
+        
+        audioMix.inputParameters = [params]
+        item.audioMix = audioMix
+    }
+}

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/Event.swift

@@ -0,0 +1,155 @@
+//
+//  Event.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 09/03/2019.
+//
+
+import Foundation
+import MediaPlayer
+
+extension AudioPlayer {
+    
+    public typealias PlayWhenReadyChangeData = Bool
+    public typealias StateChangeEventData = AudioPlayerState
+    public typealias PlaybackEndEventData = PlaybackEndedReason
+    public typealias SecondElapseEventData = TimeInterval
+    public typealias FailEventData = Error?
+    public typealias SeekEventData = (seconds: Double, didFinish: Bool)
+    public typealias UpdateDurationEventData = Double
+    public typealias MetadataCommonEventData = [AVMetadataItem]
+    public typealias MetadataTimedEventData = [AVTimedMetadataGroup]
+    public typealias DidRecreateAVPlayerEventData = ()
+    public typealias CurrentItemEventData = (
+        item: AudioItem?,
+        index: Int?,
+        lastItem: AudioItem?,
+        lastIndex: Int?,
+        lastPosition: Double?
+    )
+    
+    public struct EventHolder {
+        
+        /**
+         Emitted when the `AudioPlayer`s state is changed
+         - Important: Remember to dispatch to the main queue if any UI is updated in the event handler.
+         */
+        public let stateChange: AudioPlayer.Event<StateChangeEventData> = AudioPlayer.Event()
+
+        /**
+         Emitted when the `AudioPlayer#playWhenReady` has changed
+         - Important: Remember to dispatch to the main queue if any UI is updated in the event handler.
+         */
+        public let playWhenReadyChange: AudioPlayer.Event<PlayWhenReadyChangeData> = AudioPlayer.Event()
+        
+        /**
+         Emitted when the playback of the player, for some reason, has stopped.
+         - Important: Remember to dispatch to the main queue if any UI is updated in the event handler.
+         */
+        public let playbackEnd: AudioPlayer.Event<PlaybackEndEventData> = AudioPlayer.Event()
+        
+        /**
+         Emitted when a second is elapsed in the `AudioPlayer`.
+         - Important: Remember to dispatch to the main queue if any UI is updated in the event handler.
+         */
+        public let secondElapse: AudioPlayer.Event<SecondElapseEventData> = AudioPlayer.Event()
+        
+        /**
+         Emitted when the player encounters an error. This will ultimately result in the AVPlayer instance to be recreated.
+         If this event is emitted, it means you will need to load a new item in some way. Calling play() will not resume playback.
+         - Important: Remember to dispatch to the main queue if any UI is updated in the event handler.
+         */
+        public let fail: AudioPlayer.Event<FailEventData> = AudioPlayer.Event()
+        
+        /**
+         Emitted when the player is done attempting to seek.
+         - Important: Remember to dispatch to the main queue if any UI is updated in the event handler.
+         */
+        public let seek: AudioPlayer.Event<SeekEventData> = AudioPlayer.Event()
+        
+        /**
+         Emitted when the player updates its duration.
+         - Important: Remember to dispatch to the main queue if any UI is updated in the event handler.
+         */
+        public let updateDuration: AudioPlayer.Event<UpdateDurationEventData> = AudioPlayer.Event()
+
+        /**
+         Emitted when the player receives common metadata.
+         - Important: Remember to dispatch to the main queue if any UI is updated in the event handler.
+         */
+        public let receiveCommonMetadata: AudioPlayer.Event<MetadataCommonEventData> = AudioPlayer.Event()
+        
+        /**
+         Emitted when the player receives timed metadata.
+         - Important: Remember to dispatch to the main queue if any UI is updated in the event handler.
+         */
+        public let receiveTimedMetadata: AudioPlayer.Event<MetadataTimedEventData> = AudioPlayer.Event()
+        
+        /**
+         Emitted when the player receives chapter metadata.
+         - Important: Remember to dispatch to the main queue if any UI is updated in the event handler.
+         */
+        public let receiveChapterMetadata: AudioPlayer.Event<MetadataTimedEventData> = AudioPlayer.Event()
+        
+        /**
+         Emitted when the underlying AVPlayer instance is recreated. Recreation happens if the current player fails.
+         - Important: Remember to dispatch to the main queue if any UI is updated in the event handler.
+         - Note: It can be necessary to set the AVAudioSession's category again when this event is emitted.
+         */
+        public let didRecreateAVPlayer: AudioPlayer.Event<()> = AudioPlayer.Event()
+
+        /**
+         Emitted when the current track has changed.
+         - Important: Remember to dispatch to the main queue if any UI is updated in the event handler.
+         - Note: It is only fired for instances of a QueuedAudioPlayer.
+         */
+        public let currentItem: AudioPlayer.Event<CurrentItemEventData> = AudioPlayer.Event()
+    }
+    
+    public typealias EventClosure<EventData> = (EventData) -> Void
+    
+    class Invoker<EventData> {
+        
+        // Signals false if the listener object is nil
+        let invoke: (EventData) -> Bool
+        weak var listener: AnyObject?
+        
+        init<Listener: AnyObject>(listener: Listener, closure: @escaping EventClosure<EventData>) {
+            self.listener = listener
+            invoke = { [weak listener] (data: EventData) in
+                guard let _ = listener else {
+                    return false
+                }
+                closure(data)
+                return true
+            }
+        }
+        
+    }
+    
+    public class Event<EventData> {
+        private let queue: DispatchQueue = DispatchQueue(label: "com.swiftAudioEx.eventQueue")
+        var invokers: [Invoker<EventData>] = []
+        
+        public func addListener<Listener: AnyObject>(_ listener: Listener, _ closure: @escaping EventClosure<EventData>) {
+            queue.async {
+                self.invokers.append(Invoker(listener: listener, closure: closure))
+            }
+        }
+        
+        public func removeListener(_ listener: AnyObject) {
+            queue.async {
+                self.invokers = self.invokers.filter({ (invoker) -> Bool in
+                    return invoker.listener !== listener
+                })
+            }
+        }
+        
+        func emit(data: EventData) {
+            queue.async {
+                self.invokers = self.invokers.filter { $0.invoke(data) }
+            }
+        }
+    }
+    
+}

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/NowPlayingInfoController/MediaItemProperty.swift

@@ -0,0 +1,95 @@
+//
+//  MediaItemProperty.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 15/03/2018.
+//
+
+import Foundation
+import MediaPlayer
+
+
+/**
+ Enum representing MPMediaItemProperties.
+ Docs for each property is taken from [Apple docs](https://developer.apple.com/documentation/mediaplayer/mpmediaitem/general_media_item_property_keys)
+ */
+public enum MediaItemProperty: NowPlayingInfoKeyValue {
+    
+    /**
+     The performing artist(s) for a media item—which may vary from the primary artist for the album that a media item belongs to.
+     
+     For example, if the album artist is “Joseph Fable,” the artist for one of the songs in the album may be “Joseph Fable featuring Thomas Smithson”. Value is an NSString object.
+     */
+    case artist(String?)
+
+
+    /**
+     The title (or name) of the media item.
+     
+     This property is unrelated to the MPMediaItemPropertyAlbumTitle property. Value is an NSString object.
+     */
+    case title(String?)
+    
+    /**
+     The title of an album.
+     
+     This property contains the album title, such as “Live On Mars”, as opposed to the title of an individual song on the album, such as “Crater Dance (radio edit)” (which you specify using the MPMediaItemPropertyTitle property). Value is an NSString object.
+     */
+    case albumTitle(String?)
+
+    /**
+     The playback duration of the media item.
+     Value is an NSNumber object representing a duration in seconds as an TimeInterval.
+     */
+    case duration(TimeInterval?)
+        
+
+    /**
+     The artwork image for the media item.
+     */
+    case artwork(MPMediaItemArtwork?)
+
+    public func getKey() -> String {
+        switch self {
+            
+        case .artist(_):
+            return MPMediaItemPropertyArtist
+            
+        case .title(_):
+            return MPMediaItemPropertyTitle
+            
+        case .albumTitle(_):
+            return MPMediaItemPropertyAlbumTitle
+            
+        case .duration(_):
+            return MPMediaItemPropertyPlaybackDuration
+            
+        case .artwork(_):
+            return MPMediaItemPropertyArtwork
+
+        }
+    }
+
+    public func getValue() -> Any? {
+        switch self {
+            
+        case .artist(let artist):
+            return artist
+            
+        case .title(let title):
+            return title
+            
+        case .albumTitle(let title):
+            return title
+            
+        case .duration(let duration):
+            return duration != nil ? NSNumber(floatLiteral: duration!) : nil
+            
+        case .artwork(let artwork):
+            return artwork
+
+        }
+    }
+
+}
+

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/NowPlayingInfoController/NowPlayingInfoCenter.swift

@@ -0,0 +1,17 @@
+//
+//  NowPlayingInfoCenter.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 03/03/2019.
+//
+
+import Foundation
+import MediaPlayer
+
+public protocol NowPlayingInfoCenter {
+    
+    var nowPlayingInfo: [String: Any]? { get set }
+    
+}
+
+extension MPNowPlayingInfoCenter: NowPlayingInfoCenter {}

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/NowPlayingInfoController/NowPlayingInfoController.swift

@@ -0,0 +1,73 @@
+//
+//  MediaInfoController.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 15/03/2018.
+//
+
+import Foundation
+import MediaPlayer
+
+public class NowPlayingInfoController: NowPlayingInfoControllerProtocol {
+    private var infoQueue: DispatchQueueType = DispatchQueue(
+        label: "NowPlayingInfoController.infoQueue",
+        attributes: .concurrent
+    )
+
+    private(set) var infoCenter: NowPlayingInfoCenter
+    private(set) var info: [String: Any] = [:]
+    
+    public required init() {
+        infoCenter = MPNowPlayingInfoCenter.default()
+    }
+
+    /// Used for testing purposes.
+    public required init(dispatchQueue: DispatchQueueType, infoCenter: NowPlayingInfoCenter) {
+        infoQueue = dispatchQueue
+        self.infoCenter = infoCenter
+    }
+    
+    public required init(infoCenter: NowPlayingInfoCenter = MPNowPlayingInfoCenter.default()) {
+        self.infoCenter = infoCenter
+    }
+    
+    public func set(keyValues: [NowPlayingInfoKeyValue]) {
+        infoQueue.async(flags: .barrier) { [weak self] in
+            guard let self = self else { return }
+            keyValues.forEach {
+                (keyValue) in self.info[keyValue.getKey()] = keyValue.getValue()
+            }
+            self.update()
+        }
+    }
+
+    public func setWithoutUpdate(keyValues: [NowPlayingInfoKeyValue]) {
+        infoQueue.async(flags: .barrier) { [weak self] in
+            guard let self = self else { return }
+            keyValues.forEach {
+                (keyValue) in self.info[keyValue.getKey()] = keyValue.getValue()
+            }
+        }
+    }
+    
+    public func set(keyValue: NowPlayingInfoKeyValue) {
+        infoQueue.async(flags: .barrier) { [weak self] in
+            guard let self = self else { return }
+            self.info[keyValue.getKey()] = keyValue.getValue()
+            self.update()
+        }
+    }
+   
+    private func update() {
+        infoCenter.nowPlayingInfo = info
+    }
+    
+    public func clear() {
+        infoQueue.async(flags: .barrier) { [weak self] in
+            guard let self = self else { return }
+            self.info = [:]
+            self.infoCenter.nowPlayingInfo = nil
+        }
+    }
+    
+}

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/NowPlayingInfoController/NowPlayingInfoControllerProtocol.swift

@@ -0,0 +1,26 @@
+//
+//  NowPlayingInfoControllerProtocol.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 28/02/2019.
+//
+
+import Foundation
+import MediaPlayer
+
+
+public protocol NowPlayingInfoControllerProtocol {
+    
+    init()
+    
+    init(infoCenter: NowPlayingInfoCenter)
+    
+    func set(keyValue: NowPlayingInfoKeyValue)
+    
+    func set(keyValues: [NowPlayingInfoKeyValue])
+    
+    func setWithoutUpdate(keyValues: [NowPlayingInfoKeyValue])
+    
+    func clear()
+    
+}

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/NowPlayingInfoController/NowPlayingInfoKeyValue.swift

@@ -0,0 +1,14 @@
+//
+//  NowPlayingInfoKeyValue.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 28/02/2019.
+//
+
+import Foundation
+
+
+public protocol NowPlayingInfoKeyValue {
+    func getKey() -> String
+    func getValue() -> Any?
+}