react-native-tpstreams 0.1.14 → 0.2.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Bharath
+Copyright (c) 2025 Testpress
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights

package/README.md

@@ -1,6 +1,6 @@
 # react-native-tpstreams
 
-Video Component for TPStreams
+Video player component for TPStreams
 
 ## Installation
 
@@ -8,436 +8,38 @@ Video Component for TPStreams
 npm install react-native-tpstreams
 ```
 
-### Initializing TPStreams SDK
+## Usage
 
-First, import the package:
-
-```javascript
-import { NativeModules } from 'react-native';
-const { Tpstreams } = NativeModules;
-```
-
-Next, initialize the SDK with your organization ID:
-
-```javascript
-Tpstreams.initializeTPSPlayer("YOUR_ORGANIZATION_ID");
-```
-
-Make sure to replace `YOUR_ORGANIZATION_ID` with your actual organization ID. This should be called at the entry point of your application to ensure proper initialization.
-
-## Play a Video
-
-To play a video using the TPStreams Player SDK, use the `TpStreamsPlayerView` component:
-
-```javascript
-import React, { useState } from 'react';
-import { View, StyleSheet } from 'react-native';
-import TpStreamsPlayerView from 'react-native-tpstreams';
-
-const App = () => {
-  const [playerProps] = useState({
-    videoId: 'ASSET_ID',
-    accessToken: 'ACCESS_TOKEN',
-    enableDownload: false,
-    autoPlay: true,
-    startAt: 0,
-    offlineLicenseExpireTime: 15,
-    style: { width: '100%', height: 300 },
-  });
-
-  return (
-    <View style={styles.container}>
-      <TpStreamsPlayerView {...playerProps} />
-    </View>
-  );
-};
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-  },
-});
-
-export default App;
-```
-
-Replace `ASSET_ID` and `ACCESS_TOKEN` with the actual assetId and accessToken of the video you wish to play.
-
-## Player Props
-The player component accepts the following props:
-
-| Prop                      | Type    | Required | Default | Description                                            |
-|--------------------------|---------|----------|---------|--------------------------------------------------------|
-| `videoId`                | string  | Yes      | -       | The unique identifier of the video asset.              |
-| `accessToken`            | string  | Yes      | -       | The authentication token required to access the video. |
-| `enableDownload`         | boolean | No       | `true`  | Enables or disables video download.                   |
-| `autoPlay`               | boolean | No       | `true`  | Controls whether the video should start playing automatically. |
-| `startAt`                | number  | No       | `0`     | Start the video from a particular time (in seconds).  |
-| `offlineLicenseExpireTime` | number | No    | `1296000(15 days in seconds)`    | DRM license expiration time in seconds.                  |
-| `style`                  | object  | No       | `{ width: '100%', height: 300 }` | Defines the player’s width and height. |
-
-# Player Methods
-
-To use the `Tpstreams` module, first import `NativeModules` from `react-native` and get the `Tpstreams` instance:
-
-```js
-import { NativeModules } from 'react-native';
-const { Tpstreams } = NativeModules;
-```
-
-The `Tpstreams` module provides several methods to control video playback and manage player states. Below is a detailed explanation of each method:
-
-## Play
-
-```js
-Tpstreams.play();
-```
-
-Starts video playback. Call this method when you want the video to start playing or resume after being paused.
-
-## Pause
-
-```js
-Tpstreams.pause();
-```
-
-Pauses video playback, allowing it to be resumed later from the same position.
-
-## Seek To
-
-```js
-Tpstreams.seekTo(position: number);
-```
-
-Seeks to a specific position in the video (in milliseconds).
-
-**Example Usage:**
-
-```js
-Tpstreams.seekTo(10000); // Jump to the 10-second mark
-```
-
-## Get Current Time
-
-```js
-Tpstreams.getCurrentTime().then(console.log);
-```
-
-Gets the current playback position of the video (in milliseconds). Returns a promise that resolves with the current time.
-
-## Get Duration
-
-```js
-Tpstreams.getDuration().then(console.log);
-```
-
-Retrieves the total duration of the currently loaded video (in milliseconds). Returns a promise that resolves with the total duration.
-
-## Get Buffered Time
-
-```js
-Tpstreams.getBufferedTime().then(console.log);
-```
-
-Gets the amount of video data that has been buffered (in milliseconds). Returns a promise that resolves with the buffered time.
-
-## Get Playback State
-
-```js
-Tpstreams.getPlaybackState().then(console.log);
-```
-
-Gets the current playback state of the player (e.g., `playing`, `paused`, `buffering`). Returns a promise that resolves with the state.
-
-## Get Play When Ready
-
-```js
-Tpstreams.getPlayWhenReady().then(console.log);
-```
-
-Checks if the player is set to start playback automatically. Returns a promise that resolves with a boolean value.
-
-## Set Play When Ready
-
-```js
-Tpstreams.setPlayWhenReady(true); // Enable autoplay
-```
-
-Controls whether the player should start playback automatically when loaded.
-
-## Get Playback Speed
-
-```js
-Tpstreams.getPlaybackSpeed().then(console.log);
-```
-
-Gets the current playback speed of the video. Returns a promise that resolves with the speed value.
-
-## Set Playback Speed
-
-```js
-Tpstreams.setPlaybackSpeed(1.5); // Play at 1.5x speed
-```
-
-Changes the playback speed of the video.
-
-## Release
-
-```js
-Tpstreams.release();
-```
-
-Releases the player resources, stopping playback and hiding the player UI. Once called, the player cannot be used again unless reinitialized.
-
-
-# Player Events
-
-`Tpstreams` provides event listeners to handle various player events. Below are the available events and how to use them:
-
-## Listening to Events
-
-To subscribe to player events, use the `NativeEventEmitter` from `react-native` with `TpstreamsModule`:
+Initialize TPStreams with your organization ID:
 
 ```js
