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

package/ios/RNTrackPlayer/Support/RNTrackPlayer-Bridging-Header.h

@@ -4,3 +4,4 @@
 
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
+#import <React/RCTConvert.h>

package/ios/RNTrackPlayer/TrackPlayer.h

@@ -0,0 +1,14 @@
+#import <React/RCTEventEmitter.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <NativeTrackPlayerSpec/NativeTrackPlayerSpec.h>
+NS_ASSUME_NONNULL_BEGIN
+
+@interface NativeTrackPlayer: RCTEventEmitter <NativeTrackPlayerSpec>
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/ios/RNTrackPlayer/TrackPlayer.mm

@@ -0,0 +1,249 @@
+#import "TrackPlayer.h"
+
+#if __has_include("react_native_track_player-Swift.h")
+#import "react_native_track_player-Swift.h"
+#else
+#import "react_native_track_player/react_native_track_player-Swift.h"
+#endif
+
+@interface NativeTrackPlayer () <RNTPDelegate>
+@end
+
+@implementation NativeTrackPlayer {
+    RNTrackPlayer *trackPlayer;
+}
+
+RCT_EXPORT_MODULE()
+
+- (instancetype)init {
+    self = [super init];
+    if(self) {
+        trackPlayer = [RNTrackPlayer new];
+        trackPlayer.delegate = self;
+    }
+    return self;
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return NO;
+}
+
+- (void)sendEvent:(NSString *)name body:(id)body {
+  [super sendEventWithName:name body:body];
+}
+
+- (NSArray<NSString *> *) supportedEvents {
+    return [RNTrackPlayer supportedEvents];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+    return std::make_shared<facebook::react::NativeTrackPlayerSpecJSI>(params);
+}
+
+- (void)add:(nonnull NSArray *)tracks insertBeforeIndex:(double)insertBeforeIndex resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    [trackPlayer add:tracks before:insertBeforeIndex resolver:resolve rejecter:reject];
+}
+
+
+- (nonnull facebook::react::ModuleConstants<JS::NativeTrackPlayer::Constants::Builder>)constantsToExport {
+    return [RNTrackPlayer constantsToExport];
+}
+
+- (void)getActiveTrack:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer getActiveTrack:resolve rejecter:reject];
+}
+
+- (void)getActiveTrackIndex:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer getActiveTrackIndex:resolve rejecter:reject];
+}
+
+- (nonnull facebook::react::ModuleConstants<JS::NativeTrackPlayer::Constants::Builder>)getConstants { 
+    return [self constantsToExport];
+}
+
+- (void)getPlayWhenReady:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer getPlayWhenReady:resolve rejecter:reject];
+}
+
+- (void)getPlaybackState:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer getPlaybackState:resolve rejecter:reject];
+}
+
+- (void)getProgress:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer getProgress:resolve rejecter:reject];
+}
+
+- (void)getQueue:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer getQueue:resolve rejecter:reject];
+}
+
+- (void)getRate:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer getRate:resolve rejecter:reject];
+}
+
+- (void)getRepeatMode:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer getRepeatMode:resolve rejecter:reject];
+}
+
+- (void)getTrack:(double)index resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer getTrack:index resolver:resolve rejecter:reject];
+}
+
+- (void)getVolume:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer getVolume:resolve rejecter:reject];
+}
+
+- (void)load:(nonnull NSDictionary *)track resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer load:track resolver:resolve rejecter:reject];
+}
+
+- (void)move:(double)fromIndex toIndex:(double)toIndex resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    [trackPlayer move:fromIndex toIndex:toIndex resolver:resolve rejecter:reject];
+}
+
+- (void)pause:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer pause:resolve rejecter:reject];
+}
+
+- (void)play:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer play:resolve rejecter:reject];
+}
+
+- (void)remove:(nonnull NSArray *)indexes resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer remove:indexes resolver:resolve rejecter:reject];
+}
+
+- (void)removeUpcomingTracks:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer removeUpcomingTracks:resolve rejecter:reject];
+}
+
+- (void)reset:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer reset:resolve rejecter:reject];
+}
+
+- (void)retry:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer retry:resolve rejecter:reject];
+}
+
+- (void)seekBy:(double)offset resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer seekBy:offset resolver:resolve rejecter:reject];
+}
+
+- (void)seekTo:(double)position resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer seekTo:position resolver:resolve rejecter:reject];
+}
+
+- (void)setPlayWhenReady:(BOOL)playWhenReady resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer setPlayWhenReady:playWhenReady resolver:resolve rejecter:reject];
+}
+
+- (void)setQueue:(nonnull NSArray *)tracks resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer setQueue:tracks resolver:resolve rejecter:reject];
+}
+
+- (void)setRate:(double)rate resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer setRate:rate resolver:resolve rejecter:reject];
+}
+
+- (void)setRepeatMode:(double)mode resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer setRepeatMode:mode resolver:resolve rejecter:reject];
+}
+
+- (void)setVolume:(double)level resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer setVolume:level resolver:resolve rejecter:reject];
+}
+
+- (void)setupPlayer:(nonnull NSDictionary *)options background:(BOOL)background resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer setupPlayer:options resolver:resolve rejecter:reject];
+}
+
+- (void)skip:(double)index initialPosition:(double)initialPosition resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer skip:index initialTime:initialPosition resolver:resolve rejecter:reject];
+}
+
+- (void)skipToNext:(double)initialPosition resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer skipToNext:initialPosition resolver:resolve rejecter:reject];
+}
+
+- (void)skipToPrevious:(double)initialPosition resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer skipToPrevious:initialPosition resolver:resolve rejecter:reject];
+}
+
+- (void)stop:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer stop:resolve rejecter:reject];
+}
+
+- (void)updateMetadataForTrack:(double)trackIndex metadata:(nonnull NSDictionary *)metadata resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer updateMetadataForTrack:trackIndex metadata:metadata resolver:resolve rejecter:reject];
+}
+
+- (void)updateNowPlayingMetadata:(nonnull NSDictionary *)metadata resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer updateNowPlayingMetadata:metadata resolver:resolve rejecter:reject];
+}
+
+- (void)updateOptions:(nonnull NSDictionary *)options resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [trackPlayer updateOptions:options resolver:resolve rejecter:reject];
+}
+
+// android only. placeholder.
+- (void)abandonWakeLock:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)acquireWakeLock:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)getCurrentEqualizerPreset:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)getEqualizerPresets:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)getLastConnectedPackage:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)getPitch:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)crossFadePrepare:(BOOL)previous seekTo:(nonnull NSNumber *)seekTo resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)fadeOutJump:(double)index duration:(double)duration interval:(double)interval toVolume:(double)toVolume resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)fadeOutNext:(double)duration interval:(double)interval toVolume:(double)toVolume resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)fadeOutPause:(double)duration interval:(double)interval resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)fadeOutPrevious:(double)duration interval:(double)interval toVolume:(double)toVolume resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)setAnimatedVolume:(double)volume duration:(double)duration interval:(double)interval msg:(nonnull NSString *)msg resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)setBrowseTree:(nonnull NSDictionary *)browseTree resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)setBrowseTreeStyle:(double)browsableStyle playableStyle:(double)playableStyle resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)setSearchResults:(nonnull NSDictionary *)browseTree resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)setEqualizerPreset:(double)preset resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)setLoudnessEnhance:(double)gain resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)setPitch:(double)pitch resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)setPlaybackState:(nonnull NSString *)mediaID resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+}
+
+- (void)switchExoPlayer:(double)fadeDuration fadeInterval:(double)fadeInterval fadeToVolume:(double)fadeToVolume waitUntil:(nonnull NSNumber *)waitUntil resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+}
+
+@end

