react-native-tpstreams 0.2.19 → 0.2.20

package/TPStreamsRNPlayerView.podspec

@@ -9,14 +9,20 @@ Pod::Spec.new do |s|
   s.homepage     = package["homepage"]
   s.license      = package["license"]
   s.authors      = package["author"]
+  s.swift_version = '5.0'
 
   s.platforms    = { :ios => min_ios_version_supported }
   s.source       = { :git => "https://github.com/testpress/react-native-tpstreams.git", :tag => "#{s.version}" }
 
   s.source_files = "ios/**/*.{h,m,mm,cpp,swift}"
   s.private_header_files = "ios/**/*.h"
-  
-  s.swift_version = '5.0'
+
+  s.pod_target_xcconfig = {
+      'DEFINES_MODULE' => 'YES',
+      'CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES' => 'YES'
+    }
+  s.dependency "TPStreamsSDK"
+
   
   # Ensure the module is not built as a framework to avoid bridging header conflicts
   s.static_framework = true

package/android/build.gradle

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

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

@@ -0,0 +1,143 @@
+package com.tpstreams
+
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.tpstreams.NativeTPStreamsDownloadsSpec
+import com.tpstreams.player.download.DownloadClient
+import com.tpstreams.player.download.DownloadItem
+import org.json.JSONObject
+import com.facebook.react.bridge.WritableMap
+
+class TPStreamsDownloadsModule(private val reactContext: ReactApplicationContext) : 
+    NativeTPStreamsDownloadsSpec(reactContext), 
+    DownloadClient.Listener {
+
+    private val downloadClient: DownloadClient by lazy {
+        DownloadClient.getInstance(reactContext)
+    }
+
+    private var isListening = false
+    private val TAG = "TPStreamsDownloadsModule"
+
+    override fun getAll(promise: Promise) {
+        try {
+            val downloadItems = downloadClient.getAllDownloadItems()
+            val result = Arguments.createArray()
+            
+            for (item in downloadItems) {
+                result.pushMap(convertDownloadItemToMap(item))
+            }
+            
+            promise.resolve(result)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error getting all download items: ${e.message}", e)
+            promise.reject("DOWNLOAD_ITEMS_ERROR", e.message, e)
+        }
+    }
+
+    override fun get(videoId: String, promise: Promise) {
+        try {
+            val download = downloadClient.getDownload(videoId)
+            download?.let { 
+                val item = downloadClient.createDownloadItem(it)
+                promise.resolve(convertDownloadItemToMap(item))
+            } ?: promise.resolve(null)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error getting download item: ${e.message}", e)
+            promise.reject("DOWNLOAD_ITEM_ERROR", e.message, e)
+        }
+    }
+
+    override fun pause(videoId: String, promise: Promise) {
+        try {
+            downloadClient.pauseDownload(videoId)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error pausing download: ${e.message}", e)
+            promise.reject("DOWNLOAD_PAUSE_ERROR", e.message, e)
+        }
+    }
+
+    override fun resume(videoId: String, promise: Promise) {
+        try {
+            downloadClient.resumeDownload(videoId)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error resuming download: ${e.message}", e)
+            promise.reject("DOWNLOAD_RESUME_ERROR", e.message, e)
+        }
+    }
+
+    override fun remove(videoId: String, promise: Promise) {
+        try {
+            downloadClient.removeDownload(videoId)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error removing download: ${e.message}", e)
+            promise.reject("DOWNLOAD_REMOVE_ERROR", e.message, e)
+        }
+    }
+
+    override fun startProgressUpdates() {
+        if (!isListening) {
+            downloadClient.addListener(this)
+            isListening = true
+            Log.d(TAG, "Started listening for download progress updates")
+        }
+    }
+
+    override fun stopProgressUpdates() {
+        if (isListening) {
+            downloadClient.removeListener(this)
+            isListening = false
+            Log.d(TAG, "Stopped listening for download progress updates")
+        }
+    }
+
+    override fun addListener(eventName: String) {
+        // Required by NativeEventEmitter, but no-op
+        // Actual listener registration happens in startProgressUpdates
+    }
+
+    override fun removeListeners(count: Double) {
+        // Required by NativeEventEmitter, but no-op
+        // Actual listener removal happens in stopProgressUpdates
+    }
+
+    override fun onDownloadsChanged() {
+        try {
+            val currentDownloads = downloadClient.getAllDownloadItems()
+            
+            val result = Arguments.createArray()
+            for (item in currentDownloads) {
+                result.pushMap(convertDownloadItemToMap(item))
+            }
+            
+            emitEvent("onDownloadProgressChanged", result)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in onDownloadsChanged: ${e.message}", e)
+        }
+    }
+
+    private fun convertDownloadItemToMap(item: DownloadItem): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("videoId", item.assetId)
+        map.putString("title", item.title)
+        item.thumbnailUrl?.let { map.putString("thumbnailUrl", it) }
+        map.putDouble("totalBytes", item.totalBytes.toDouble())
+        map.putDouble("downloadedBytes", item.downloadedBytes.toDouble())
+        map.putDouble("progressPercentage", item.progressPercentage.toDouble())
+        map.putString("state", downloadClient.getDownloadStatus(item.assetId))
+        return map
+    }
+
+    private fun emitEvent(eventName: String, data: Any) {
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, data)
+    }
+}

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

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