-import { NativeEventEmitter, NativeModules } from 'react-native';
+import { TPStreams } from "react-native-tpstreams";
 
-const { Tpstreams } = NativeModules;
-const eventEmitter = new NativeEventEmitter(Tpstreams);
-
-const subscription = eventEmitter.addListener('onPlaybackStateChanged', (state) => {
-  console.log('Playback State Changed:', state);
-});
-
-// Remember to remove the listener when unmounting
-subscription.remove();
+// Initialize with your organization ID
+TPStreams.initialize('YOUR_ORGANIZATION_ID');
 ```
 
-## Available Events
-
-### onPlaybackStateChanged
-This event notifies us when the player's playback state changes:
-
-| State | Value | Description |
-|--------|-------|------------|
-| `STATE_IDLE` | `1` | The player is idle and not ready to play. |
-| `STATE_BUFFERING` | `2` | The player is buffering (waiting for enough data). |
-| `STATE_READY` | `3` | The player is ready to play. |
-| `STATE_ENDED` | `4` | The playback has finished. |
-
+Then use the player component:
 
 ```js
-eventEmitter.addListener('onPlaybackStateChanged', (state) => {
-  console.log('Playback State:', state);
-});
-```
+import { TPStreamsPlayerView } from "react-native-tpstreams";
 
-### onAccessTokenExpired
-Triggered when the access token expires (requires refresh).
-
-```js
-eventEmitter.addListener('onAccessTokenExpired', async () => {
-  console.log('Access token expired, fetching a new one...');
-  
-  const newToken = await fetchNewAccessToken(); // Fetch the new token from your API
-  Tpstreams.setNewAccessToken(newToken);
-});
+// Use the player component where needed
+<TPStreamsPlayerView 
+  videoId="YOUR_VIDEO_ID"
+  accessToken="YOUR_ACCESS_TOKEN"
+  style={{ width: '100%', height: 300 }}
+/>
 ```
 
-### onMarkerCallback
-Triggered when a marker (timestamp) is reached during playback.
+## Contributing
 
-```js
-eventEmitter.addListener('onMarkerCallback', (marker) => {
-  console.log('Marker reached:', marker);
-});
-```
-
-### onDeviceInfoChanged
-Triggered when the device information changes.
-
-```js
-eventEmitter.addListener('onDeviceInfoChanged', (info) => {
-  console.log('Device info changed:', info);
-});
-```
+See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
 
-### onFullScreenChanged
-Triggered when the fullscreen mode changes.
+## License
 
-```js
-eventEmitter.addListener('onFullScreenChanged', (isFullscreen) => {
-  console.log('Fullscreen mode:', isFullscreen);
-});
-```
-
-### onIsLoadingChanged
-- `true`: The player is currently loading or buffering new data from the network.
-- `false`: The player has sufficient buffered content and can play without interruption.
-
-```js
-eventEmitter.addListener('onIsLoadingChanged', (isLoading) => {
-  console.log('Loading state changed:', isLoading);
-});
-```
+MIT
 
-### onIsPlayingChanged
-Triggered when the player’s playing state changes.
-
-```js
-eventEmitter.addListener('onIsPlayingChanged', (isPlaying) => {
-  console.log('Playing state:', isPlaying);
-});
-```
-
-### onPlayerError
-Triggered when the player encounters an error.
-
-```js
-eventEmitter.addListener('onPlayerError', (error) => {
-  console.log('Player Error:', error);
-});
-```
-
-### onSeekBackIncrementChanged
-Triggered when the seek-back increment value changes.
-
-```js
-eventEmitter.addListener('onSeekBackIncrementChanged', (value) => {
-  console.log('Seek back increment changed:', value);
-});
-```
-
-### onSeekForwardIncrementChanged
-Triggered when the seek-forward increment value changes.
-
-```js
-eventEmitter.addListener('onSeekForwardIncrementChanged', (value) => {
-  console.log('Seek forward increment changed:', value);
-});
-```
-
-### onTimelineChanged
-Triggered when the timeline of the player changes.
-
-```js
-eventEmitter.addListener('onTimelineChanged', (timeline) => {
-  console.log('Timeline changed:', timeline);
-});
-```
-
-### onTracksChanged
-Triggered when the available tracks change (e.g., audio/video/subtitles).
-
-```js
-eventEmitter.addListener('onTracksChanged', (tracks) => {
-  console.log('Tracks changed:', tracks);
-});
-```
-
-# Download Module
-
-The `Download Module` in `Tpstreams` allows users to manage offline video downloads efficiently. This includes observing download progress, pausing, resuming, canceling, and deleting downloads.
-
-## Observing Download Data
-
-To start observing the download data, call the `observeDownloadData` method from `FragmentModule`.
-
-```js
-import { NativeModules, DeviceEventEmitter } from 'react-native';
-
-const { FragmentModule } = NativeModules;
-FragmentModule.observeDownloadData();
-```
-
-Once initialized, the module will emit events whenever the download data changes.
-
-## Listening to Download Events
-
-To listen for download state changes, use `DeviceEventEmitter`:
-
-```js
-const subscription = DeviceEventEmitter.addListener(
-  'onDownloadDataChanged',
-  (event) => {
-    console.log('Download data updated:', event.assets);
-  }
-);
-
-// Remember to remove the listener when unmounting
-subscription.remove();
-```
-
-## Managing Downloads
-
-### Pause Download
-Pauses an active download.
-
-```js
-FragmentModule.pauseDownload(videoId);
-```
-
-### Resume Download
-Resumes a paused download.
-
-```js
-FragmentModule.resumeDownload(videoId);
-```
-
-### Cancel Download
-Cancels an ongoing download.
-
-```js
-FragmentModule.cancelDownload(videoId);
-```
-
-### Delete Download
-Deletes a completed download from storage.
-
-```js
-FragmentModule.deleteDownload(videoId);
-```
-
-## Rendering a Download List
-
-Below is a sample implementation of a download list UI using `FlatList` in React Native:
-
-```js
-import React, { useState, useEffect } from 'react';
-import { SafeAreaView, Text, FlatList, View, Button, DeviceEventEmitter } from 'react-native';
-import { NativeModules } from 'react-native';
-
-const { FragmentModule } = NativeModules;
-
-const DownloadListScreen = () => {
-  const [downloads, setDownloads] = useState([]);
-
-  useEffect(() => {
-    FragmentModule.observeDownloadData();
-    const subscription = DeviceEventEmitter.addListener('onDownloadDataChanged', (event) => {
-      setDownloads(event.assets);
-    });
-    return () => subscription.remove();
-  }, []);
-
-  const renderItem = ({ item }) => (
-    <View>
-      <Text>{item.title} - {item.percentage}%</Text>
-      {item.status === 'DOWNLOADING' && <Button title="Pause" onPress={() => FragmentModule.pauseDownload(item.videoId)} />}
-      {item.status === 'COMPLETE' && <Button title="Delete" onPress={() => FragmentModule.deleteDownload(item.videoId)} />}
-      {item.status === 'PAUSED' && <Button title="Resume" onPress={() => FragmentModule.resumeDownload(item.videoId)} />}
-    </View>
-  );
-
-  return (
-    <SafeAreaView>
-      <FlatList data={downloads} keyExtractor={(item) => item.videoId} renderItem={renderItem} />
-    </SafeAreaView>
-  );
-};
-
-export default DownloadListScreen;
-```
+---
 
-This component observes download events and dynamically updates the list with buttons for user interactions.
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/Tpstreams.podspec

@@ -1,7 +1,6 @@
 require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
-folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
 
 Pod::Spec.new do |s|
   s.name         = "Tpstreams"
@@ -12,31 +11,10 @@ Pod::Spec.new do |s|
   s.authors      = package["author"]
 
   s.platforms    = { :ios => min_ios_version_supported }
-  s.source       = { :git => "https://github.com/testpress/react-native-player-sdk.git", :tag => "#{s.version}" }
+  s.source       = { :git => "https://github.com/testpress/react-native-tpstreams.git", :tag => "#{s.version}" }
 
   s.source_files = "ios/**/*.{h,m,mm,cpp}"
-  s.private_header_files = "ios/generated/**/*.h"
+  s.private_header_files = "ios/**/*.h"
 
-  # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
-  # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
-  if respond_to?(:install_modules_dependencies, true)
-    install_modules_dependencies(s)
-  else
-    s.dependency "React-Core"
-
-    # Don't install the dependencies when we run `pod install` in the old architecture.
-    if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
-      s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
-      s.pod_target_xcconfig    = {
-          "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
-          "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
-          "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
-      }
-      s.dependency "React-Codegen"
-      s.dependency "RCT-Folly"
-      s.dependency "RCTRequired"
-      s.dependency "RCTTypeSafety"
-      s.dependency "ReactCommon/turbomodule/core"
-    end
-  end
+ install_modules_dependencies(s)
 end

package/android/build.gradle

@@ -4,6 +4,7 @@ buildscript {
   }
 
   repositories {
+    mavenLocal()
     google()
     mavenCentral()
   }
@@ -20,53 +21,28 @@ rootProject.allprojects {
         mavenCentral()  // Ensure this line is here
         google()
         maven {
-            url "https://github.com/testpress/maven/raw/main/repo"
+            url "https://github.com/testpress/TPStreamsAndroidPlayerMaven/raw/main/repo"
         }
     }
 }
 
-
-def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
-}
-
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
 
-if (isNewArchitectureEnabled()) {
-  apply plugin: "com.facebook.react"
-}
+apply plugin: "com.facebook.react"
 
 def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Tpstreams_" + name]).toInteger()
 }
 
-def supportsNamespace() {
-  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
-  def major = parsed[0].toInteger()
-  def minor = parsed[1].toInteger()
-
-  // Namespace support was added in 7.3.0
-  return (major == 7 && minor >= 3) || major >= 8
-}
-
 android {
-  if (supportsNamespace()) {
-    namespace "com.tpstreams"
-
-    sourceSets {
-      main {
-        manifest.srcFile "src/main/AndroidManifestNew.xml"
-      }
-    }
-  }
+  namespace "com.tpstreams"
 
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
   }
 
   buildFeatures {
@@ -90,18 +66,16 @@ android {
 
   sourceSets {
     main {
-      if (isNewArchitectureEnabled()) {
-          java.srcDirs += [
-            "generated/java",
-            "generated/jni"
-          ]
-      }
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
     }
   }
 }
 
 repositories {
-  mavenCentral()
+  mavenLocal()
   google()
 }
 
@@ -110,13 +84,11 @@ def kotlin_version = getExtOrDefault("kotlinVersion")
 dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation "com.tpstreams.player:player:3.1.6"
+  implementation "com.tpstreams:tpstreams-player:0.0.1"
 }
 
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "Tpstreams"
-    codegenJavaPackageName = "com.tpstreams"
-  }
+react {
+  jsRootDir = file("../src/")
+  libraryName = "TpstreamsView"
+  codegenJavaPackageName = "com.tpstreams"
 }

package/android/src/main/AndroidManifest.xml

@@ -1,4 +1,2 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.tpstreams">
-          <application android:allowBackup="true" android:icon="@mipmap/appicon" android:roundIcon="@mipmap/appicon_round" android:supportsRtl="true" android:networkSecurityConfig="@xml/network_security_config"></application>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 </manifest>

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

@@ -0,0 +1,18 @@
+package com.tpstreams
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.tpstreams.player.TPStreamsPlayer
+
+class TPStreamsRNModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String {
+        return "TPStreams"
+    }
+
+    @ReactMethod
+    fun initialize(organizationId: String) {
+        TPStreamsPlayer.init(organizationId)
+    }
+} 

package/android/src/main/java/com/tpstreams/{TpstreamsPackage.kt → TPStreamsRNPackage.kt}

@@ -4,13 +4,18 @@ import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
+import java.util.ArrayList
 
-class TpstreamsPackage : ReactPackage {
-  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-      return listOf(TpstreamsModule(reactContext), FragmentModule(reactContext))
+class TPStreamsRNPackage : ReactPackage {
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    val viewManagers: MutableList<ViewManager<*, *>> = ArrayList()
+    viewManagers.add(TPStreamsRNPlayerViewManager())
+    return viewManagers
   }
 
-  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return listOf(TpStreamsPlayerViewManager())
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    val modules: MutableList<NativeModule> = ArrayList()
+    modules.add(TPStreamsRNModule(reactContext))
+    return modules
   }
 }