package/ios/RNTrackPlayer/Utils/EventType.swift

@@ -0,0 +1,45 @@
+import Foundation
+
+enum EventType: String, CaseIterable {
+    case RemotePlayPause = "remote-play-pause"
+    case RemotePlayId = "remote-play-id"
+    case RemotePlaySearch = "remote-play-search"
+    case RemoteBrowse = "remote-browse"
+    case RemoteCustomAction = "remote-custom-action"
+    case RemoteSearch = "remote-search"
+
+    case RemoteDuck = "remote-duck"
+    case RemoteSeek = "remote-seek"
+    case RemoteNext = "remote-next"
+    case RemotePrevious = "remote-previous"
+    case RemoteStop = "remote-stop"
+    case RemotePause = "remote-pause"
+    case RemotePlay = "remote-play"
+    case RemoteJumpForward = "remote-jump-forward"
+    case RemoteJumpBackward = "remote-jump-backward"
+    case RemoteLike = "remote-like"
+    case RemoteDislike = "remote-dislike"
+    case RemoteBookmark = "remote-bookmark"
+    case PlaybackMetadataReceived = "playback-metadata-received"
+    case PlaybackError = "playback-error"
+    case PlaybackQueueEnded = "playback-queue-ended"
+    case PlaybackTrackChanged = "playback-track-changed"
+    case PlaybackActiveTrackChanged = "playback-active-track-changed"
+    case PlaybackState = "playback-state"
+    case PlaybackProgressUpdated = "playback-progress-updated"
+    case PlaybackPlayWhenReadyChanged = "playback-play-when-ready-changed"
+    case SleepTimerChanged = "sleep-timer-changed"
+    case SleepTimerComplete = "sleep-timer-complete"
+    case MetadataChapterReceived = "metadata-chapter-received"
+    case MetadataTimedReceived = "metadata-timed-received"
+    case MetadataCommonReceived = "metadata-common-received"
+
+    case FFTUpdated = "fft-updated"
+    case ControllerConnected = "android-controller-connected"
+    case ControllerDisconnected = "android-controller-disconnected"
+    case PlaybackAnimatedVolumeChanged = "playback-animated-volume-changed"
+
+    static func allRawValues() -> [String] {
+        return allCases.map { $0.rawValue }
+    }
+}

