react-native-tpstreams 0.2.25 → 0.2.27

package/android/build.gradle

@@ -86,7 +86,7 @@ dependencies {
 }
 
 react {
-  jsRootDir = file("../spec/")
+  jsRootDir = file("../src/")
   libraryName = "TpstreamsView"
   codegenJavaPackageName = "com.tpstreams"
 }

package/android/src/main/java/com/tpstreams/TPStreamsRNPackage.kt

@@ -17,7 +17,6 @@ class TPStreamsRNPackage : ReactPackage {
     val modules: MutableList<NativeModule> = ArrayList()
     modules.add(TPStreamsRNModule(reactContext))
     modules.add(TPStreamsDownloadModule(reactContext))
-    modules.add(TPStreamsDownloadsModule(reactContext))
     return modules
   }
 }

package/ios/TPStreamsDownloadModule.mm

@@ -1,7 +1,48 @@
 #import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
 
-@interface RCT_EXTERN_MODULE(TPStreamsDownload, NSObject)
+@interface RCT_EXTERN_MODULE(TPStreamsDownload, RCTEventEmitter)
 
-// Add download-related methods here if needed
+// Download Progress Listener Methods
+RCT_EXTERN_METHOD(addDownloadProgressListener:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(removeDownloadProgressListener:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+// Download Control Methods
+RCT_EXTERN_METHOD(pauseDownload:(NSString *)videoId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(resumeDownload:(NSString *)videoId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(removeDownload:(NSString *)videoId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+// Download Status Methods
+RCT_EXTERN_METHOD(isDownloaded:(NSString *)videoId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(isDownloading:(NSString *)videoId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(isPaused:(NSString *)videoId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getDownloadStatus:(NSString *)videoId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getAllDownloads:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(supportedEvents)
 
 @end 

package/ios/TPStreamsDownloadModule.swift

@@ -1,13 +1,265 @@
 import Foundation
 import React
+import TPStreamsSDK
+
+private enum PlayerConstants {
+    static let statusNotDownloaded = "NotDownloaded"
+    static let statusDownloading = "Downloading"
+    static let statusPaused = "Paused"
+    static let statusCompleted = "Completed"
+    static let statusFailed = "Failed"
+    static let statusUnknown = "Unknown"
+}
 
 @objc(TPStreamsDownload)
-class TPStreamsDownloadModule: NSObject {
+class TPStreamsDownloadModule: RCTEventEmitter, TPStreamsDownloadDelegate {
+    
+    private let downloadManager = TPStreamsDownloadManager.shared
+    private var isListening = false
+    
+    override init() {
+        super.init()
+        downloadManager.setTPStreamsDownloadDelegate(tpStreamsDownloadDelegate: self)
+    }
+    
+    @objc
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+    
+    @objc
+    func addDownloadProgressListener(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        isListening = true
+        resolve(nil)
+    }
+    
+    @objc
+    func removeDownloadProgressListener(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        isListening = false
+        resolve(nil)
+    }
+    
+    func onProgressChange(assetId: String, percentage: Double) {
+        if isListening {
+            notifyDownloadsChange()
+        }
+    }
+    
+    func onStateChange(status: Status, offlineAsset: OfflineAsset) {
+        if isListening {
+            notifyDownloadsChange()
+        }
+    }
+    
+    func onDelete(assetId: String) {
+        if isListening {
+            notifyDownloadsChange()
+        }
+    }
+    
+    func onStart(offlineAsset: OfflineAsset) {
+        if isListening {
+            notifyDownloadsChange()
+        }
+    }
+    
+    func onComplete(offlineAsset: OfflineAsset) {
+        if isListening {
+            notifyDownloadsChange()
+        }
+    }
+    
+    func onPause(offlineAsset: OfflineAsset) {
+        if isListening {
+            notifyDownloadsChange()
+        }
+    }
+    
+    func onResume(offlineAsset: OfflineAsset) {
+        if isListening {
+            notifyDownloadsChange()
+        }
+    }
+    
+    func onCanceled(assetId: String) {
+        if isListening {
+            notifyDownloadsChange()
+        }
+    }
+    
+    private func notifyDownloadsChange() {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            let downloadAssets = self.getAllDownloadItems()
+            self.sendEvent(withName: "onDownloadProgressChanged", body: downloadAssets)
+        }
+    }
+    
+    private func getAllDownloadItems() -> [[String: Any]] {
+        let offlineAssets = downloadManager.getAllOfflineAssets()
+        return offlineAssets.map { mapOfflineAssetToDict($0) }
+    }
+    
+    private func mapOfflineAssetToDict(_ asset: OfflineAsset) -> [String: Any] {
+        var item: [String: Any] = [:]
+        item["videoId"] = asset.assetId
+        item["title"] = asset.title
+        item["totalBytes"] = asset.size
+        item["downloadedBytes"] = calculateDownloadedBytes(size: asset.size, progress: asset.percentageCompleted)
+        item["progressPercentage"] = asset.percentageCompleted
+        item["state"] = mapDownloadStatus(Status(rawValue: asset.status))
+        item["metadata"] = "{}"
+        
+        return item
+    }
+
+    private func calculateDownloadedBytes(size: Any?, progress: Any?) -> Int64 {
+        guard let totalBytes = size as? Double,
+            let progressPercentage = progress as? Double else {
+            return 0
+        }
+        return Int64((progressPercentage / 100.0) * totalBytes)
+    }
+    
+    @objc
+    func pauseDownload(_ videoId: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else {
+                reject("ERROR", "Module deallocated", nil)
+                return
+            }
+            self.downloadManager.pauseDownload(videoId)
+            resolve(nil)
+        }
+    }
+    
+    @objc
+    func resumeDownload(_ videoId: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else {
+                reject("ERROR", "Module deallocated", nil)
+                return
+            }
+            self.downloadManager.resumeDownload(videoId)
+            resolve(nil)
+        }
+    }
+    
+    @objc
+    func removeDownload(_ videoId: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else {
+                reject("ERROR", "Module deallocated", nil)
+                return
+            }
+            if self.downloadManager.isAssetDownloaded(assetID: videoId) {
+                self.downloadManager.deleteDownload(videoId)
+            } else {
+                self.downloadManager.cancelDownload(videoId)
+            }
+            resolve(nil)
+        }
+    }
+    
+    @objc
+    func isDownloaded(_ videoId: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async { [weak self] in
+            resolve(self?.downloadManager.isAssetDownloaded(assetID: videoId) ?? false)
+        }
+    }
+    
+    @objc
+    func isDownloading(_ videoId: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else {
+                reject("ERROR", "Module deallocated", nil)
+                return
+            }
+            let offlineAssets = self.downloadManager.getAllOfflineAssets()
+            let isDownloading = offlineAssets.contains { asset in
+                asset.assetId == videoId && Status(rawValue: asset.status) == .inProgress
+            }
+            resolve(isDownloading)
+        }
+    }
     
     @objc
-    static func requiresMainQueueSetup() -> Bool {
-        return false
+    func isPaused(_ videoId: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else {
+                reject("ERROR", "Module deallocated", nil)
+                return
+            }
+            let offlineAssets = self.downloadManager.getAllOfflineAssets()
+            let isPaused = offlineAssets.contains { asset in
+                asset.assetId == videoId && Status(rawValue: asset.status) == .paused
+            }
+            resolve(isPaused)
+        }
     }
     
-    // Download functionality will be implemented in future commits
-} 
+    @objc
+    func getDownloadStatus(_ videoId: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else {
+                reject("ERROR", "Module deallocated", nil)
+                return
+            }
+            let offlineAssets = self.downloadManager.getAllOfflineAssets()
+            
+            if let asset = offlineAssets.first(where: { $0.assetId == videoId }) {
+                resolve(mapDownloadStatus(Status(rawValue: asset.status)))
+            } else {
+                resolve(PlayerConstants.statusNotDownloaded)
+            }
+        }
+    }
+    
+    @objc
+    func getAllDownloads(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else {
+                reject("ERROR", "Module deallocated", nil)
+                return
+            }
+            let downloadItems = self.getAllDownloadItems()
+            resolve(downloadItems)
+        }
+    }
+
+    private func mapDownloadStatus(_ status: Status?) -> String {
+        guard let status = status else { return PlayerConstants.statusUnknown }
+        
+        switch status {
+        case .inProgress:
+            return PlayerConstants.statusDownloading
+        case .paused:
+            return PlayerConstants.statusPaused
+        case .finished:
+            return PlayerConstants.statusCompleted
+        case .failed:
+            return PlayerConstants.statusFailed
+        default:
+            return PlayerConstants.statusNotDownloaded
+        }
+    }
+
+    @objc
+    override func supportedEvents() -> [String] {
+        return ["onDownloadProgressChanged"]
+    }
+    
+    @objc
+    override func addListener(_ eventName: String) {
+        super.addListener(eventName)
+    }
+    
+    @objc
+    override func removeListeners(_ count: Double) {
+        super.removeListeners(count)
+        
+        if count >= 1 && isListening {
+            isListening = false
+        }
+    }
+}

package/ios/TPStreamsModule.swift

@@ -10,13 +10,15 @@ class TPStreamsModule: NSObject {
    @objc func initialize(_ organizationId: NSString) {
      if !isInitialized {
        print("Initializing TPStreamsSDK with org code: \(organizationId)")
-       TPStreamsSDK.initialize(withOrgCode: organizationId as String)
-       isInitialized = true
+       DispatchQueue.main.async {
+        TPStreamsSDK.initialize(withOrgCode: organizationId as String)
+        self.isInitialized = true
+       }
      }
    }
 
    @objc
    static func requiresMainQueueSetup() -> Bool {
-     return false
+     return true
    }
 }

package/ios/TPStreamsRNPlayerView.swift

@@ -9,17 +9,17 @@ class TPStreamsRNPlayerView: UIView {
 
     private var player: TPAVPlayer?
     private var playerViewController: TPStreamPlayerViewController?
-
-    private var _videoId: NSString = ""
-    private var _accessToken: NSString = ""
-    private var _shouldAutoPlay: Bool = true
-    private var _startAt: Double = 0
-    private var _enableDownload: Bool = false
-    private var _offlineLicenseExpireTime: Double = 0
-    private var _showDefaultCaptions: Bool = false
-    private var _downloadMetadata: String?
-    private var setupScheduled = false
     private var playerStatusObserver: NSKeyValueObservation?
+    private var setupScheduled = false
+    
+    @objc var videoId: NSString = ""
+    @objc var accessToken: NSString = ""
+    @objc var shouldAutoPlay: Bool = true
+    @objc var startAt: Double = 0
+    @objc var enableDownload: Bool = false
+    @objc var offlineLicenseExpireTime: Double = 0
+    @objc var showDefaultCaptions: Bool = false
+    @objc var downloadMetadata: NSString?
     
     @objc var onCurrentPosition: RCTDirectEventBlock?
     @objc var onDuration: RCTDirectEventBlock?
@@ -31,65 +31,7 @@ class TPStreamsRNPlayerView: UIView {
     @objc var onIsLoadingChanged: RCTDirectEventBlock?
     @objc var onError: RCTDirectEventBlock?
     @objc var onAccessTokenExpired: RCTDirectEventBlock?
-
-    @objc var videoId: NSString {
-        get { _videoId }
-        set {
-            _videoId = newValue
-            schedulePlayerSetup()
-        }
-    }
-
-    @objc var accessToken: NSString {
-        get { _accessToken }
-        set {
-            _accessToken = newValue
-            schedulePlayerSetup()
-        }
-    }
-    
-    @objc var shouldAutoPlay: Bool {
-        get { _shouldAutoPlay }
-        set {
-            _shouldAutoPlay = newValue
-        }
-    }
-    
-    @objc var startAt: Double {
-        get { _startAt }
-        set {
-            _startAt = newValue
-        }
-    }
-    
-    @objc var enableDownload: Bool {
-        get { _enableDownload }
-        set {
-            _enableDownload = newValue
-        }
-    }
-    
-    @objc var offlineLicenseExpireTime: Double {
-        get { _offlineLicenseExpireTime }
-        set {
-            _offlineLicenseExpireTime = newValue
-        }
-    }
     
-    @objc var showDefaultCaptions: Bool {
-        get { _showDefaultCaptions }
-        set {
-            _showDefaultCaptions = newValue
-        }
-    }
-    
-    @objc var downloadMetadata: NSString? {
-        get { _downloadMetadata as NSString? }
-        set {
-            _downloadMetadata = newValue as String?
-        }
-    }
-
     override init(frame: CGRect) {
         super.init(frame: frame)
         backgroundColor = .black
@@ -104,46 +46,91 @@ class TPStreamsRNPlayerView: UIView {
         super.layoutSubviews()
         playerViewController?.view.frame = bounds
     }
+    
+    override func didSetProps(_ changedProps: [String]!) {
+        super.didSetProps(changedProps)
+        schedulePlayerSetup()
+    }
 
     private func schedulePlayerSetup() {
-        guard videoId.length > 0, accessToken.length > 0 else { return }
-
-        if setupScheduled { return }
+        guard !setupScheduled else { return }
+        
         setupScheduled = true
-
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
-            self.setupPlayer()
+        DispatchQueue.main.async { [weak self] in
+            self?.setupPlayer()
         }
     }
-
+    
     private func setupPlayer() {
+        cleanupPlayer()
+        
+        player = TPStreamsDownloadManager.shared.isAssetDownloaded(assetID: videoId as String)
+            ? createOfflinePlayer()
+            : createOnlinePlayer()
+        
+        guard player != nil else {
+            print("Failed to create player - invalid videoId or accessToken")
+            setupScheduled = false
+            return
+        }
+
+        configurePlayerView()
+        observePlayerChanges()
+        setupScheduled = false
+    }
+    
+    private func cleanupPlayer() {
+        removeObservers()
         playerViewController?.view.removeFromSuperview()
         playerViewController?.removeFromParent()
         playerViewController = nil
         player = nil
+    }
+    
+    private func removeObservers() {
         playerStatusObserver?.invalidate()
-
-        player = TPAVPlayer(assetID: videoId as String, accessToken: accessToken as String) { error in
-            if let error = error {
-                print("Online setup error: \(error.localizedDescription)")
-                let nsError = error as NSError
-                self.onError?([
-                    "message": "Player initialization failed",
-                    "code": nsError.code,
-                    "details": error.localizedDescription
-                ])
-            }
+    }
+    
+    private func createOfflinePlayer() -> TPAVPlayer? {
+        guard videoId.length > 0 else { return nil }
+        return TPAVPlayer(offlineAssetId: videoId as String) { [weak self] error in
+            self?.handlePlayerError(error, context: "Offline setup")
         }
-        
-        if startAt > 0 {
-            playerStatusObserver = player?.observe(\.status, options: [.new]) { [weak self] player, _ in
-                guard let self = self, player.status == .readyToPlay else { return }
-                self.seekTo(position: self.startAt*1000.0)
-                self.playerStatusObserver?.invalidate()
-                self.playerStatusObserver = nil
-            }
+    }
+    
+    private func createOnlinePlayer() -> TPAVPlayer? {
+        guard videoId.length > 0, accessToken.length > 0 else { return nil }
+        return TPAVPlayer(assetID: videoId as String, accessToken: accessToken as String) { [weak self] error in
+            self?.handlePlayerError(error, context: "Online setup")
         }
-
+    }
+    
+    private func handlePlayerError(_ error: Error?, context: String) {
+        guard let error = error else { return }
+        let nsError = error as NSError
+        print("\(context) error: \(error.localizedDescription)")
+        onError?([
+            "message": "Player initialization failed",
+            "code": nsError.code,
+            "details": error.localizedDescription
+        ])
+    }
+    
+    private func configurePlayerView() {
+        guard let player = player else { return }
+        
+        let configBuilder = createPlayerConfigBuilder()
+        let playerVC = TPStreamPlayerViewController()
+        playerVC.player = player
+        playerVC.config = configBuilder.build()
+        
+        attachPlayerViewController(playerVC)
+        
+        if shouldAutoPlay { player.play() }
+        playerViewController = playerVC
+    }
+    
+    private func createPlayerConfigBuilder() -> TPStreamPlayerConfigurationBuilder {
         let configBuilder = TPStreamPlayerConfigurationBuilder()
             .setPreferredForwardDuration(15)
             .setPreferredRewindDuration(5)
@@ -154,27 +141,34 @@ class TPStreamsRNPlayerView: UIView {
             configBuilder.showDownloadOption()
         }
         
-        let config = configBuilder.build()
-
-        let vc = TPStreamPlayerViewController()
-        vc.player = player
-        vc.config = config
-
-        if let parentVC = self.reactViewController() {
-            parentVC.addChild(vc)
-            addSubview(vc.view)
-            vc.view.frame = bounds
-            vc.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-            vc.view.isHidden = false
-            bringSubviewToFront(vc.view)
-            vc.didMove(toParent: parentVC)
-        }
-
-        if shouldAutoPlay {
-            player?.play()
-        }
+        return configBuilder
+    }
+    
+    private func attachPlayerViewController(_ playerVC: TPStreamPlayerViewController) {
+        guard let parentVC = reactViewController() else { return }
+        
+        parentVC.addChild(playerVC)
+        addSubview(playerVC.view)
+        playerVC.view.frame = bounds
+        playerVC.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        playerVC.view.isHidden = false
+        bringSubviewToFront(playerVC.view)
+        playerVC.didMove(toParent: parentVC)
+    }
         
-        playerViewController = vc
+    private func observePlayerChanges() {
+        setupSeekObserver()
+    }
+    
+    private func setupSeekObserver() {
+        guard let player = player, startAt > 0 else { return }
+        
+        playerStatusObserver = player.observe(\.status, options: [.new]) { [weak self] player, _ in
+            guard let self = self, player.status == .readyToPlay else { return }
+            self.seekTo(position: self.startAt * 1000.0)
+            self.playerStatusObserver?.invalidate()
+            self.playerStatusObserver = nil
+        }
     }
     
     @objc func seekTo(position: Double) {
@@ -184,13 +178,9 @@ class TPStreamsRNPlayerView: UIView {
         player.seek(to: seekTime, toleranceBefore: .zero, toleranceAfter: .zero)
     }
     
-    @objc func play() {
-        player?.play()
-    }
-    
-    @objc func pause() {
-        player?.pause()
-    }
+    @objc func play() { player?.play() }
+
+    @objc func pause() { player?.pause() }
     
     @objc func setPlaybackSpeed(_ speed: Float) {
         player?.rate = speed
@@ -201,42 +191,34 @@ class TPStreamsRNPlayerView: UIView {
             onCurrentPosition?(["position": 0])
             return
         }
-        
-        let currentTime = player.currentTime()
-        let positionMs = CMTimeGetSeconds(currentTime) * 1000
+        let positionMs = CMTimeGetSeconds(player.currentTime()) * 1000
         onCurrentPosition?(["position": positionMs])
     }
     
     @objc func getDuration() {
-        guard let player = player, let currentItem = player.currentItem else {
+        guard let duration = player?.currentItem?.duration else {
             onDuration?(["duration": 0])
             return
         }
-        
-        let durationMs = CMTimeGetSeconds(currentItem.duration) * 1000
+        let durationMs = CMTimeGetSeconds(duration) * 1000
         onDuration?(["duration": durationMs])
     }
     
     @objc func isPlaying() {
-        guard let player = player else {
-            onIsPlaying?(["isPlaying": false])
-            return
-        }
-        
-        let isPlaying = player.timeControlStatus == .playing
+        let isPlaying = player?.timeControlStatus == .playing
         onIsPlaying?(["isPlaying": isPlaying])
     }
     
     @objc func getPlaybackSpeed() {
-        let speed = player?.rate ?? 1.0
-        onPlaybackSpeed?(["speed": speed])
+        onPlaybackSpeed?(["speed": player?.rate ?? 1.0])
     }
 
     @objc func setNewAccessToken(_ newToken: String) {
-        print("TPStreamsRNPlayerView: setNewAccessToken called with token: \(newToken)")
+        print("New access token set: \(newToken)")
+        // TODO: Reinitialize player with new token if needed
     }
-
+    
     deinit {
-        playerStatusObserver?.invalidate()
+        removeObservers()
     }
 }