package/ios/TPStreamsDownloadsModule.mm

@@ -0,0 +1,32 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(TPStreamsDownloads, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(getAll:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(get:(NSString *)videoId
+                 resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(pause:(NSString *)videoId
+                 resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(resume:(NSString *)videoId
+                 resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(remove:(NSString *)videoId
+                 resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject)
+
+// Required for RCTEventEmitter
+RCT_EXTERN_METHOD(supportedEvents)
+
+// Required by NativeEventEmitter
+RCT_EXTERN_METHOD(addListener:(NSString *)eventName)
+RCT_EXTERN_METHOD(removeListeners:(double)count)
+
+@end

package/ios/TPStreamsDownloadsModule.swift

@@ -0,0 +1,92 @@
+import Foundation
+import React
+
+@objc(TPStreamsDownloads)
+class TPStreamsDownloadsModule: NSObject, RCTEventEmitterProtocol {
+    
+    private var hasListeners = false
+    
+    @objc
+    static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+    
+    @objc
+    func supportedEvents() -> [String] {
+        return [
+            "onDownloadProgressChanged"
+        ]
+    }
+    
+    @objc
+    func startObserving() {
+        hasListeners = true
+        // TODO: Add observer for download progress changes
+    }
+    
+    @objc
+    func stopObserving() {
+        hasListeners = false
+        // TODO: Remove observer
+    }
+
+    @objc
+    func sendEvent(withName name: String, body: Any?) {
+        // This method is required by RCTEventEmitterProtocol
+        // It should send events to React Native when hasListeners is true
+        if hasListeners {
+            // TODO: Implement actual event sending logic
+            // For now, this satisfies the protocol requirement
+        }
+    }
+    
+    // MARK: - Native Methods (TODO: Implement with TPDownloadClient)
+    
+    @objc
+    func getAll(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        // TODO: Get all downloads from TPDownloadClient.shared.getAllDownloads()
+        resolve([])
+    }
+    
+    @objc
+    func get(_ videoId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        // TODO: Get download by videoId from TPDownloadClient.shared.getDownload(videoId:)
+        resolve(nil)
+    }
+    
+    @objc
+    func pause(_ videoId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        // TODO: Pause download using TPDownloadClient.shared.pauseDownload(videoId:)
+        resolve(nil)
+    }
+    
+    @objc
+    func resume(_ videoId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        // TODO: Resume download using TPDownloadClient.shared.resumeDownload(videoId:)
+        resolve(nil)
+    }
+    
+    @objc
+    func remove(_ videoId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        // TODO: Remove download using TPDownloadClient.shared.removeDownload(videoId:)
+        resolve(nil)
+    }
+    
+    @objc
+    func addListener(_ eventName: String) {
+        // Required for RCTEventEmitter
+    }
+    
+    @objc
+    func removeListeners(_ count: NSNumber) {
+        // Required for RCTEventEmitter
+    }
+}
+
+// Protocol to avoid direct dependency on RCTEventEmitter
+@objc protocol RCTEventEmitterProtocol {
+    func supportedEvents() -> [String]
+    func startObserving()
+    func stopObserving()
+    func sendEvent(withName name: String, body: Any?)
+}

package/ios/TPStreamsModule.swift

@@ -1,17 +1,22 @@
 import Foundation
 import React
+import TPStreamsSDK
 
 @objc(TPStreams)
 class TPStreamsModule: NSObject {
-    
-    @objc
-    static func requiresMainQueueSetup() -> Bool {
-        return false
-    }
-    
-    @objc
-    func initialize(_ organizationId: String) {
-        // Basic initialization - will be implemented in future commits
-        print("TPStreams initialized with organization ID: \(organizationId)")
-    }
-} 
+
+   private var isInitialized = false
+
+   @objc func initialize(_ organizationId: NSString) {
+     if !isInitialized {
+       print("Initializing TPStreamsSDK with org code: \(organizationId)")
+       TPStreamsSDK.initialize(withOrgCode: organizationId as String)
+       isInitialized = true
+     }
+   }
+
+   @objc
+   static func requiresMainQueueSetup() -> Bool {
+     return false
+   }
+}

package/ios/TPStreamsRNPlayerView.swift

@@ -0,0 +1,242 @@
+import UIKit
+import TPStreamsSDK
+import CoreMedia
+import React
+import AVFoundation
+
+@objc(TPStreamsRNPlayerView)
+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?
+    
+    @objc var onCurrentPosition: RCTDirectEventBlock?
+    @objc var onDuration: RCTDirectEventBlock?
+    @objc var onIsPlaying: RCTDirectEventBlock?
+    @objc var onPlaybackSpeed: RCTDirectEventBlock?
+    @objc var onPlayerStateChanged: RCTDirectEventBlock?
+    @objc var onIsPlayingChanged: RCTDirectEventBlock?
+    @objc var onPlaybackSpeedChanged: RCTDirectEventBlock?
+    @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
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        backgroundColor = .black
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        playerViewController?.view.frame = bounds
+    }
+
+    private func schedulePlayerSetup() {
+        guard videoId.length > 0, accessToken.length > 0 else { return }
+
+        if setupScheduled { return }
+        setupScheduled = true
+
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+            self.setupPlayer()
+        }
+    }
+
+    private func setupPlayer() {
+        playerViewController?.view.removeFromSuperview()
+        playerViewController?.removeFromParent()
+        playerViewController = nil
+        player = nil
+        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
+                ])
+            }
+        }
+        
+        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
+            }
+        }
+
+        let configBuilder = TPStreamPlayerConfigurationBuilder()
+            .setPreferredForwardDuration(15)
+            .setPreferredRewindDuration(5)
+            .setprogressBarThumbColor(.systemBlue)
+            .setwatchedProgressTrackColor(.systemBlue)
+        
+        if enableDownload {
+            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()
+        }
+        
+        playerViewController = vc
+    }
+    
+    @objc func seekTo(position: Double) {
+        guard position >= 0, let player = player else { return }
+        
+        let seekTime = CMTime(value: CMTimeValue(position), timescale: 1000)
+        player.seek(to: seekTime, toleranceBefore: .zero, toleranceAfter: .zero)
+    }
+    
+    @objc func play() {
+        player?.play()
+    }
+    
+    @objc func pause() {
+        player?.pause()
+    }
+    
+    @objc func setPlaybackSpeed(_ speed: Float) {
+        player?.rate = speed
+    }
+    
+    @objc func getCurrentPosition() {
+        guard let player = player else {
+            onCurrentPosition?(["position": 0])
+            return
+        }
+        
+        let currentTime = player.currentTime()
+        let positionMs = CMTimeGetSeconds(currentTime) * 1000
+        onCurrentPosition?(["position": positionMs])
+    }
+    
+    @objc func getDuration() {
+        guard let player = player, let currentItem = player.currentItem else {
+            onDuration?(["duration": 0])
+            return
+        }
+        
+        let durationMs = CMTimeGetSeconds(currentItem.duration) * 1000
+        onDuration?(["duration": durationMs])
+    }
+    
+    @objc func isPlaying() {
+        guard let player = player else {
+            onIsPlaying?(["isPlaying": false])
+            return
+        }
+        
+        let isPlaying = player.timeControlStatus == .playing
+        onIsPlaying?(["isPlaying": isPlaying])
+    }
+    
+    @objc func getPlaybackSpeed() {
+        let speed = player?.rate ?? 1.0
+        onPlaybackSpeed?(["speed": speed])
+    }
+
+    @objc func setNewAccessToken(_ newToken: String) {
+        print("TPStreamsRNPlayerView: setNewAccessToken called with token: \(newToken)")
+    }
+
+    deinit {
+        playerStatusObserver?.invalidate()
+    }
+}