package/ios/RNTrackPlayer/Utils/Metadata.swift

@@ -0,0 +1,60 @@
+//
+//  Metadata.swift
+//  RNTrackPlayer
+//
+//  Created by David Chavez on 23.06.19.
+//  Copyright © 2019 David Chavez. All rights reserved.
+//
+
+import Foundation
+import MediaPlayer
+
+struct Metadata {
+    private static var currentImageTask: URLSessionDataTask?
+
+    static func update(for player: AudioPlayer, with metadata: [String: Any]) {
+        currentImageTask?.cancel()
+        var ret: [NowPlayingInfoKeyValue] = []
+        
+        if let title = metadata["title"] as? String {
+            ret.append(MediaItemProperty.title(title))
+        }
+        
+        if let artist = metadata["artist"] as? String {
+            ret.append(MediaItemProperty.artist(artist))
+        }
+        
+        if let album = metadata["album"] as? String {
+            ret.append(MediaItemProperty.albumTitle(album))
+        }
+        
+        if let duration = metadata["duration"] as? Double {
+            ret.append(MediaItemProperty.duration(duration))
+        }
+        
+        if let elapsedTime = metadata["elapsedTime"] as? Double {
+            ret.append(NowPlayingInfoProperty.elapsedPlaybackTime(elapsedTime))
+        }
+
+        if let isLiveStream = metadata["isLiveStream"] as? Bool {
+            ret.append(NowPlayingInfoProperty.isLiveStream(isLiveStream))
+        }
+        
+        player.nowPlayingInfoController.set(keyValues: ret)
+        
+        if let artworkURL = MediaURL(object: metadata["artwork"]) {
+            currentImageTask = URLSession.shared.dataTask(with: artworkURL.value, completionHandler: { [weak player] (data, _, error) in
+                if let data = data, let image = UIImage(data: data), error == nil {
+                    let artwork = MPMediaItemArtwork(boundsSize: image.size, requestHandler: { (size) -> UIImage in
+                        return image
+                    })
+                    player?.nowPlayingInfoController.set(keyValue: MediaItemProperty.artwork(artwork))
+                }
+            })
+            
+            currentImageTask?.resume()
+        } else {
+            player.nowPlayingInfoController.set(keyValue: MediaItemProperty.artwork(nil))
+        }
+    }
+}

