react-native-theoplayer 2.16.1 → 3.0.0

package/src/internal/cache/NativeCachingTaskAdapter.ts

@@ -0,0 +1,81 @@
+import { DefaultEventDispatcher } from '../adapter/event/DefaultEventDispatcher';
+import type {
+  CachingTask,
+  CachingTaskEventMap,
+  CachingTaskLicense,
+  CachingTaskParameters,
+  SourceDescription,
+  TimeRange,
+} from 'react-native-theoplayer';
+import type { CacheTaskStatus } from 'react-native-theoplayer';
+import { NativeModules } from 'react-native';
+import type { DRMConfiguration } from 'react-native-theoplayer';
+import { fromNativeCachingTaskParameters, NativeCachingTaskParameters } from "./NativeCachingTaskParametersAdapter";
+
+export interface NativeCachingTask {
+  readonly id: string;
+
+  readonly status: CacheTaskStatus;
+
+  readonly source: SourceDescription;
+
+  readonly parameters: NativeCachingTaskParameters;
+
+  readonly duration: number;
+
+  readonly cached: TimeRange[];
+
+  readonly secondsCached: number;
+
+  readonly percentageCached: number;
+
+  readonly bytes: number;
+
+  readonly bytesCached: number;
+}
+
+export class NativeCachingTaskAdapter extends DefaultEventDispatcher<CachingTaskEventMap> implements CachingTask {
+  readonly bytes: number;
+  readonly bytesCached: number;
+  readonly cached: TimeRange[];
+  readonly duration: number;
+  readonly id: string;
+  readonly license: CachingTaskLicense;
+  readonly parameters: CachingTaskParameters;
+  readonly percentageCached: number;
+  readonly secondsCached: number;
+  readonly source: SourceDescription;
+  readonly status: CacheTaskStatus;
+
+  constructor(task: NativeCachingTask) {
+    super();
+    this.bytes = task.bytes;
+    this.cached = { ...task.cached };
+    this.duration = task.duration;
+    this.id = task.id;
+    this.bytesCached = task.bytesCached;
+    this.license = {
+      renew(drmConfiguration?: DRMConfiguration) {
+        NativeModules.CacheModule.renewLicense(task.id, drmConfiguration);
+      },
+    };
+    this.parameters = fromNativeCachingTaskParameters(task.parameters);
+    this.percentageCached = task.percentageCached;
+    this.secondsCached = task.secondsCached;
+    // TODO!
+    this.source = { ...task.source };
+    this.status = task.status;
+  }
+
+  pause(): void {
+    NativeModules.CacheModule.pauseCachingTask(this.id);
+  }
+
+  remove(): void {
+    NativeModules.CacheModule.removeCachingTask(this.id);
+  }
+
+  start(): void {
+    NativeModules.CacheModule.startCachingTask(this.id);
+  }
+}

package/src/internal/cache/NativeCachingTaskParametersAdapter.ts

@@ -0,0 +1,32 @@
+import type {
+  CachingTaskParameters,
+} from 'react-native-theoplayer';
+import type { CachingPreferredTrackSelection } from "../../api/cache/CachingPreferredTrackSelection";
+
+export interface NativeCachingTaskParameters {
+  readonly amount: number | string;
+  readonly expirationDate: number | undefined;
+  readonly bandwidth: number | undefined;
+  readonly preferredTrackSelection: CachingPreferredTrackSelection | undefined;
+  readonly allowsCellularAccess: boolean | undefined;
+}
+
+export function fromNativeCachingTaskParameters(parameters: NativeCachingTaskParameters): CachingTaskParameters {
+  return {
+    amount: parameters.amount,
+    expirationDate: parameters?.expirationDate? new Date(parameters?.expirationDate) : undefined,
+    bandwidth: parameters.bandwidth,
+    preferredTrackSelection: parameters.preferredTrackSelection,
+    allowsCellularAccess: parameters.allowsCellularAccess
+  }
+}
+
+export function toNativeCachingTaskParameters(parameters: CachingTaskParameters): NativeCachingTaskParameters {
+  return {
+    amount: parameters.amount,
+    expirationDate: parameters?.expirationDate?.getTime(),
+    bandwidth: parameters.bandwidth,
+    preferredTrackSelection: parameters.preferredTrackSelection,
+    allowsCellularAccess: parameters.allowsCellularAccess
+  }
+}

