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

package/ios/RNTrackPlayer/RNTrackPlayer.swift

@@ -10,479 +10,940 @@ import Foundation
 import MediaPlayer
 import React
 
-@available(iOS 10.3, *)
+@objc public protocol RNTPDelegate {
+    func sendEvent(name: String, body: Any)
+}
+
 @objc(RNTrackPlayer)
-public class RNTrackPlayer: RCTEventEmitter {
-    
+public class RNTrackPlayer: NSObject, AudioSessionControllerDelegate {
+
+    // MARK: - Shared AVPlayer
+    // Exposed for external UI like VideoView that need the video layer from the single player instance.
+    @objc public static var sharedAVPlayer: AVPlayer?
+
+    // Expose underlying AVPlayer for video rendering
+    @objc public var avPlayer: AVPlayer? {
+        if let w = player.wrapper as? AVPlayerWrapper {
+            return w.player
+        }
+        return nil
+    }
+
+    // newarch swift event emitter
+    @objc public weak var delegate: RNTPDelegate? = nil
     // MARK: - Attributes
-    
     private var hasInitialized = false
-    
+    private let player = QueuedAudioPlayer()
+    private let audioSessionController = AudioSessionController.shared
+    private var shouldEmitProgressEvent: Bool = false
+    private var shouldResumePlaybackAfterInterruptionEnds: Bool = false
+    private var forwardJumpInterval: NSNumber? = nil;
+    private var backwardJumpInterval: NSNumber? = nil;
+    private var sessionCategory: AVAudioSession.Category = .playback
+    private var sessionCategoryMode: AVAudioSession.Mode = .default
+    private var sessionCategoryPolicy: AVAudioSession.RouteSharingPolicy = .default
+    private var sessionCategoryOptions: AVAudioSession.CategoryOptions = []
+
     // MARK: - Lifecycle Methods
-    
+
+    public override init() {
+        super.init()
+        audioSessionController.delegate = self
+        player.playWhenReady = false;
+        player.event.receiveChapterMetadata.addListener(self, handleAudioPlayerChapterMetadataReceived)
+        player.event.receiveTimedMetadata.addListener(self, handleAudioPlayerTimedMetadataReceived)
+        player.event.receiveCommonMetadata.addListener(self, handleAudioPlayerCommonMetadataReceived)
+        player.event.stateChange.addListener(self, handleAudioPlayerStateChange)
+        player.event.fail.addListener(self, handleAudioPlayerFailed)
+        player.event.currentItem.addListener(self, handleAudioPlayerCurrentItemChange)
+        player.event.secondElapse.addListener(self, handleAudioPlayerSecondElapse)
+        player.event.playWhenReadyChange.addListener(self, handlePlayWhenReadyChange)
+
+        // Store global reference to the underlying AVPlayer so that other native views can reuse it.
+        if let wrapper = player.wrapper as? AVPlayerWrapper {
+            RNTrackPlayer.sharedAVPlayer = wrapper.player
+        }
+    }
+
     deinit {
         reset(resolve: { _ in }, reject: { _, _, _  in })
-    }
-    
-    private var currentTrack: Track? = nil
-    
-    private var previousArtworkUrl : String? = nil
-    
-    private var placeHolderImageArtwork : MPMediaItemArtwork? = nil
-    
-    private var artworkUrl : MediaURL? = nil
 
-    
-    // MARK: - RCTEventEmitter
-    
-    override public static func requiresMainQueueSetup() -> Bool {
-        return true;
-    }
-    
-    @objc(constantsToExport)
-    override public func constantsToExport() -> [AnyHashable: Any] {
-        return [
-            "STATE_NONE": PlayState.none.rawValue,
-            "STATE_PLAYING": PlayState.playing.rawValue,
-            "STATE_PAUSED": PlayState.paused.rawValue,
-            "STATE_STOPPED": PlayState.stopped.rawValue,
-
-            "CAPABILITY_PLAY": Capability.play.rawValue,
-            "CAPABILITY_PLAY_FROM_ID": "NOOP",
-            "CAPABILITY_PLAY_FROM_SEARCH": "NOOP",
-            "CAPABILITY_PAUSE": Capability.pause.rawValue,
-            "CAPABILITY_STOP": Capability.stop.rawValue,
-            "CAPABILITY_SEEK_TO": Capability.seek.rawValue,
-            "CAPABILITY_SKIP": "NOOP",
-            "CAPABILITY_SKIP_TO_NEXT": Capability.next.rawValue,
-            "CAPABILITY_SKIP_TO_PREVIOUS": Capability.previous.rawValue,
-            "CAPABILITY_SET_RATING": "NOOP",
-            "CAPABILITY_JUMP_FORWARD": Capability.jumpForward.rawValue,
-            "CAPABILITY_JUMP_BACKWARD": Capability.jumpBackward.rawValue,
-            "CAPABILITY_LIKE": Capability.like.rawValue,
-            "CAPABILITY_DISLIKE": Capability.dislike.rawValue,
-            "CAPABILITY_BOOKMARK": Capability.bookmark.rawValue,
-        ]
+        RNTrackPlayer.sharedAVPlayer = nil
     }
-    
-    @objc(supportedEvents)
-    override public func supportedEvents() -> [String] {
-        return [
-            "playback-queue-ended",
-            "playback-state",
-            "playback-error",
-            "playback-track-changed",
-            
-            "remote-play-pause",
-            "remote-stop",
-            "remote-pause",
-            "remote-play",
-            "remote-duck",
-            "remote-next",
-            "remote-seek",
-            "remote-previous",
-            "remote-jump-forward",
-            "remote-jump-backward",
-            "remote-like",
-            "remote-dislike",
-            "remote-bookmark",
-        ]
-    }
-    
-    func setupInterruptionHandling() {
-        let notificationCenter = NotificationCenter.default
-        notificationCenter.removeObserver(self)
-        notificationCenter.addObserver(self,
-                                       selector: #selector(handleInterruption),
-                                       name: AVAudioSession.interruptionNotification,
-                                       object: nil)
+
+    private func emit(event: EventType, body: Any? = nil) {
+        delegate?.sendEvent(name: event.rawValue, body: body)
     }
-    
-    @objc func handleInterruption(notification: Notification) {
-        guard let userInfo = notification.userInfo,
-            let typeValue = userInfo[AVAudioSessionInterruptionTypeKey] as? UInt,
-            let type = AVAudioSession.InterruptionType(rawValue: typeValue) else {
-                return
-        }
-        
-        let center = MPNowPlayingInfoCenter.default()
-        
-        if(center.nowPlayingInfo == nil){
-            center.nowPlayingInfo = [
-                MPMediaItemPropertyTitle: "",
-                MPMediaItemPropertyArtist: "",
-                MPMediaItemPropertyAlbumTitle: "",
-                MPMediaItemPropertyPlaybackDuration: 0,
-                MPNowPlayingInfoPropertyElapsedPlaybackTime: 0,
-                MPNowPlayingInfoPropertyPlaybackRate: 0
-            ]
-        }
-        
-        if type == .began {
-            
-            var wasSupended = userInfo[AVAudioSessionInterruptionWasSuspendedKey] as? Bool
-
-#if TARGET_OS_IOS
-            if #available(iOS 14.5, *) {
-                let reason = userInfo[AVAudioSessionInterruptionReasonKey] as? NSNumber
-                
-                if(reason != nil && reason == 1){
-                    wasSupended = true
-                }
-            }
-#endif
-            
-            if(wasSupended != nil && wasSupended == true){
-                return
-            }
 
-            center.nowPlayingInfo![MPNowPlayingInfoPropertyPlaybackRate] = 0
-            // Interruption began, take appropriate actions
-            self.sendEvent(withName: "remote-duck", body: [
+    // MARK: - AudioSessionControllerDelegate
+
+    public func handleInterruption(type: InterruptionType) {
+        switch type {
+        case .began:
+            // Interruption began, take appropriate actions (save state, update user interface)
+            emit(event: EventType.RemoteDuck, body: [
                 "paused": true
-                ])
-        }
-        else if type == .ended {
-            if let optionsValue = userInfo[AVAudioSessionInterruptionOptionKey] as? UInt {
-                let options = AVAudioSession.InterruptionOptions(rawValue: optionsValue)
-                if options.contains(.shouldResume) {
-                    // Interruption Ended - playback should resume
-                    center.nowPlayingInfo![MPNowPlayingInfoPropertyPlaybackRate] = 1.0
-                    self.sendEvent(withName: "remote-duck", body: [
-                        "paused": false
-                        ])
-                } else {
-                    // Interruption Ended - playback should NOT resume
-                    self.sendEvent(withName: "remote-duck", body: [
-                        "paused": true,
-                        "permanent": true
-                        ])
+            ])
+        case let .ended(shouldResume):
+            if shouldResume {
+                if (shouldResumePlaybackAfterInterruptionEnds) {
+                    player.play()
                 }
+                // Interruption Ended - playback should resume
+                emit(event: EventType.RemoteDuck, body: [
+                    "paused": false
+                ])
+            } else {
+                // Interruption Ended - playback should NOT resume
+                emit(event: EventType.RemoteDuck, body: [
+                    "paused": true,
+                    "permanent": true
+                ])
             }
         }
     }
 
-    private func setupPlayer() {
+    // MARK: - Bridged Methods
+
+    private func rejectWhenNotInitialized(reject: RCTPromiseRejectBlock) -> Bool {
+        let rejected = !hasInitialized;
+        if (rejected) {
+            reject("player_not_initialized", "The player is not initialized. Call setupPlayer first.", nil)
+        }
+        return rejected;
+    }
+
+    private func rejectWhenTrackIndexOutOfBounds(
+        index: Int,
+        min: Int? = nil,
+        max : Int? = nil,
+        message : String? = "The track index is out of bounds",
+        reject: RCTPromiseRejectBlock
+    ) -> Bool {
+        let rejected = index < (min ?? 0) || index > (max ?? player.items.count - 1);
+        if (rejected) {
+            reject("index_out_of_bounds", message, nil)
+        }
+        return rejected
+    }
+
+    @objc(setupPlayer:resolver:rejecter:)
+    public func setupPlayer(config: [String: Any], resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
         if hasInitialized {
+            reject("player_already_initialized", "The player has already been initialized via setupPlayer.", nil)
             return
         }
-        
-        setupInterruptionHandling();
-        
-        let center = MPRemoteCommandCenter.shared()
-
-            if #available(iOS 9.1, *) {
-                center.changePlaybackPositionCommand.addTarget { (commandEvent) -> MPRemoteCommandHandlerStatus in
-                        if let event = commandEvent as? MPChangePlaybackPositionCommandEvent {
-                        self.sendEvent(withName: "remote-seek", body: ["position": event.positionTime])
-                        return MPRemoteCommandHandlerStatus.success
-                    }
-                    
-                    return MPRemoteCommandHandlerStatus.commandFailed
-                }
-            }
-            
-            center.playCommand.addTarget { (commandEvent) -> MPRemoteCommandHandlerStatus in
-                self.sendEvent(withName: "remote-play", body: nil)
-                return MPRemoteCommandHandlerStatus.success
-            }
-            
-            
-            center.pauseCommand.addTarget { (commandEvent) -> MPRemoteCommandHandlerStatus in
-                self.sendEvent(withName: "remote-pause", body: nil)
+
+        // configure the FFT audio tap
+        if let fftLength = config["useFFTProcessor"] as? Int {
+            player.audioTap = WaveformAudioTap(mFFTLength: fftLength, mEmit: {data in
+                self.emit(event:EventType.FFTUpdated, body:data)})
+        }
+
+        // configure buffer size
+        if let bufferDuration = config["minBuffer"] as? TimeInterval {
+            player.bufferDuration = bufferDuration
+        }
+
+        if let autoHandleInterruptions = config["autoHandleInterruptions"] as? Bool {
+            self.shouldResumePlaybackAfterInterruptionEnds = autoHandleInterruptions
+        }
+
+        // configure wether player waits to play (deprecated)
+        if let waitForBuffer = config["waitForBuffer"] as? Bool {
+            player.automaticallyWaitsToMinimizeStalling = waitForBuffer
+        }
+
+        // configure wether control center metdata should auto update
+        player.automaticallyUpdateNowPlayingInfo = config["autoUpdateMetadata"] as? Bool ?? true
+
+        // configure audio session - category, options & mode
+        if
+            let sessionCategoryStr = config["iosCategory"] as? String,
+            let mappedCategory = SessionCategory(rawValue: sessionCategoryStr) {
+            sessionCategory = mappedCategory.mapConfigToAVAudioSessionCategory()
+        }
+
+        if
+            let sessionCategoryModeStr = config["iosCategoryMode"] as? String,
+            let mappedCategoryMode = SessionCategoryMode(rawValue: sessionCategoryModeStr) {
+            sessionCategoryMode = mappedCategoryMode.mapConfigToAVAudioSessionCategoryMode()
+        }
+
+        if
+            let sessionCategoryPolicyStr = config["iosCategoryPolicy"] as? String,
+            let mappedCategoryPolicy = SessionCategoryPolicy(rawValue: sessionCategoryPolicyStr) {
+            sessionCategoryPolicy = mappedCategoryPolicy.mapConfigToAVAudioSessionCategoryPolicy()
+        }
+
+        let sessionCategoryOptsStr = config["iosCategoryOptions"] as? [String]
+        let mappedCategoryOpts = sessionCategoryOptsStr?.compactMap { SessionCategoryOptions(rawValue: $0)?.mapConfigToAVAudioSessionCategoryOptions() } ?? []
+        sessionCategoryOptions = AVAudioSession.CategoryOptions(mappedCategoryOpts)
+
+        configureAudioSession()
+
+        // setup event listeners
+        player.remoteCommandController.handleChangePlaybackPositionCommand = { [weak self] event in
+            if let event = event as? MPChangePlaybackPositionCommandEvent {
+                self?.emit(event: EventType.RemoteSeek, body: ["position": event.positionTime])
                 return MPRemoteCommandHandlerStatus.success
             }
-            
-            center.nextTrackCommand.addTarget { (commandEvent) -> MPRemoteCommandHandlerStatus in
-                self.sendEvent(withName: "remote-next", body: nil)
+
+            return MPRemoteCommandHandlerStatus.commandFailed
+        }
+
+        player.remoteCommandController.handleNextTrackCommand = { [weak self] _ in
+            self?.emit(event: EventType.RemoteNext)
+            return MPRemoteCommandHandlerStatus.success
+        }
+
+        player.remoteCommandController.handlePauseCommand = { [weak self] _ in
+            self?.emit(event: EventType.RemotePause)
+            return MPRemoteCommandHandlerStatus.success
+        }
+
+        player.remoteCommandController.handlePlayCommand = { [weak self] _ in
+            self?.emit(event: EventType.RemotePlay)
+            return MPRemoteCommandHandlerStatus.success
+        }
+
+        player.remoteCommandController.handlePreviousTrackCommand = { [weak self] _ in
+            self?.emit(event: EventType.RemotePrevious)
+            return MPRemoteCommandHandlerStatus.success
+        }
+
+        player.remoteCommandController.handleSkipBackwardCommand = { [weak self] event in
+            if let command = event.command as? MPSkipIntervalCommand,
+               let interval = command.preferredIntervals.first {
+                self?.emit(event: EventType.RemoteJumpBackward, body: ["interval": interval])
                 return MPRemoteCommandHandlerStatus.success
             }
-            
-            center.previousTrackCommand.addTarget { (commandEvent) -> MPRemoteCommandHandlerStatus in
-                self.sendEvent(withName: "remote-previous", body: nil)
+
+            return MPRemoteCommandHandlerStatus.commandFailed
+        }
+
+        player.remoteCommandController.handleSkipForwardCommand = { [weak self] event in
+            if let command = event.command as? MPSkipIntervalCommand,
+               let interval = command.preferredIntervals.first {
+                self?.emit(event: EventType.RemoteJumpForward, body: ["interval": interval])
                 return MPRemoteCommandHandlerStatus.success
             }
-            
-            center.skipBackwardCommand.addTarget { (commandEvent) -> MPRemoteCommandHandlerStatus in
-                    if let command = commandEvent.command as? MPSkipIntervalCommand,
-                        let interval = command.preferredIntervals.first {
-                        self.sendEvent(withName: "remote-jump-backward", body: ["interval": interval])
-                        return MPRemoteCommandHandlerStatus.success
-                    }
-              
-                return MPRemoteCommandHandlerStatus.commandFailed
-            }
-            
-            center.skipForwardCommand.addTarget { (commandEvent) -> MPRemoteCommandHandlerStatus in
-                   if let command = commandEvent.command as? MPSkipIntervalCommand,
-                        let interval = command.preferredIntervals.first {
-                        self.sendEvent(withName: "remote-jump-forward", body: ["interval": interval])
-                        return MPRemoteCommandHandlerStatus.success
-                    }
-                    
-                    return MPRemoteCommandHandlerStatus.commandFailed
-            }
+
+            return MPRemoteCommandHandlerStatus.commandFailed
+        }
+
+        player.remoteCommandController.handleStopCommand = { [weak self] _ in
+            self?.emit(event: EventType.RemoteStop)
+            return MPRemoteCommandHandlerStatus.success
+        }
+
+        player.remoteCommandController.handleTogglePlayPauseCommand = { [weak self] _ in
+            self?.emit(event: self?.player.playerState == .paused
+                ? EventType.RemotePlay
+                : EventType.RemotePause
+            )
+
+            return MPRemoteCommandHandlerStatus.success
+        }
+
+        player.remoteCommandController.handleLikeCommand = { [weak self] _ in
+            self?.emit(event: EventType.RemoteLike)
+            return MPRemoteCommandHandlerStatus.success
+        }
+
+        player.remoteCommandController.handleDislikeCommand = { [weak self] _ in
+            self?.emit(event: EventType.RemoteDislike)
+            return MPRemoteCommandHandlerStatus.success
+        }
+
+        player.remoteCommandController.handleBookmarkCommand = { [weak self] _ in
+            self?.emit(event: EventType.RemoteBookmark)
+            return MPRemoteCommandHandlerStatus.success
+        }
+
+        hasInitialized = true
+        resolve(NSNull())
+    }
+
+
+    private func configureAudioSession() {
+
+        // deactivate the session when there is no current item to be played
+        if (player.currentItem == nil) {
+            try? audioSessionController.deactivateSession()
+            return
+        }
         
-            center.stopCommand.addTarget { (commandEvent) -> MPRemoteCommandHandlerStatus in
-                self.sendEvent(withName: "remote-stop", body: nil)
-                return MPRemoteCommandHandlerStatus.success
-            }
-            
-            center.togglePlayPauseCommand.addTarget { (commandEvent) -> MPRemoteCommandHandlerStatus in
-                    self.sendEvent(withName: "remote-play-pause", body: nil)
-                           return MPRemoteCommandHandlerStatus.success
+        // activate the audio session when there is an item to be played
+        // and the player has been configured to start when it is ready loading:
+        if (player.playWhenReady) {
+            try? audioSessionController.activateSession()
+            if #available(iOS 11.0, *) {
+                try? AVAudioSession.sharedInstance().setCategory(sessionCategory, mode: sessionCategoryMode, policy: sessionCategoryPolicy, options: sessionCategoryOptions)
+            } else {
+                try? AVAudioSession.sharedInstance().setCategory(sessionCategory, mode: sessionCategoryMode, options: sessionCategoryOptions)
             }
-            
-            
-            center.likeCommand.addTarget { (commandEvent) -> MPRemoteCommandHandlerStatus in
-                self.sendEvent(withName: "remote-like", body: nil)
-                return MPRemoteCommandHandlerStatus.success
+        }
+    }
+
+    @objc(isServiceRunning:rejecter:)
+    public func isServiceRunning(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        // TODO That is probably always true
+        resolve(player != nil)
+    }
+
+    @objc(updateOptions:resolver:rejecter:)
+    public func update(options: [String: Any], resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        var capabilitiesStr = options["capabilities"] as? [String] ?? []
+        if (capabilitiesStr.contains("play") && capabilitiesStr.contains("pause")) {
+            capabilitiesStr.append("togglePlayPause");
+        }
+
+        forwardJumpInterval = options["forwardJumpInterval"] as? NSNumber ?? forwardJumpInterval
+        backwardJumpInterval = options["backwardJumpInterval"] as? NSNumber ?? backwardJumpInterval
+
+        player.remoteCommands = capabilitiesStr
+            .compactMap { Capability(rawValue: $0) }
+            .map { capability in
+                capability.mapToPlayerCommand(
+                    forwardJumpInterval: forwardJumpInterval,
+                    backwardJumpInterval: backwardJumpInterval,
+                    likeOptions: options["likeOptions"] as? [String: Any],
+                    dislikeOptions: options["dislikeOptions"] as? [String: Any],
+                    bookmarkOptions: options["bookmarkOptions"] as? [String: Any]
+                )
             }
-            
-            center.dislikeCommand.addTarget { (commandEvent) -> MPRemoteCommandHandlerStatus in
-                self.sendEvent(withName: "remote-dislike", body: nil)
-                return MPRemoteCommandHandlerStatus.success
+
+        configureProgressUpdateEvent(
+            interval: ((options["progressUpdateEventInterval"] as? NSNumber) ?? 0).doubleValue
+        )
+
+        resolve(NSNull())
+    }
+
+    private func configureProgressUpdateEvent(interval: Double) {
+        shouldEmitProgressEvent = interval > 0
+        self.player.timeEventFrequency = shouldEmitProgressEvent
+            ? .custom(time: CMTime(seconds: interval, preferredTimescale: 1000))
+            : .everySecond
+    }
+
+    @objc(add:before:resolver:rejecter:)
+    public func add(
+        trackDicts: [[String: Any]],
+        before trackIndex: Int,
+        resolve: RCTPromiseResolveBlock,
+        reject: RCTPromiseRejectBlock
+    ) {
+        // -1 means no index was passed and therefore should be inserted at the end.
+        let index = trackIndex == -1 ? player.items.count : trackIndex;
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        if (rejectWhenTrackIndexOutOfBounds(
+            index: index,
+            max: player.items.count,
+            reject: reject
+        )) { return }
+
+        var tracks = [Track]()
+        for trackDict in trackDicts {
+            guard let track = Track(dictionary: trackDict) else {
+                reject("invalid_track_object", "Track is missing a required key", nil)
+                return
             }
-            
-            center.bookmarkCommand.addTarget { (commandEvent) -> MPRemoteCommandHandlerStatus in
-                self.sendEvent(withName: "remote-bookmark", body: nil)
-                return MPRemoteCommandHandlerStatus.success
+
+            tracks.append(track)
+        }
+
+        try? player.add(
+            items: tracks,
+            at: index
+        )
+        resolve(index)
+    }
+
+    @objc(load:resolver:rejecter:)
+    public func load(
+        trackDict: [String: Any],
+        resolve: RCTPromiseResolveBlock,
+        reject: RCTPromiseRejectBlock
+    ) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        guard let track = Track(dictionary: trackDict) else {
+            reject("invalid_track_object", "Track is missing a required key", nil)
+            return
+        }
+
+        player.load(item: track)
+        resolve(player.currentIndex)
+    }
+
+    @objc(remove:resolver:rejecter:)
+    public func remove(tracks indexes: [Int], resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        for index in indexes {
+            if (rejectWhenTrackIndexOutOfBounds(index: index, message: "One or more of the indexes were out of bounds.", reject: reject)) {
+                return
             }
-                
-        hasInitialized = true
+        }
+
+        // Sort the indexes in descending order so we can safely remove them one by one
+        // without having the next index possibly newly pointing to another item than intended:
+        for index in indexes.sorted().reversed() {
+            try? player.removeItem(at: index)
+        }
+
+        resolve(NSNull())
     }
-    
+
+    @objc(move:toIndex:resolver:rejecter:)
+    public func move(
+        fromIndex: Int,
+        toIndex: Int,
+        resolve: RCTPromiseResolveBlock,
+        reject: RCTPromiseRejectBlock
+    ) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        if (rejectWhenTrackIndexOutOfBounds(
+            index: fromIndex,
+            message: "The fromIndex is out of bounds",
+            reject: reject)
+        ) { return }
+        if (rejectWhenTrackIndexOutOfBounds(
+            index: toIndex,
+            max: Int.max,
+            message: "The toIndex is out of bounds",
+            reject: reject)
+        ) { return }
+        try? player.moveItem(fromIndex: fromIndex, toIndex: toIndex)
+        resolve(NSNull())
+    }
+
+
+    @objc(removeUpcomingTracks:rejecter:)
+    public func removeUpcomingTracks(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        player.removeUpcomingItems()
+        resolve(NSNull())
+    }
+
+    @objc(skip:initialTime:resolver:rejecter:)
+    public func skip(
+        to trackIndex: Int,
+        initialTime: Double,
+        resolve: RCTPromiseResolveBlock,
+        reject: RCTPromiseRejectBlock
+    ) {
+        let index = trackIndex;
+        if (rejectWhenTrackIndexOutOfBounds(index: index, reject: reject)) { return }
+
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        print("Skipping to track:", index)
+        try? player.jumpToItem(atIndex: index, playWhenReady: player.playerState == .playing)
+
+        // if an initialTime is passed the seek to it
+        if (initialTime >= 0) {
+            self.seekTo(time: initialTime, resolve: resolve, reject: reject)
+        } else {
+            resolve(NSNull())
+        }
+    }
+
+    @objc(skipToNext:resolver:rejecter:)
+    public func skipToNext(
+        initialTime: Double,
+        resolve: RCTPromiseResolveBlock,
+        reject: RCTPromiseRejectBlock
+    ) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        player.next()
+
+        // if an initialTime is passed the seek to it
+        if (initialTime >= 0) {
+            self.seekTo(time: initialTime, resolve: resolve, reject: reject)
+        } else {
+            resolve(NSNull())
+        }
+    }
+
+    @objc(skipToPrevious:resolver:rejecter:)
+    public func skipToPrevious(
+        initialTime: Double,
+        resolve: RCTPromiseResolveBlock,
+        reject: RCTPromiseRejectBlock
+    ) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        player.previous()
+
+        // if an initialTime is passed the seek to it
+        if (initialTime >= 0) {
+            self.seekTo(time: initialTime, resolve: resolve, reject: reject)
+        } else {
+            resolve(NSNull())
+        }
+    }
+
     @objc(reset:rejecter:)
     public func reset(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
-        print("Resetting player.")
-        MPNowPlayingInfoCenter.default().nowPlayingInfo = nil
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        player.stop()
+        player.clear()
+        resolve(NSNull())
+    }
+
+    @objc(play:rejecter:)
+    public func play(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        player.play()
         resolve(NSNull())
-        DispatchQueue.main.async {
-            UIApplication.shared.endReceivingRemoteControlEvents();
+    }
+
+    @objc(pause:rejecter:)
+    public func pause(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        player.pause()
+        resolve(NSNull())
+    }
+
+    @objc(setPlayWhenReady:resolver:rejecter:)
+    public func setPlayWhenReady(playWhenReady: Bool, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        player.playWhenReady = playWhenReady
+        resolve(NSNull())
+    }
+
+    @objc(getPlayWhenReady:rejecter:)
+    public func getPlayWhenReady(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        resolve(player.playWhenReady)
+    }
+
+    @objc(stop:rejecter:)
+    public func stop(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        player.stop()
+        resolve(NSNull())
+    }
+
+    @objc(seekTo:resolver:rejecter:)
+    public func seekTo(time: Double, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        player.seek(to: time)
+        resolve(NSNull())
+    }
+
+    @objc(seekBy:resolver:rejecter:)
+    public func seekBy(offset: Double, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        player.seek(by: offset)
+        resolve(NSNull())
+    }
+
+    @objc(retry:rejecter:)
+    public func retry(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        player.reload(startFromCurrentTime: true)
+        resolve(NSNull())
+    }
+
+    @objc(setRepeatMode:resolver:rejecter:)
+    public func setRepeatMode(repeatMode: Int, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        player.repeatMode = RepeatMode(rawValue: repeatMode) ?? .off
+        resolve(NSNull())
+    }
+
+    @objc(getRepeatMode:rejecter:)
+    public func getRepeatMode(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        resolve(player.repeatMode.rawValue)
+    }
+
+    @objc(setVolume:resolver:rejecter:)
+    public func setVolume(level: Float, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        player.volume = level
+        resolve(NSNull())
+    }
+
+    @objc(getVolume:rejecter:)
+    public func getVolume(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        resolve(player.volume)
+    }
+
+    @objc(setRate:resolver:rejecter:)
+    public func setRate(rate: Float, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        player.rate = rate
+        resolve(NSNull())
+    }
+
+    @objc(getRate:rejecter:)
+    public func getRate(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        resolve(player.rate)
+    }
+
+    @objc(getTrack:resolver:rejecter:)
+    public func getTrack(index: Int, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        if (index >= 0 && index < player.items.count) {
+            let track = player.items[index]
+            resolve((track as? Track)?.toObject())
+        } else {
+            resolve(NSNull())
         }
     }
-    
-    @objc(updateOptions:resolver:rejecter:)
-    public func update(options: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
-        DispatchQueue.main.async {
-            let capabilitiesStr = options["capabilities"] as? [String]
-            let capabilities = capabilitiesStr?.compactMap { Capability(rawValue: $0) } ?? []
-            
-            let jumpInterval = options["jumpInterval"] as? NSNumber
-            let likeOptions = options["likeOptions"] as? [String: Any]
-            let dislikeOptions = options["dislikeOptions"] as? [String: Any]
-            let bookmarkOptions = options["bookmarkOptions"] as? [String: Any]
-            
-            let center = MPRemoteCommandCenter.shared()
-            
-            
-            if #available(iOS 9.1, *) {
-                center.changePlaybackPositionCommand.isEnabled = capabilities.contains(.seek)
-            }
-            
-            center.togglePlayPauseCommand.isEnabled = capabilities.contains(.play)
-            
-            center.playCommand.isEnabled = capabilities.contains(.play)
-            center.pauseCommand.isEnabled = capabilities.contains(.pause)
-            center.nextTrackCommand.isEnabled = capabilities.contains(.next)
-            center.previousTrackCommand.isEnabled = capabilities.contains(.previous)
-            
-            center.skipBackwardCommand.isEnabled = capabilities.contains(.jumpBackward)
-            center.skipBackwardCommand.preferredIntervals = [jumpInterval ?? 15]
-            
-            center.skipForwardCommand.isEnabled = capabilities.contains(.jumpForward)
-            center.skipForwardCommand.preferredIntervals = [jumpInterval ?? 15]
-            
-            center.stopCommand.isEnabled = capabilities.contains(.stop)
-            
-            center.likeCommand.isEnabled = likeOptions?["isActive"] as? Bool ?? false//capabilities.contains(.like)
-            center.likeCommand.localizedTitle = likeOptions?["title"] as? String ?? "Like"
-            center.likeCommand.localizedShortTitle = likeOptions?["title"] as? String ?? "Like"
-            
-            center.dislikeCommand.isEnabled = dislikeOptions?["isActive"] as? Bool ?? false//capabilities.contains(.like)
-            center.dislikeCommand.localizedTitle = dislikeOptions?["title"] as? String ?? "Dislike"
-            center.dislikeCommand.localizedShortTitle = dislikeOptions?["title"] as? String ?? "Dislike"
-            
-            center.bookmarkCommand.isEnabled = bookmarkOptions?["isActive"] as? Bool ?? false//capabilities.contains(.like)
-            center.bookmarkCommand.localizedTitle = bookmarkOptions?["title"] as? String ?? "Bookmark"
-            center.bookmarkCommand.localizedShortTitle = bookmarkOptions?["title"] as? String ?? "Bookmark"
-            
-            
-            //load placeholder
-            if(self.placeHolderImageArtwork == nil && options["placeholderImage"] != nil){
-                let placeHolderImage : UIImage = RCTConvert.uiImage(options["placeholderImage"])
-                
-                if #available(iOS 10.0, *) {
-                    self.placeHolderImageArtwork = MPMediaItemArtwork.init(boundsSize: placeHolderImage.size, requestHandler: { (size) -> UIImage in
-                        return placeHolderImage
-                    })
-                } else {
-                    self.placeHolderImageArtwork = MPMediaItemArtwork(image: placeHolderImage)
-                }
+
+    @objc(getQueue:rejecter:)
+    public func getQueue(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        let serializedQueue = player.items.map { ($0 as! Track).toObject() }
+        resolve(serializedQueue)
+    }
+
+    @objc(setQueue:resolver:rejecter:)
+    public func setQueue(
+        trackDicts: [[String: Any]],
+        resolve: RCTPromiseResolveBlock,
+        reject: RCTPromiseRejectBlock
+    ) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        var tracks = [Track]()
+        for trackDict in trackDicts {
+            guard let track = Track(dictionary: trackDict) else {
+                reject("invalid_track_object", "Track is missing a required key", nil)
+                return
             }
-            
-           resolve(NSNull())
-        }
 
+            tracks.append(track)
+        }
+        player.clear()
+        try? player.add(items: tracks)
+        resolve(index)
     }
-    
-    @objc(setNowPlaying:resolver:rejecter:)
-    public func setNowPlaying(trackDict: [String: Any], resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
-        
-        if(!hasInitialized){
-            setupPlayer()
+
+    @objc(getActiveTrack:rejecter:)
+    public func getActiveTrack(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        let index = player.currentIndex
+        if (index >= 0 && index < player.items.count) {
+            let track = player.items[index]
+            resolve((track as? Track)?.toObject())
+        } else {
+            resolve(NSNull())
         }
-        
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
-            UIApplication.shared.beginReceivingRemoteControlEvents();
+    }
+
+    @objc(getActiveTrackIndex:rejecter:)
+    public func getActiveTrackIndex(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        let index = player.currentIndex
+        if index < 0 || index >= player.items.count {
+            resolve(NSNull())
+        } else {
+            resolve(index)
         }
+    }
 
-        currentTrack = Track(dictionary: trackDict)
-        updatePlayback(properties: trackDict, resolve: resolve, reject: reject)
-        
+    @objc(getDuration:rejecter:)
+    public func getDuration(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        resolve(player.duration)
     }
-    
-    @objc(updatePlayback:resolver:rejecter:)
-    public func updatePlayback(properties: [String: Any], resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
 
-        let center = MPNowPlayingInfoCenter.default()
+    @objc(getBufferedPosition:rejecter:)
+    public func getBufferedPosition(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
 
-        let stateRaw = properties["state"] as? String
+        resolve(player.bufferedPosition)
+    }
 
-        let state = stateRaw != nil ? PlayState(rawValue: stateRaw!) : PlayState.none
+    @objc(getPosition:rejecter:)
+    public func getPosition(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
 
-        currentTrack?.updateMetadata(dictionary: properties)
+        resolve(player.currentTime)
+    }
 
-        updateMetadata(properties: properties, state: state)
+    @objc(getProgress:rejecter:)
+    public func getProgress(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        resolve([
+            "position": player.currentTime,
+            "duration": player.duration,
+            "buffered": player.bufferedPosition
+        ])
+    }
 
-        let commandCenter = MPRemoteCommandCenter.shared()
+    @objc(getPlaybackState:rejecter:)
+    public func getPlaybackState(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        resolve(getPlaybackStateBodyKeyValues(state: player.playerState))
+    }
 
-        if(state == PlayState.stopped){
-                commandCenter.stopCommand.isEnabled = false
-        }
+    @objc(updateMetadataForTrack:metadata:resolver:rejecter:)
+    public func updateMetadata(for trackIndex: Int, metadata: [String: Any], resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        let index = trackIndex;
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        if (rejectWhenTrackIndexOutOfBounds(index: index, reject: reject)) { return }
 
-#if TARGET_OS_IOS
-        if #available(iOS 13.0, *) {
-            if (state == PlayState.playing) {
-                center.playbackState = MPNowPlayingPlaybackState.playing
-            } else if (state == PlayState.paused) {
-                center.playbackState = MPNowPlayingPlaybackState.paused;
-            } else if (state == PlayState.stopped) {
-                    center.playbackState = MPNowPlayingPlaybackState.stopped;
-            }
+        let track : Track = player.items[index] as! Track;
+        track.updateMetadata(dictionary: metadata)
+
+        if (player.currentIndex == index) {
+            Metadata.update(for: player, with: metadata)
         }
-#endif
 
         resolve(NSNull())
     }
-    
-    private func updateMetadata(properties: [String: Any], state: PlayState!) {
-        
-        let center = MPNowPlayingInfoCenter.default()
-        
-        if(center.nowPlayingInfo == nil){
-            center.nowPlayingInfo = [
-                MPMediaItemPropertyTitle: "",
-                MPMediaItemPropertyArtist: "",
-                MPMediaItemPropertyAlbumTitle: "",
-                MPMediaItemPropertyPlaybackDuration: 0,
-                MPNowPlayingInfoPropertyElapsedPlaybackTime: 0,
+
+    @objc(clearNowPlayingMetadata:rejecter:)
+    public func clearNowPlayingMetadata(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        player.nowPlayingInfoController.clear()
+        resolve(NSNull())
+    }
+
+    @objc(updateNowPlayingMetadata:resolver:rejecter:)
+    public func updateNowPlayingMetadata(metadata: [String: Any], resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        Metadata.update(for: player, with: metadata)
+        resolve(NSNull())
+    }
+
+    private func getPlaybackStateErrorKeyValues() -> Dictionary<String, Any> {
+        switch player.playbackError {
+            case .failedToLoadKeyValue: return [
+                "message": "Failed to load resource",
+                "code": "ios_failed_to_load_resource"
+            ]
+            case .invalidSourceUrl: return [
+                "message": "The source url was invalid",
+                "code": "ios_invalid_source_url"
+            ]
+            case .notConnectedToInternet: return [
+                "message": "A network resource was requested, but an internet connection has not been established and can’t be established automatically.",
+                "code": "ios_not_connected_to_internet"
+            ]
+            case .playbackFailed: return [
+                "message": "Playback of the track failed",
+                "code": "ios_playback_failed"
+            ]
+            case .itemWasUnplayable: return [
+                "message": "The track could not be played",
+                "code": "ios_track_unplayable"
+            ]
+            default: return [
+                "message": "A playback error occurred",
+                "code": "ios_playback_error"
             ]
         }
-        
+    }
 
-        let elapsedTime = properties["elapsedTime"] as? Double
-        
-        var newNowPlaying = center.nowPlayingInfo
-        
-        newNowPlaying![MPMediaItemPropertyTitle] = currentTrack?.title ?? center.nowPlayingInfo![MPMediaItemPropertyTitle]
-        newNowPlaying![MPMediaItemPropertyArtist] = currentTrack?.artist ?? center.nowPlayingInfo![MPMediaItemPropertyArtist]
-        newNowPlaying![MPMediaItemPropertyAlbumTitle] = currentTrack?.album ?? center.nowPlayingInfo![MPMediaItemPropertyAlbumTitle]
-        newNowPlaying![MPMediaItemPropertyPlaybackDuration] = currentTrack?.duration ?? center.nowPlayingInfo![MPMediaItemPropertyPlaybackDuration]
-        newNowPlaying![MPNowPlayingInfoPropertyElapsedPlaybackTime] = elapsedTime ?? center.nowPlayingInfo![MPNowPlayingInfoPropertyElapsedPlaybackTime]
-        newNowPlaying![MPNowPlayingInfoPropertyPlaybackRate] = state == PlayState.paused ? 0 : 1.0
-        
-        let newArtworkUrl = properties["artwork"] as? String
-        
-        self.artworkUrl = MediaURL(object: newArtworkUrl)
-        
-        //add placeholder while image is loading
-        if(newArtworkUrl != nil && newArtworkUrl != self.previousArtworkUrl /*&& !(self.artworkUrl?.isLocal ?? false)*/){
-            newNowPlaying![MPMediaItemPropertyArtwork] = placeHolderImageArtwork
+    private func getPlaybackStateBodyKeyValues(state: AudioPlayerState) -> Dictionary<String, Any> {
+        var body: Dictionary<String, Any> = ["state": State.fromPlayerState(state: state).rawValue]
+        if (state == AudioPlayerState.failed) {
+            body["error"] = getPlaybackStateErrorKeyValues()
         }
+        return body
+    }
+
+    // MARK: - QueuedAudioPlayer Event Handlers
+
+    func handleAudioPlayerStateChange(state: AVPlayerWrapperState) {
+        emit(event: EventType.PlaybackState, body: getPlaybackStateBodyKeyValues(state: state))
+        if (state == .ended) {
+            emit(event: EventType.PlaybackQueueEnded, body: [
+                "track": player.currentIndex,
+                "position": player.currentTime,
+            ] as [String : Any])
+        }
+    }
+    
+    func handleAudioPlayerCommonMetadataReceived(metadata: [AVMetadataItem]) {
+        let commonMetadata = MetadataAdapter.convertToCommonMetadata(metadata: metadata, skipRaw: true)
+        emit(event: EventType.MetadataCommonReceived, body: ["metadata": commonMetadata])
+    }
+    
+    func handleAudioPlayerChapterMetadataReceived(metadata: [AVTimedMetadataGroup]) {
+        let metadataItems = MetadataAdapter.convertToGroupedMetadata(metadataGroups: metadata);
+        emit(event: EventType.MetadataChapterReceived, body:  ["metadata": metadataItems])
+    }
+
+    func handleAudioPlayerTimedMetadataReceived(metadata: [AVTimedMetadataGroup]) {
+        let metadataItems = MetadataAdapter.convertToGroupedMetadata(metadataGroups: metadata);
+        emit(event: EventType.MetadataTimedReceived, body: ["metadata": metadataItems])
         
-        MPNowPlayingInfoCenter.default().nowPlayingInfo = newNowPlaying
-        
-        //updateArtworkIfNeeded(artworkUrl: newArtworkUrl, newNowPlaying: newNowPlaying!)
-        
-        
-        if(newArtworkUrl == nil){
-                return
+        // SwiftAudioEx was updated to return the array of timed metadata
+        // Until we have support for that in RNTP, we take the first item to keep existing behaviour.
+        let metadata = metadata.first?.items ?? []
+        let metadataItem = MetadataAdapter.legacyConversion(metadata: metadata)
+        emit(event: EventType.PlaybackMetadataReceived, body: metadataItem)
+    }
+
+    func handleAudioPlayerFailed(error: Error?) {
+        emit(event: EventType.PlaybackError, body: ["error": error?.localizedDescription])
+    }
+
+    func handleAudioPlayerCurrentItemChange(
+        item: AudioItem?,
+        index: Int?,
+        lastItem: AudioItem?,
+        lastIndex: Int?,
+        lastPosition: Double?
+    ) {
+
+        if let item = item {
+            DispatchQueue.main.async {
+                UIApplication.shared.beginReceivingRemoteControlEvents();
+            }
+            // Update now playing controller with isLiveStream option from track
+            if self.player.automaticallyUpdateNowPlayingInfo {
+                let isTrackLiveStream = (item as? Track)?.isLiveStream ?? false
+                self.player.nowPlayingInfoController.set(keyValue: NowPlayingInfoProperty.isLiveStream(isTrackLiveStream))
+            }
+        } else {
+            DispatchQueue.main.async {
+                UIApplication.shared.endReceivingRemoteControlEvents();
+            }
         }
-            
-        if(self.previousArtworkUrl == newArtworkUrl && newNowPlaying![MPMediaItemPropertyArtwork] != nil){
-                return
+
+        if ((item != nil && lastItem == nil) || item == nil) {
+            configureAudioSession();
         }
-        
-        if(newArtworkUrl == ""){
-            return
+
+        var a: Dictionary<String, Any> = ["lastPosition": lastPosition ?? 0]
+        if let lastIndex = lastIndex {
+            a["lastIndex"] = lastIndex
         }
-        
-        self.previousArtworkUrl = newArtworkUrl
-        
-        self.getArtwork { [weak self] image in
-            if let image = image {
-                
-                // check whether image is loaded
-                if (image.cgImage == nil && image.ciImage == nil) {
-                    return;
-                }
-                
-                if(self?.previousArtworkUrl != newArtworkUrl){
-                    return
-                }
-                
-                    
-                let artwork = self?.mediaItemArtwork(from: image)//MPMediaItemArtwork(from: image)
 
-                if(MPNowPlayingInfoCenter.default().nowPlayingInfo != nil)
-                {
-                    MPNowPlayingInfoCenter.default().nowPlayingInfo![MPMediaItemPropertyArtwork] = artwork
-                }
-            }
+        if let lastTrack = (lastItem as? Track)?.toObject() {
+            a["lastTrack"] = lastTrack
         }
-    }
-    
-    func getArtwork(_ handler: @escaping (UIImage?) -> Void) {
-        if let artworkURL = self.artworkUrl?.value {
-            if(self.artworkUrl?.isLocal ?? false){
-                
-                if(FileManager.default.fileExists(atPath: artworkURL.path)){
-                    let image = UIImage.init(named: artworkURL.path);
-                    handler(image);
-                }
-                
-            } else {
-                URLSession.shared.dataTask(with: artworkURL, completionHandler: { (data, _, error) in
-                    if let data = data, let artwork = UIImage(data: data), error == nil {
-                        handler(artwork)
-                    }
 
-                    handler(nil)
-                }).resume()
-            }
+        if let index = index {
+            a["index"] = index
         }
-        
-        handler(nil)
+
+        if let track = (item as? Track)?.toObject() {
+            a["track"] = track
+        }
+        emit(event: EventType.PlaybackActiveTrackChanged, body: a)
+
+        // deprecated:
+        var b: Dictionary<String, Any> = ["position": lastPosition ?? 0]
+        if let lastIndex = lastIndex {
+            b["lastIndex"] = lastIndex
+        }
+        if let index = index {
+            b["nextTrack"] = index
+        }
+        emit(event: EventType.PlaybackTrackChanged, body: b)
     }
-    
-    fileprivate func mediaItemArtwork(from image: UIImage) -> MPMediaItemArtwork {
-            if #available(iOS 10.0, *) {
-                return MPMediaItemArtwork.init(boundsSize: image.size, requestHandler: { (size: CGSize) -> UIImage in
-                    return image
-                })
-            } else {
-                return MPMediaItemArtwork(image: image)
-            }
+
+    func handleAudioPlayerSecondElapse(seconds: Double) {
+        // because you cannot prevent the `event.secondElapse` from firing
+        // do not emit an event if `progressUpdateEventInterval` is nil
+        // additionally, there are certain instances in which this event is emitted
+        // _after_ a manipulation to the queu causing no currentItem to exist (see reset)
+        // in which case we shouldn't emit anything or we'll get an exception.
+        if !shouldEmitProgressEvent || player.currentItem == nil { return }
+        emit(
+            event: EventType.PlaybackProgressUpdated,
+            body: [
+                "position": player.currentTime,
+                "duration": player.duration,
+                "buffered": player.bufferedPosition,
+                "track": player.currentIndex,
+            ]
+        )
+    }
+
+    func handlePlayWhenReadyChange(playWhenReady: Bool) {
+        configureAudioSession();
+        emit(
+            event: EventType.PlaybackPlayWhenReadyChanged,
+            body: [
+                "playWhenReady": playWhenReady
+            ]
+        )
+    }
+}
+
+extension RNTrackPlayer {
+    @objc
+    public static var constantsToExport: [AnyHashable: Any] {
+            return [
+                "STATE_NONE": State.none.rawValue,
+                "STATE_READY": State.ready.rawValue,
+                "STATE_PLAYING": State.playing.rawValue,
+                "STATE_PAUSED": State.paused.rawValue,
+                "STATE_STOPPED": State.stopped.rawValue,
+                "STATE_BUFFERING": State.buffering.rawValue,
+                "STATE_LOADING": State.loading.rawValue,
+                "STATE_ERROR": State.error.rawValue,
+
+                "TRACK_PLAYBACK_ENDED_REASON_END": PlaybackEndedReason.playedUntilEnd.rawValue,
+                "TRACK_PLAYBACK_ENDED_REASON_JUMPED": PlaybackEndedReason.jumpedToIndex.rawValue,
+                "TRACK_PLAYBACK_ENDED_REASON_NEXT": PlaybackEndedReason.skippedToNext.rawValue,
+                "TRACK_PLAYBACK_ENDED_REASON_PREVIOUS": PlaybackEndedReason.skippedToPrevious.rawValue,
+                "TRACK_PLAYBACK_ENDED_REASON_STOPPED": PlaybackEndedReason.playerStopped.rawValue,
+
+                "PITCH_ALGORITHM_LINEAR": PitchAlgorithm.linear.rawValue,
+                "PITCH_ALGORITHM_MUSIC": PitchAlgorithm.music.rawValue,
+                "PITCH_ALGORITHM_VOICE": PitchAlgorithm.voice.rawValue,
+
+                "CAPABILITY_PLAY": Capability.play.rawValue,
+                "CAPABILITY_PLAY_FROM_ID": "NOOP",
+                "CAPABILITY_PLAY_FROM_SEARCH": "NOOP",
+                "CAPABILITY_PAUSE": Capability.pause.rawValue,
+                "CAPABILITY_STOP": Capability.stop.rawValue,
+                "CAPABILITY_SEEK_TO": Capability.seek.rawValue,
+                "CAPABILITY_SKIP": "NOOP",
+                "CAPABILITY_SKIP_TO_NEXT": Capability.next.rawValue,
+                "CAPABILITY_SKIP_TO_PREVIOUS": Capability.previous.rawValue,
+                "CAPABILITY_SET_RATING": "NOOP",
+                "CAPABILITY_JUMP_FORWARD": Capability.jumpForward.rawValue,
+                "CAPABILITY_JUMP_BACKWARD": Capability.jumpBackward.rawValue,
+                "CAPABILITY_LIKE": Capability.like.rawValue,
+                "CAPABILITY_DISLIKE": Capability.dislike.rawValue,
+                "CAPABILITY_BOOKMARK": Capability.bookmark.rawValue,
+
+                "REPEAT_OFF": RepeatMode.off.rawValue,
+                "REPEAT_TRACK": RepeatMode.track.rawValue,
+                "REPEAT_QUEUE": RepeatMode.queue.rawValue,
+            ]
+        }
+
+    @objc
+    public static var supportedEvents: [String] {
+        return EventType.allRawValues()
     }
 }