react-native-tpstreams 1.1.0-debug.2 → 1.1.0-debug.3

package/ios/TPStreamsRNPlayerView.swift

@@ -28,6 +28,14 @@ class TPStreamsRNPlayerView: UIView {
     private var pendingOfflineCredentialsCompletion: ((String?, Double) -> Void)?
     private var _offlineLicenseExpireTime: Double = TPStreamsRNPlayerView.maxOfflineLicenseDuration
     
+    // Add a property to track when play() was called
+    private var playCallTime: CFAbsoluteTime?
+    private var playerReadyTime: CFAbsoluteTime?
+    private var playbackStartTime: CFAbsoluteTime?
+    
+    // Add a property to track when setup started (for relative timing)
+    private var setupStartTime: CFAbsoluteTime?
+    
     @objc var videoId: NSString = ""
     @objc var accessToken: NSString = ""
     @objc var shouldAutoPlay: Bool = true
@@ -57,11 +65,17 @@ class TPStreamsRNPlayerView: UIView {
     override init(frame: CGRect) {
         super.init(frame: frame)
         backgroundColor = .black
+        let deviceModel = UIDevice.current.model
+        let systemVersion = UIDevice.current.systemVersion
+        print("⏱️ [TPStreams] TPStreamsRNPlayerView init() - Device: \(deviceModel), iOS: \(systemVersion)")
     }
 
     required init?(coder: NSCoder) {
         super.init(coder: coder)
         backgroundColor = .black
+        let deviceModel = UIDevice.current.model
+        let systemVersion = UIDevice.current.systemVersion
+        print("⏱️ [TPStreams] TPStreamsRNPlayerView init(coder:) - Device: \(deviceModel), iOS: \(systemVersion)")
     }
 
     override func layoutSubviews() {
@@ -71,38 +85,93 @@ class TPStreamsRNPlayerView: UIView {
     
     override func didSetProps(_ changedProps: [String]!) {
         super.didSetProps(changedProps)
+        let propsTime = CFAbsoluteTimeGetCurrent()
+        print("⏱️ [TPStreams] didSetProps() called with props: \(changedProps ?? [])")
         schedulePlayerSetup()
+        let propsDuration = CFAbsoluteTimeGetCurrent() - propsTime
+        print("⏱️ [TPStreams] didSetProps() took: \(String(format: "%.3f", propsDuration * 1000))ms")
     }
 
     private func schedulePlayerSetup() {
-        guard !setupScheduled else { return }
+        guard !setupScheduled else {
+            print("⏱️ [TPStreams] setupPlayer() already scheduled, skipping")
+            return
+        }
         
+        let scheduleTime = CFAbsoluteTimeGetCurrent()
         setupScheduled = true
+        print("⏱️ [TPStreams] schedulePlayerSetup() - scheduling async setup")
         DispatchQueue.main.async { [weak self] in
+            let asyncDelay = CFAbsoluteTimeGetCurrent() - scheduleTime
+            print("⏱️ [TPStreams] schedulePlayerSetup() - async dispatch delay: \(String(format: "%.3f", asyncDelay * 1000))ms")
             self?.setupPlayer()
         }
     }
     
     private func setupPlayer() {
+        let setupStartTime = CFAbsoluteTimeGetCurrent()
+        self.setupStartTime = setupStartTime  // Store for relative timing
+        print("⏱️ [TPStreams] ========== setupPlayer() STARTED ==========")
+        print("⏱️ [TPStreams] videoId: \(videoId), accessToken length: \(accessToken.length)")
+        
+        // Cleanup
+        let cleanupStartTime = CFAbsoluteTimeGetCurrent()
         cleanupPlayer()
+        let cleanupDuration = CFAbsoluteTimeGetCurrent() - cleanupStartTime
+        print("⏱️ [TPStreams] cleanupPlayer() took: \(String(format: "%.3f", cleanupDuration * 1000))ms")
+        
+        // Download check
+        let downloadCheckStartTime = CFAbsoluteTimeGetCurrent()
+        let isDownloaded = TPStreamsDownloadManager.shared.isAssetDownloaded(assetID: videoId as String)
+        let downloadCheckDuration = CFAbsoluteTimeGetCurrent() - downloadCheckStartTime
+        print("⏱️ [TPStreams] Download check took: \(String(format: "%.3f", downloadCheckDuration * 1000))ms (isDownloaded: \(isDownloaded))")
         
-        player = TPStreamsDownloadManager.shared.isAssetDownloaded(assetID: videoId as String)
+        // Player creation
+        let playerCreateStartTime = CFAbsoluteTimeGetCurrent()
+        player = isDownloaded
             ? createOfflinePlayer()
             : createOnlinePlayer()
+        let playerCreateDuration = CFAbsoluteTimeGetCurrent() - playerCreateStartTime
+        print("⏱️ [TPStreams] Player creation took: \(String(format: "%.3f", playerCreateDuration * 1000))ms")
         
         guard player != nil else {
-            print("Failed to create player - invalid videoId or accessToken")
+            print("❌ [TPStreams] Failed to create player - invalid videoId or accessToken")
             setupScheduled = false
             return
         }
+        
+        // Token delegate setup
+        let tokenDelegateStartTime = CFAbsoluteTimeGetCurrent()
         setupTokenDelegate()
+        let tokenDelegateDuration = CFAbsoluteTimeGetCurrent() - tokenDelegateStartTime
+        print("⏱️ [TPStreams] setupTokenDelegate() took: \(String(format: "%.3f", tokenDelegateDuration * 1000))ms")
+        
+        // View configuration
+        let configStartTime = CFAbsoluteTimeGetCurrent()
         configurePlayerView()
+        let configDuration = CFAbsoluteTimeGetCurrent() - configStartTime
+        print("⏱️ [TPStreams] configurePlayerView() took: \(String(format: "%.3f", configDuration * 1000))ms")
+        
+        // Observer setup
+        let observerStartTime = CFAbsoluteTimeGetCurrent()
         observePlayerChanges()
+        let observerDuration = CFAbsoluteTimeGetCurrent() - observerStartTime
+        print("⏱️ [TPStreams] observePlayerChanges() took: \(String(format: "%.3f", observerDuration * 1000))ms")
+        
         setupScheduled = false
+        
+        let totalDuration = CFAbsoluteTimeGetCurrent() - setupStartTime
+        print("⏱️ [TPStreams] ========== setupPlayer() COMPLETED in \(String(format: "%.3f", totalDuration * 1000))ms ==========")
     }
     
     private func cleanupPlayer() {
+        let cleanupStartTime = CFAbsoluteTimeGetCurrent()
+        
+        let removeObserversStartTime = CFAbsoluteTimeGetCurrent()
         removeObservers()
+        let removeObserversDuration = CFAbsoluteTimeGetCurrent() - removeObserversStartTime
+        print("⏱️ [TPStreams] removeObservers() took: \(String(format: "%.3f", removeObserversDuration * 1000))ms")
+        
         player?.pause()
         
         playerViewController?.view.removeFromSuperview()
@@ -111,6 +180,11 @@ class TPStreamsRNPlayerView: UIView {
         
         player?.replaceCurrentItem(with: nil)
         player = nil
+        
+        let totalCleanupDuration = CFAbsoluteTimeGetCurrent() - cleanupStartTime
+        if totalCleanupDuration > 0.001 { // Only log if cleanup took meaningful time
+            print("⏱️ [TPStreams] cleanupPlayer() total: \(String(format: "%.3f", totalCleanupDuration * 1000))ms")
+        }
     }
     
     private func removeObservers() {
@@ -125,17 +199,37 @@ class TPStreamsRNPlayerView: UIView {
     }
     
     private func createOfflinePlayer() -> TPAVPlayer? {
-        guard videoId.length > 0 else { return nil }
-        return TPAVPlayer(offlineAssetId: videoId as String) { [weak self] error in
+        let startTime = CFAbsoluteTimeGetCurrent()
+        guard videoId.length > 0 else {
+            print("❌ [TPStreams] createOfflinePlayer() - invalid videoId")
+            return nil
+        }
+        print("⏱️ [TPStreams] Creating offline player for videoId: \(videoId)")
+        let player = TPAVPlayer(offlineAssetId: videoId as String) { [weak self] error in
+            let errorTime = CFAbsoluteTimeGetCurrent()
+            print("⏱️ [TPStreams] Offline player error callback triggered at: \(String(format: "%.3f", errorTime * 1000))ms")
             self?.handlePlayerError(error, context: "Offline setup")
         }
+        let duration = CFAbsoluteTimeGetCurrent() - startTime
+        print("⏱️ [TPStreams] TPAVPlayer(offline) init took: \(String(format: "%.3f", duration * 1000))ms")
+        return player
     }
     
     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
+        let startTime = CFAbsoluteTimeGetCurrent()
+        guard videoId.length > 0, accessToken.length > 0 else {
+            print("❌ [TPStreams] createOnlinePlayer() - invalid videoId or accessToken")
+            return nil
+        }
+        print("⏱️ [TPStreams] Creating online player for videoId: \(videoId)")
+        let player = TPAVPlayer(assetID: videoId as String, accessToken: accessToken as String) { [weak self] error in
+            let errorTime = CFAbsoluteTimeGetCurrent()
+            // print("⏱️ [TPStreams] Online player error callback triggered at: \(String(format: "%.3f", errorTime * 1000))ms")
             self?.handlePlayerError(error, context: "Online setup")
         }
+        let duration = CFAbsoluteTimeGetCurrent() - startTime
+        print("⏱️ [TPStreams] TPAVPlayer(online) init took: \(String(format: "%.3f", duration * 1000))ms")
+        return player
     }
     
     private func handlePlayerError(_ error: Error?, context: String) {
@@ -150,7 +244,14 @@ class TPStreamsRNPlayerView: UIView {
     }
     
     private func configurePlayerView() {
-        guard let player = player else { return }
+        let configStartTime = CFAbsoluteTimeGetCurrent()
+        guard let player = player else {
+            print("❌ [TPStreams] configurePlayerView() - player is nil")
+            return
+        }
+        
+        // License renewal setup
+        let licenseSetupStartTime = CFAbsoluteTimeGetCurrent()
         player.onRequestOfflineLicenseRenewal = { [weak self] assetId, completion in
             guard let self = self else {
                 completion(nil, 0)
@@ -160,53 +261,132 @@ class TPStreamsRNPlayerView: UIView {
             self.pendingOfflineCredentialsCompletion = completion
             self.onAccessTokenExpired?(["videoId": assetId])
         }
+        let licenseSetupDuration = CFAbsoluteTimeGetCurrent() - licenseSetupStartTime
+        print("⏱️ [TPStreams] License renewal setup took: \(String(format: "%.3f", licenseSetupDuration * 1000))ms")
         
+        // Config builder
+        let configBuilderStartTime = CFAbsoluteTimeGetCurrent()
         let configBuilder = createPlayerConfigBuilder()
+        let configBuilderDuration = CFAbsoluteTimeGetCurrent() - configBuilderStartTime
+        print("⏱️ [TPStreams] createPlayerConfigBuilder() took: \(String(format: "%.3f", configBuilderDuration * 1000))ms")
+        
+        // View controller creation
+        let vcCreateStartTime = CFAbsoluteTimeGetCurrent()
         let playerVC = TPStreamPlayerViewController()
         playerVC.player = player
         playerVC.config = configBuilder.build()
+        let vcCreateDuration = CFAbsoluteTimeGetCurrent() - vcCreateStartTime
+        print("⏱️ [TPStreams] TPStreamPlayerViewController creation took: \(String(format: "%.3f", vcCreateDuration * 1000))ms")
         
+        // Attach view controller
+        let attachStartTime = CFAbsoluteTimeGetCurrent()
         attachPlayerViewController(playerVC)
+        let attachDuration = CFAbsoluteTimeGetCurrent() - attachStartTime
+        print("⏱️ [TPStreams] attachPlayerViewController() took: \(String(format: "%.3f", attachDuration * 1000))ms")
+        
+        if shouldAutoPlay {
+            let playStartTime = CFAbsoluteTimeGetCurrent()
+            playCallTime = playStartTime
+            print("⏱️ [TPStreams] 🎬 player.play() CALLED at: \(String(format: "%.3f", playStartTime * 1000))ms")
+            player.play()
+            let playDuration = CFAbsoluteTimeGetCurrent() - playStartTime
+            print("⏱️ [TPStreams] player.play() took: \(String(format: "%.3f", playDuration * 1000))ms")
+        }
         
-        if shouldAutoPlay { player.play() }
         playerViewController = playerVC
+        
+        let totalConfigDuration = CFAbsoluteTimeGetCurrent() - configStartTime
+        print("⏱️ [TPStreams] configurePlayerView() total: \(String(format: "%.3f", totalConfigDuration * 1000))ms")
     }
     
     private func createPlayerConfigBuilder() -> TPStreamPlayerConfigurationBuilder {
+        let builderStartTime = CFAbsoluteTimeGetCurrent()
+        
+        let parseStartTime = CFAbsoluteTimeGetCurrent()
         let metadataDict = parseMetadataJSON(from: downloadMetadata)
+        let parseDuration = CFAbsoluteTimeGetCurrent() - parseStartTime
+        print("⏱️ [TPStreams] parseMetadataJSON() took: \(String(format: "%.3f", parseDuration * 1000))ms")
+        
+        let builderCreateStartTime = CFAbsoluteTimeGetCurrent()
         let configBuilder = TPStreamPlayerConfigurationBuilder()
             .setPreferredForwardDuration(15)
             .setPreferredRewindDuration(5)
             .setprogressBarThumbColor(.systemBlue)
             .setwatchedProgressTrackColor(.systemBlue)
             .setDownloadMetadata(metadataDict)
+        let builderCreateDuration = CFAbsoluteTimeGetCurrent() - builderCreateStartTime
+        print("⏱️ [TPStreams] ConfigBuilder creation took: \(String(format: "%.3f", builderCreateDuration * 1000))ms")
 
+        let licenseStartTime = CFAbsoluteTimeGetCurrent()
         configBuilder.setLicenseDurationSeconds(offlineLicenseExpireTime)
+        let licenseDuration = CFAbsoluteTimeGetCurrent() - licenseStartTime
+        print("⏱️ [TPStreams] setLicenseDurationSeconds() took: \(String(format: "%.3f", licenseDuration * 1000))ms")
         
         if enableDownload {
+            let downloadOptionStartTime = CFAbsoluteTimeGetCurrent()
             configBuilder.showDownloadOption()
+            let downloadOptionDuration = CFAbsoluteTimeGetCurrent() - downloadOptionStartTime
+            print("⏱️ [TPStreams] showDownloadOption() took: \(String(format: "%.3f", downloadOptionDuration * 1000))ms")
         }
         
+        let totalBuilderDuration = CFAbsoluteTimeGetCurrent() - builderStartTime
+        print("⏱️ [TPStreams] createPlayerConfigBuilder() total: \(String(format: "%.3f", totalBuilderDuration * 1000))ms")
+        
         return configBuilder
     }
     
     private func attachPlayerViewController(_ playerVC: TPStreamPlayerViewController) {
-        guard let parentVC = reactViewController() else { return }
+        let attachStartTime = CFAbsoluteTimeGetCurrent()
+        guard let parentVC = reactViewController() else {
+            print("❌ [TPStreams] attachPlayerViewController() - reactViewController() is nil")
+            return
+        }
         
+        let addChildStartTime = CFAbsoluteTimeGetCurrent()
         parentVC.addChild(playerVC)
+        let addChildDuration = CFAbsoluteTimeGetCurrent() - addChildStartTime
+        print("⏱️ [TPStreams] addChild() took: \(String(format: "%.3f", addChildDuration * 1000))ms")
+        
         addSubview(playerVC.view)
         playerVC.view.frame = bounds
         playerVC.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
         playerVC.view.isHidden = false
         bringSubviewToFront(playerVC.view)
+        
+        let didMoveStartTime = CFAbsoluteTimeGetCurrent()
         playerVC.didMove(toParent: parentVC)
+        let didMoveDuration = CFAbsoluteTimeGetCurrent() - didMoveStartTime
+        print("⏱️ [TPStreams] didMove(toParent:) took: \(String(format: "%.3f", didMoveDuration * 1000))ms")
+        
+        let totalAttachDuration = CFAbsoluteTimeGetCurrent() - attachStartTime
+        print("⏱️ [TPStreams] attachPlayerViewController() total: \(String(format: "%.3f", totalAttachDuration * 1000))ms")
     }
         
     private func observePlayerChanges() {
+        let observerStartTime = CFAbsoluteTimeGetCurrent()
+        
+        let seekObserverStartTime = CFAbsoluteTimeGetCurrent()
         setupSeekObserver()
+        let seekObserverDuration = CFAbsoluteTimeGetCurrent() - seekObserverStartTime
+        print("⏱️ [TPStreams] setupSeekObserver() took: \(String(format: "%.3f", seekObserverDuration * 1000))ms")
+        
+        let playerStateObserverStartTime = CFAbsoluteTimeGetCurrent()
         setupPlayerStateObserver()
+        let playerStateObserverDuration = CFAbsoluteTimeGetCurrent() - playerStateObserverStartTime
+        print("⏱️ [TPStreams] setupPlayerStateObserver() took: \(String(format: "%.3f", playerStateObserverDuration * 1000))ms")
+        
+        let playbackSpeedObserverStartTime = CFAbsoluteTimeGetCurrent()
         setupPlaybackSpeedObserver()
+        let playbackSpeedObserverDuration = CFAbsoluteTimeGetCurrent() - playbackSpeedObserverStartTime
+        print("⏱️ [TPStreams] setupPlaybackSpeedObserver() took: \(String(format: "%.3f", playbackSpeedObserverDuration * 1000))ms")
+        
+        let playingStateObserverStartTime = CFAbsoluteTimeGetCurrent()
         setupPlayingStateObserver()
+        let playingStateObserverDuration = CFAbsoluteTimeGetCurrent() - playingStateObserverStartTime
+        print("⏱️ [TPStreams] setupPlayingStateObserver() took: \(String(format: "%.3f", playingStateObserverDuration * 1000))ms")
+        
+        let totalObserverDuration = CFAbsoluteTimeGetCurrent() - observerStartTime
+        print("⏱️ [TPStreams] observePlayerChanges() total: \(String(format: "%.3f", totalObserverDuration * 1000))ms")
     }
     
     private func setupSeekObserver() {
@@ -245,6 +425,37 @@ class TPStreamsRNPlayerView: UIView {
         guard let player = player else { return }
         
         playerStateObserver = player.observe(\.status, options: [.new, .initial]) { [weak self] player, _ in
+            let statusTime = CFAbsoluteTimeGetCurrent()
+            let statusString: String
+            switch player.status {
+            case .unknown:
+                statusString = "unknown"
+            case .readyToPlay:
+                statusString = "readyToPlay"
+                if self?.playerReadyTime == nil {
+                    self?.playerReadyTime = statusTime
+                    if let playCallTime = self?.playCallTime {
+                        let timeToReady = statusTime - playCallTime
+                        print("⏱️ [TPStreams] ✅ Player READY TO PLAY - Time from play() call: \(String(format: "%.3f", timeToReady * 1000))ms")
+                    } else {
+                        print("⏱️ [TPStreams] ✅ Player READY TO PLAY")
+                    }
+                }
+            case .failed:
+                statusString = "failed"
+                print("❌ [TPStreams] Player status: FAILED")
+            @unknown default:
+                statusString = "unknown"
+            }
+            
+            // Show relative time from setup start instead of absolute timestamp
+            if let setupStart = self?.setupStartTime {
+                let relativeTime = statusTime - setupStart
+                print("⏱️ [TPStreams] Player status changed to: \(statusString) at +\(String(format: "%.3f", relativeTime * 1000))ms from setup start")
+            } else {
+                print("⏱️ [TPStreams] Player status changed to: \(statusString)")
+            }
+            
             DispatchQueue.main.async {
                 let state = self?.mapPlayerStateToAndroid(player.status) ?? PlaybackState.idle.rawValue
                 self?.onPlayerStateChanged?(["playbackState": state])
@@ -252,6 +463,46 @@ class TPStreamsRNPlayerView: UIView {
         }
         
         timeControlStatusObserver = player.observe(\.timeControlStatus, options: [.new, .initial]) { [weak self] player, _ in
+            let controlStatusTime = CFAbsoluteTimeGetCurrent()
+            let statusString: String
+            switch player.timeControlStatus {
+            case .paused:
+                statusString = "paused"
+            case .waitingToPlayAtSpecifiedRate:
+                statusString = "waitingToPlayAtSpecifiedRate"
+                if let setupStart = self?.setupStartTime {
+                    let relativeTime = controlStatusTime - setupStart
+                    print("⏱️ [TPStreams] ⏳ Player WAITING TO PLAY (buffering) at +\(String(format: "%.3f", relativeTime * 1000))ms from setup start")
+                } else {
+                    print("⏱️ [TPStreams] ⏳ Player WAITING TO PLAY (buffering)")
+                }
+            case .playing:
+                statusString = "playing"
+                if self?.playbackStartTime == nil {
+                    self?.playbackStartTime = controlStatusTime
+                    if let playCallTime = self?.playCallTime {
+                        let timeToPlay = controlStatusTime - playCallTime
+                        print("⏱️ [TPStreams] 🎥 PLAYBACK STARTED! Time from play() call: \(String(format: "%.3f", timeToPlay * 1000))ms")
+                        if let readyTime = self?.playerReadyTime {
+                            let bufferingTime = controlStatusTime - readyTime
+                            print("⏱️ [TPStreams] 📊 Buffering time (readyToPlay → playing): \(String(format: "%.3f", bufferingTime * 1000))ms")
+                        }
+                    } else {
+                        print("⏱️ [TPStreams] 🎥 PLAYBACK STARTED!")
+                    }
+                }
+            @unknown default:
+                statusString = "unknown"
+            }
+            
+            // Show relative time from setup start
+            if let setupStart = self?.setupStartTime {
+                let relativeTime = controlStatusTime - setupStart
+                print("⏱️ [TPStreams] TimeControlStatus changed to: \(statusString) at +\(String(format: "%.3f", relativeTime * 1000))ms from setup start")
+            } else {
+                print("⏱️ [TPStreams] TimeControlStatus changed to: \(statusString)")
+            }
+            
             DispatchQueue.main.async {
                 let state = self?.mapPlayerStateToAndroid(player.status, timeControlStatus: player.timeControlStatus) ?? PlaybackState.idle.rawValue
                 self?.onPlayerStateChanged?(["playbackState": state])
@@ -284,7 +535,10 @@ class TPStreamsRNPlayerView: UIView {
     }
     
     private func setupTokenDelegate() {
+        let delegateStartTime = CFAbsoluteTimeGetCurrent()
         TPStreamsDownloadModule.shared?.setAccessTokenDelegate(self)
+        let delegateDuration = CFAbsoluteTimeGetCurrent() - delegateStartTime
+        print("⏱️ [TPStreams] setupTokenDelegate() took: \(String(format: "%.3f", delegateDuration * 1000))ms")
     }
 
     private static func sanitizeLicenseDuration(_ value: Double) -> Double {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-tpstreams",
-  "version": "1.1.0-debug.2",
+  "version": "1.1.0-debug.3",
   "description": "Video component for TPStreams",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",