package/src/internal/cache/WebCachingTaskAdapter.ts

@@ -0,0 +1,95 @@
+import type {
+  CachingTask,
+  CachingTaskEventMap,
+  CachingTaskLicense,
+  CachingTaskParameters,
+  SourceDescription,
+  TimeRange,
+} from 'react-native-theoplayer';
+
+import type { CachingTask as WebCachingTask, CachingTaskEventMap as WebCachingTaskEventMap } from 'theoplayer';
+import type { CacheTaskStatus } from 'react-native-theoplayer';
+import type { StringKeyOf } from '../../api/event/EventDispatcher';
+import type { EventListener } from '../../api/event/EventListener';
+
+export class WebCachingTaskAdapter implements CachingTask {
+  constructor(private webCachingTask: WebCachingTask) {}
+
+  get bytes(): number {
+    return this.webCachingTask.bytes;
+  }
+
+  get bytesCached(): number {
+    return this.webCachingTask.bytesCached;
+  }
+
+  get cached(): TimeRange[] {
+    return fromTimeRanges(this.webCachingTask.cached);
+  }
+
+  get duration(): number {
+    return this.webCachingTask.duration;
+  }
+
+  get id(): string {
+    return this.webCachingTask.id;
+  }
+
+  get license(): CachingTaskLicense {
+    return this.webCachingTask.license;
+  }
+
+  get parameters(): CachingTaskParameters {
+    return this.webCachingTask.parameters;
+  }
+
+  get percentageCached(): number {
+    return this.webCachingTask.percentageCached;
+  }
+
+  get secondsCached(): number {
+    return this.webCachingTask.secondsCached;
+  }
+
+  get source(): SourceDescription {
+    return this.webCachingTask.source as SourceDescription;
+  }
+
+  get status(): CacheTaskStatus {
+    return this.webCachingTask.status as CacheTaskStatus;
+  }
+
+  start(): void {
+    this.webCachingTask.start();
+  }
+
+  pause(): void {
+    this.webCachingTask.pause();
+  }
+
+  remove(): void {
+    this.webCachingTask.remove();
+  }
+
+  addEventListener<TType extends StringKeyOf<CachingTaskEventMap>>(type: TType[] | TType, listener: EventListener<CachingTaskEventMap[TType]>) {
+    this.webCachingTask.addEventListener(type, listener as EventListener<WebCachingTaskEventMap[TType]>);
+  }
+
+  removeEventListener<TType extends StringKeyOf<CachingTaskEventMap>>(
+    type: TType[] | TType,
+    listener: EventListener<CachingTaskEventMap[TType]>,
+  ): void {
+    this.webCachingTask.removeEventListener(type, listener as EventListener<WebCachingTaskEventMap[TType]>);
+  }
+}
+
+function fromTimeRanges(timeRanges: TimeRanges): TimeRange[] {
+  const result: TimeRange[] = [];
+  for (let i = 0; i < timeRanges.length; i++) {
+    result.push({
+      start: timeRanges.start(i) * 1e3,
+      end: timeRanges.end(i) * 1e3,
+    });
+  }
+  return result;
+}

package/android/src/main/java/com/theoplayer/track/QualityListFilter.kt

@@ -1,28 +0,0 @@
-package com.theoplayer.track
-
-import com.theoplayer.android.api.player.track.mediatrack.quality.Quality
-import com.theoplayer.android.api.player.track.mediatrack.quality.QualityList
-import com.facebook.react.bridge.ReadableArray
-import java.util.ArrayList
-
-/**
- * QualityListFilter allows filtering a QualityList.
- */
-class QualityListFilter<Q : Quality>(private val qualities: QualityList<Q>) {
-
-  fun filterQualityList(uids: ReadableArray): QualityList<Q> {
-    return QualityListAdapter(filterList(uids))
-  }
-
-  private fun filterList(uids: ReadableArray): MutableList<Q> {
-    val filteredQualities: MutableList<Q> = ArrayList()
-    for (q in 0 until uids.size()) {
-      for (quality in qualities) {
-        if (uids.getInt(q) == quality.uid) {
-          filteredQualities.add(quality)
-        }
-      }
-    }
-    return filteredQualities
-  }
-}