package/ios/RNTrackPlayer/Video/RNTrackPlayerVideoView.swift

@@ -0,0 +1,83 @@
+import AVFoundation
+import Foundation
+import React
+
+@objc(RNTrackPlayerVideoView)
+class RNTrackPlayerVideoView: UIView {
+    override class var layerClass: AnyClass { AVPlayerLayer.self }
+
+    private var playerLayer: AVPlayerLayer {
+        return self.layer as! AVPlayerLayer
+    }
+
+    weak var bridge: RCTBridge?
+    private var resizeMode: String = "contain" {
+        didSet { updateResizeMode() }
+    }
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        backgroundColor = .black
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+    }
+
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        attachPlayerIfNeeded()
+    }
+
+    private func attachPlayerIfNeeded() {
+        guard playerLayer.player == nil else { return }
+        guard let avPlayer = RNTrackPlayer.sharedAVPlayer else { return }
+        playerLayer.player = avPlayer
+        updateResizeMode()
+
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(onPlayerRecreated),
+            name: .RNTPPlayerRecreated,
+            object: nil
+        )
+
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(appDidEnterBackground),
+                                               name: UIApplication.didEnterBackgroundNotification,
+                                               object: nil)
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(appWillEnterForeground),
+                                               name: UIApplication.willEnterForegroundNotification,
+                                               object: nil)
+    }
+
+    @objc private func onPlayerRecreated() {
+        playerLayer.player = RNTrackPlayer.sharedAVPlayer
+    }
+
+    @objc private func appDidEnterBackground() {
+        playerLayer.player = nil
+    }
+
+    @objc private func appWillEnterForeground() {
+        playerLayer.player = RNTrackPlayer.sharedAVPlayer
+    }
+
+    private func updateResizeMode() {
+        switch resizeMode {
+        case "cover": playerLayer.videoGravity = .resizeAspectFill
+        case "stretch": playerLayer.videoGravity = .resize
+        case "none": playerLayer.videoGravity = .resizeAspect
+        default: playerLayer.videoGravity = .resizeAspect // contain
+        }
+    }
+
+    @objc func setResizeMode(_ mode: NSString) {
+        resizeMode = mode as String
+    }
+}

package/ios/RNTrackPlayer/Video/RNTrackPlayerVideoViewManager.m

@@ -0,0 +1,5 @@
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(RNTrackPlayerVideoViewManager, RCTViewManager)
+RCT_EXPORT_VIEW_PROPERTY(resizeMode, NSString)
+@end

package/ios/RNTrackPlayer/Video/RNTrackPlayerVideoViewManager.swift

@@ -0,0 +1,17 @@
+import Foundation
+import React
+
+@objc(RNTrackPlayerVideoViewManager)
+class RNTrackPlayerVideoViewManager: RCTViewManager {
+    override static func requiresMainQueueSetup() -> Bool { true }
+
+    override func view() -> UIView! {
+        let v = RNTrackPlayerVideoView()
+        v.bridge = self.bridge
+        return v
+    }
+
+    @objc override func setValue(_ value: Any!, forKey key: String!) {
+        // No-op to silence undefined key warnings
+    }
+}

package/ios/SwiftAudioEx/Package.swift

@@ -0,0 +1,20 @@
+// swift-tools-version:5.3
+import PackageDescription
+
+let package = Package(
+    name: "SwiftAudioEx",
+    platforms: [.iOS(.v11), .macOS(.v11)],
+    products: [
+        .library(
+            name: "SwiftAudioEx",
+            targets: ["SwiftAudioEx"]),
+    ],
+    dependencies: [],
+    targets: [
+        .target(
+            name: "SwiftAudioEx",
+            dependencies: [],
+            path: "Sources/SwiftAudioEx"
+            ),
+    ]
+)