package/ios/TPStreamsRNPlayerViewManager.m

@@ -0,0 +1,38 @@
+#import <React/RCTViewManager.h>
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(TPStreamsRNPlayerViewManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(videoId, NSString)
+RCT_EXPORT_VIEW_PROPERTY(accessToken, NSString)
+RCT_EXPORT_VIEW_PROPERTY(shouldAutoPlay, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(startAt, double)
+RCT_EXPORT_VIEW_PROPERTY(enableDownload, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(offlineLicenseExpireTime, double)
+RCT_EXPORT_VIEW_PROPERTY(showDefaultCaptions, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(downloadMetadata, NSString)
+
+// Event props
+RCT_EXPORT_VIEW_PROPERTY(onCurrentPosition, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onDuration, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onIsPlaying, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPlaybackSpeed, RCTDirectEventBlock)
+
+RCT_EXPORT_VIEW_PROPERTY(onPlayerStateChanged, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onIsPlayingChanged, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPlaybackSpeedChanged, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onIsLoadingChanged, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onError, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onAccessTokenExpired, RCTDirectEventBlock)
+
+// Player commands
+RCT_EXTERN_METHOD(play:(nonnull NSNumber *)node)
+RCT_EXTERN_METHOD(pause:(nonnull NSNumber *)node)
+RCT_EXTERN_METHOD(seekTo:(nonnull NSNumber *)node position:(nonnull NSNumber *)position)
+RCT_EXTERN_METHOD(setPlaybackSpeed:(nonnull NSNumber *)node speed:(nonnull NSNumber *)speed)
+RCT_EXTERN_METHOD(getCurrentPosition:(nonnull NSNumber *)node)
+RCT_EXTERN_METHOD(getDuration:(nonnull NSNumber *)node)
+RCT_EXTERN_METHOD(isPlaying:(nonnull NSNumber *)node)
+RCT_EXTERN_METHOD(getPlaybackSpeed:(nonnull NSNumber *)node)
+
+@end