bitmovin-player-react-native 0.9.2 → 0.10.0

package/src/offline/offlineContentManager.ts

@@ -0,0 +1,216 @@
+import {
+  EmitterSubscription,
+  NativeEventEmitter,
+  NativeModule,
+  NativeModules,
+} from 'react-native';
+import NativeInstance from '../nativeInstance';
+import { SourceConfig } from '../source';
+import {
+  BitmovinNativeOfflineEventData,
+  handleBitmovinNativeOfflineEvent,
+  OfflineContentManagerListener,
+} from './offlineContentManagerListener';
+import { OfflineContentConfig } from './offlineContentConfig';
+import { OfflineDownloadRequest } from './offlineDownloadRequest';
+import { OfflineState } from './offlineState';
+import { Drm } from 'bitmovin-player-react-native';
+
+interface NativeOfflineModule extends NativeModule {
+  initWithConfig(
+    nativeId: string,
+    config: { identifier: string; sourceConfig: SourceConfig },
+    drmNativeId: string | undefined
+  ): Promise<void>;
+  getState(nativeId: string): Promise<OfflineState>;
+  getOptions(nativeId: string): Promise<void>;
+  download(nativeId: string, request: OfflineDownloadRequest): Promise<void>;
+  resume(nativeId: string): Promise<void>;
+  suspend(nativeId: string): Promise<void>;
+  cancelDownload(nativeId: string): Promise<void>;
+  usedStorage(nativeId: string): Promise<number>;
+  deleteAll(nativeId: string): Promise<void>;
+  downloadLicense(nativeId: string): Promise<void>;
+  releaseLicense(nativeId: string): Promise<void>;
+  renewOfflineLicense(nativeId: string): Promise<void>;
+  release(nativeId: string): Promise<void>;
+}
+
+const OfflineModule =
+  NativeModules.BitmovinOfflineModule as NativeOfflineModule;
+
+/**
+ * Provides the means to download and store sources locally that can be played back with a Player
+ * without an active network connection. An OfflineContentManager instance can be created via
+ * the constructor and will be idle until initialized.
+ *
+ * @platform Android, iOS
+ */
+export class OfflineContentManager extends NativeInstance<OfflineContentConfig> {
+  isInitialized = false;
+  isDestroyed = false;
+  eventSubscription?: EmitterSubscription = undefined;
+  listeners: Set<OfflineContentManagerListener> =
+    new Set<OfflineContentManagerListener>();
+  drm?: Drm;
+
+  constructor(config: OfflineContentConfig) {
+    super(config);
+  }
+
+  /**
+   * Allocates the native `OfflineManager` instance and its resources natively.
+   * Registers the `DeviceEventEmitter` listener to receive data from the native `OfflineContentManagerListener` callbacks
+   */
+  initialize = async (): Promise<void> => {
+    let initPromise = Promise.resolve();
+    if (!this.isInitialized && this.config) {
+      this.eventSubscription = new NativeEventEmitter(
+        OfflineModule
+      ).addListener(
+        'BitmovinOfflineEvent',
+        (data?: BitmovinNativeOfflineEventData) => {
+          if (this.nativeId !== data?.nativeId) {
+            return;
+          }
+
+          handleBitmovinNativeOfflineEvent(data, this.listeners);
+        }
+      );
+
+      if (this.config.sourceConfig.drmConfig) {
+        this.drm = new Drm(this.config.sourceConfig.drmConfig);
+        this.drm.initialize();
+      }
+
+      initPromise = OfflineModule.initWithConfig(
+        this.nativeId,
+        {
+          identifier: this.config.identifier,
+          sourceConfig: this.config.sourceConfig,
+        },
+        this.drm?.nativeId
+      );
+    }
+
+    this.isInitialized = true;
+    return initPromise;
+  };
+
+  /**
+   * Adds a listener to the receive data from the native `OfflineContentManagerListener` callbacks
+   * Returns a function that removes this listener from the `OfflineContentManager` that registered it.
+   */
+  addListener = (listener: OfflineContentManagerListener): (() => void) => {
+    this.listeners.add(listener);
+
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+
+  /**
+   * Destroys the native `OfflineManager` and releases all of its allocated resources.
+   */
+  destroy = async (): Promise<void> => {
+    if (!this.isDestroyed) {
+      this.isDestroyed = true;
+      this.eventSubscription?.remove?.();
+      this.listeners.clear();
+      this.drm?.destroy();
+
+      return OfflineModule.release(this.nativeId);
+    }
+
+    return Promise.resolve();
+  };
+
+  /**
+   * Gets the current state of the `OfflineContentManager`
+   */
+  state = async (): Promise<OfflineState> => {
+    return OfflineModule.getState(this.nativeId);
+  };
+
+  /**
+   * Loads the current `OfflineContentOptions`.
+   * When the options are loaded the data will be passed to the `OfflineContentManagerListener.onOptionsAvailable`.
+   */
+  getOptions = async (): Promise<void> => {
+    return OfflineModule.getOptions(this.nativeId);
+  };
+
+  /**
+   * Enqueues downloads according to the `OfflineDownloadRequest`.
+   * The promise will reject in the event of null or invalid request parameters.
+   * The promise will reject when calling this method when download has already started or is completed.
+   * The promise will resolve when the download has been queued. The download will is not finished when the promise resolves.
+   */
+  download = async (request: OfflineDownloadRequest): Promise<void> => {
+    return OfflineModule.download(this.nativeId, request);
+  };
+
+  /**
+   * Resumes all suspended actions.
+   */
+  resume = async (): Promise<void> => {
+    return OfflineModule.resume(this.nativeId);
+  };
+
+  /**
+   * Suspends all active actions.
+   */
+  suspend = async (): Promise<void> => {
+    return OfflineModule.suspend(this.nativeId);
+  };
+
+  /**
+   * Cancels and deletes the active download.
+   */
+  cancelDownload = async (): Promise<void> => {
+    return OfflineModule.cancelDownload(this.nativeId);
+  };
+
+  /**
+   * Resolves how many bytes of storage are used by the offline content.
+   */
+  usedStorage = async (): Promise<number> => {
+    return OfflineModule.usedStorage(this.nativeId);
+  };
+
+  /**
+   * Deletes everything related to the related content ID.
+   */
+  deleteAll = async (): Promise<void> => {
+    return OfflineModule.deleteAll(this.nativeId);
+  };
+
+  /**
+   * Downloads the offline license.
+   * When finished successfully, data will be passed to the `OfflineContentManagerListener.onDrmLicenseUpdated`.
+   * Errors are transmitted to the `OfflineContentManagerListener.onError`.
+   */
+  downloadLicense = async (): Promise<void> => {
+    return OfflineModule.downloadLicense(this.nativeId);
+  };
+
+  /**
+   * Releases the currently held offline license.
+   * When finished successfully data will be passed to the `OfflineContentManagerListener.onDrmLicenseUpdated`.
+   * Errors are transmitted to the `OfflineContentManagerListener.onError`.
+   *
+   * @platform Android
+   */
+  releaseLicense = async (): Promise<void> => {
+    return OfflineModule.releaseLicense(this.nativeId);
+  };
+
+  /**
+   * Renews the already downloaded DRM license.
+   * When finished successfully data will be passed to the `OfflineContentManagerListener.onDrmLicenseUpdated`.
+   * Errors are transmitted to the `OfflineContentManagerListener.onError`.
+   */
+  renewOfflineLicense = async (): Promise<void> => {
+    return OfflineModule.renewOfflineLicense(this.nativeId);
+  };
+}

package/src/offline/offlineContentManagerListener.ts

@@ -0,0 +1,187 @@
+import { OfflineContentOptions } from './offlineContentOptions';
+import { OfflineState } from './offlineState';
+
+/**
+ * Enum to hold the `eventType` on the `BitmovinNativeOfflineEventData`
+ * @platform Android, iOS
+ */
+export enum OfflineEventType {
+  onCompleted = 'onCompleted',
+  onError = 'onError',
+  onProgress = 'onProgress',
+  onOptionsAvailable = 'onOptionsAvailable',
+  onDrmLicenseUpdated = 'onDrmLicenseUpdated',
+  onDrmLicenseExpired = 'onDrmLicenseExpired',
+  onSuspended = 'onSuspended',
+  onResumed = 'onResumed',
+  onCanceled = 'onCanceled',
+}
+
+/**
+ * The base interface for all offline events.
+ * @platform Android, iOS
+ */
+export interface OfflineEvent<T extends OfflineEventType> {
+  /**
+   * The native id associated with the `OfflineContentManager` emitting this event
+   */
+  nativeId: string;
+  /**
+   * The supplied id representing the source associated with the `OfflineContentManager` emitting this event.
+   */
+  identifier: string;
+  /**
+   * The `OfflineEventType` that correlates to which native `OfflineContentManagerListener` method was called.
+   */
+  eventType: T;
+  /**
+   * The current offline download state
+   */
+  state: OfflineState;
+}
+
+/**
+ * Emitted when the download process has completed.
+ * @platform Android, iOS
+ */
+export interface OnCompletedEvent
+  extends OfflineEvent<OfflineEventType.onCompleted> {
+  /**
+   * The options that are available to download
+   */
+  options?: OfflineContentOptions;
+}
+
+/**
+ * Emitted when an error has occurred.
+ * @platform Android, iOS
+ */
+export interface OnErrorEvent extends OfflineEvent<OfflineEventType.onError> {
+  /**
+   * The error code of the process error
+   */
+  code?: number;
+  /**
+   * The error message of the process error
+   */
+  message?: string;
+}
+
+/**
+ * Emitted when there is a progress change for the process call.
+ * @platform Android, iOS
+ */
+export interface OnProgressEvent
+  extends OfflineEvent<OfflineEventType.onProgress> {
+  /**
+   * The progress for the current process
+   */
+  progress: number;
+}
+
+/**
+ * Emitted when the `OfflineContentOptions` is available after a `OfflineContentManager.getOptions` call.
+ * @platform Android, iOS
+ */
+export interface OnOptionsAvailableEvent
+  extends OfflineEvent<OfflineEventType.onOptionsAvailable> {
+  /**
+   * The options that are available to download
+   */
+  options?: OfflineContentOptions;
+}
+
+/**
+ * Emitted when the DRM license was updated.
+ * @platform Android, iOS
+ */
+export interface OnDrmLicenseUpdatedEvent
+  extends OfflineEvent<OfflineEventType.onDrmLicenseUpdated> {}
+
+/**
+ * Emitted when the DRM license has expired.
+ * @platform iOS
+ */
+export interface OnDrmLicenseExpiredEvent
+  extends OfflineEvent<OfflineEventType.onDrmLicenseExpired> {}
+
+/**
+ * Emitted when all active actions have been suspended.
+ * @platform Android, iOS
+ */
+export interface OnSuspendedEvent
+  extends OfflineEvent<OfflineEventType.onSuspended> {}
+
+/**
+ * Emitted when all actions have been resumed.
+ * @platform Android, iOS
+ */
+export interface OnResumedEvent
+  extends OfflineEvent<OfflineEventType.onResumed> {}
+
+/**
+ * Emitted when the download of the media content was canceled by the user and all partially downloaded content has been deleted from disk.
+ * @platform Android, iOS
+ */
+export interface OnCanceledEvent
+  extends OfflineEvent<OfflineEventType.onCanceled> {}
+
+/**
+ * The type aggregation for all possible native offline events received from the `DeviceEventEmitter`
+ * @platform Android, iOS
+ */
+export type BitmovinNativeOfflineEventData =
+  | OnCompletedEvent
+  | OnOptionsAvailableEvent
+  | OnProgressEvent
+  | OnErrorEvent
+  | OnDrmLicenseUpdatedEvent
+  | OnDrmLicenseExpiredEvent
+  | OnSuspendedEvent
+  | OnResumedEvent
+  | OnCanceledEvent;
+
+/**
+ * The listener that can be passed to the `OfflineContentManager` to receive callbacks for different events.
+ * @platform Android, iOS
+ */
+export interface OfflineContentManagerListener {
+  onCompleted?: (e: OnCompletedEvent) => void;
+  onError?: (e: OnErrorEvent) => void;
+  onProgress?: (e: OnProgressEvent) => void;
+  onOptionsAvailable?: (e: OnOptionsAvailableEvent) => void;
+  onDrmLicenseUpdated?: (e: OnDrmLicenseUpdatedEvent) => void;
+  onDrmLicenseExpired?: (e: OnDrmLicenseExpiredEvent) => void;
+  onSuspended?: (e: OnSuspendedEvent) => void;
+  onResumed?: (e: OnResumedEvent) => void;
+  onCanceled?: (e: OnCanceledEvent) => void;
+}
+
+export const handleBitmovinNativeOfflineEvent = (
+  data: BitmovinNativeOfflineEventData,
+  listeners: Set<OfflineContentManagerListener>
+) => {
+  listeners.forEach((listener) => {
+    if (!listener) return;
+
+    if (data.eventType === OfflineEventType.onCompleted) {
+      listener.onCompleted?.(data);
+    } else if (data.eventType === OfflineEventType.onError) {
+      listener.onError?.(data);
+    } else if (data.eventType === OfflineEventType.onProgress) {
+      listener.onProgress?.(data);
+    } else if (data.eventType === OfflineEventType.onOptionsAvailable) {
+      listener.onOptionsAvailable?.(data);
+    } else if (data.eventType === OfflineEventType.onDrmLicenseUpdated) {
+      listener.onDrmLicenseUpdated?.(data);
+    } else if (data.eventType === OfflineEventType.onDrmLicenseExpired) {
+      listener.onDrmLicenseExpired?.(data);
+    } else if (data.eventType === OfflineEventType.onSuspended) {
+      listener.onSuspended?.(data);
+    } else if (data.eventType === OfflineEventType.onResumed) {
+      listener.onResumed?.(data);
+    } else if (data.eventType === OfflineEventType.onCanceled) {
+      listener.onCanceled?.(data);
+    }
+  });
+};

package/src/offline/offlineContentOptions.ts

@@ -0,0 +1,29 @@
+/**
+ * Superclass of entries which can be selected to download for offline playback
+ * @platform Android, iOS
+ */
+export interface OfflineContentOptionEntry {
+  /**
+   * The ID of the option.
+   */
+  id: string;
+  /**
+   * The language of the option.
+   */
+  language?: string;
+}
+
+/**
+ * Represents the downloadable options provided via the `onOptionsAvailable` callback on `OfflineContentManagerListener`
+ * @platform Android, iOS
+ */
+export interface OfflineContentOptions {
+  /**
+   * Represents the audio options available for download
+   */
+  audioOptions: OfflineContentOptionEntry[];
+  /**
+   * Represents the text options available for download
+   */
+  textOptions: OfflineContentOptionEntry[];
+}

package/src/offline/offlineDownloadRequest.ts

@@ -0,0 +1,20 @@
+/**
+ * Represents the configuration to start a download.
+ * @platform Android, iOS
+ */
+export interface OfflineDownloadRequest {
+  /**
+   * Minimum video bitrate to download. The nearest higher available bitrate will be selected.
+   */
+  minimumBitrate?: number;
+
+  /**
+   * Audio tracks with IDs to download.
+   */
+  audioOptionIds?: string[];
+
+  /**
+   * Text tracks with IDs to download.
+   */
+  textOptionIds?: string[];
+}

package/src/offline/offlineSourceOptions.ts

@@ -0,0 +1,11 @@
+/**
+ * Object used configure how the native offline managers create and get offline source configurations
+ * @platform Android, iOS
+ */
+export interface OfflineSourceOptions {
+  /**
+   * Whether or not the player should restrict playback only to audio, video and subtitle tracks which are stored offline on the device. This has to be set to true if the device has no network access.
+   * @platform iOS
+   */
+  restrictedToAssetCache?: boolean;
+}

package/src/offline/offlineState.ts

@@ -0,0 +1,22 @@
+/**
+ * Contains the state an OfflineContentManager can have.
+ * @platform Android, iOS
+ */
+export enum OfflineState {
+  /**
+   * The offline content is downloaded and ready for offline playback.
+   */
+  Downloaded = 'Downloaded',
+  /**
+   * The offline content is currently downloading.
+   */
+  Downloading = 'Downloading',
+  /**
+   * The download of the offline content is suspended, and is only partly downloaded yet.
+   */
+  Suspended = 'Suspended',
+  /**
+   * The offline content is not downloaded. However, some data may be still cached.
+   */
+  NotDownloaded = 'NotDownloaded',
+}

package/src/player.ts

@@ -7,6 +7,8 @@ import { AudioTrack } from './audioTrack';
 import { SubtitleTrack } from './subtitleTrack';
 import { StyleConfig } from './styleConfig';
 import { TweaksConfig } from './tweaksConfig';
+import { AdaptationConfig } from './adaptationConfig';
+import { OfflineContentManager, OfflineSourceOptions } from './offline';
 
 const PlayerModule = NativeModules.PlayerModule;
 
@@ -53,6 +55,10 @@ export interface PlayerConfig extends NativeInstanceConfig {
    * Configures analytics functionality.
    */
   analyticsConfig?: AnalyticsConfig;
+  /**
+   * Configures adaptation logic.
+   */
+  adaptationConfig?: AdaptationConfig;
 }
 
 /**
@@ -194,6 +200,20 @@ export class Player extends NativeInstance<PlayerConfig> {
     this.loadSource(new Source(sourceConfig));
   };
 
+  /**
+   * Loads the downloaded content from `OfflineContentManager` into the player.
+   */
+  loadOfflineContent = (
+    offlineContentManager: OfflineContentManager,
+    options?: OfflineSourceOptions
+  ) => {
+    PlayerModule.loadOfflineContent(
+      this.nativeId,
+      offlineContentManager.nativeId,
+      options
+    );
+  };
+
   /**
    * Loads the given `Source` into the player.
    */
@@ -428,4 +448,14 @@ export class Player extends NativeInstance<PlayerConfig> {
   getMaxTimeShift = async (): Promise<number> => {
     return PlayerModule.getMaxTimeShift(this.nativeId);
   };
+
+  /**
+   * Sets the upper bitrate boundary for video qualities. All qualities with a bitrate
+   * that is higher than this threshold will not be eligible for automatic quality selection.
+   *
+   * Can be set to `undefined` for no limitation.
+   */
+  setMaxSelectableBitrate = (bitrate: number | null) => {
+    PlayerModule.setMaxSelectableBitrate(this.nativeId, bitrate || -1);
+  };
 }

package/src/source.ts

@@ -45,6 +45,40 @@ export enum LoadingState {
   LOADED = 2,
 }
 
+/**
+ * Types of SourceOptions.
+ */
+export interface SourceOptions {
+  /**
+   * The position where the stream should be started.
+   * Number can be positive or negative depending on the used `TimelineReferencePoint`.
+   * Invalid numbers will be corrected according to the stream boundaries.
+   * For VOD this is applied at the time the stream is loaded, for LIVE when playback starts.
+   */
+  startOffset?: number;
+  /**
+   * Sets the Timeline reference point to calculate the startOffset from.
+   * Default for live: `TimelineReferencePoint.END`.
+   * Default for VOD: `TimelineReferencePoint.START`.
+   */
+  startOffsetTimelineReference?: TimelineReferencePoint;
+}
+
+/**
+ Timeline reference point to calculate SourceOptions.startOffset from.
+ Default for live: TimelineReferencePoint.EBD Default for VOD: TimelineReferencePoint.START.
+ */
+export enum TimelineReferencePoint {
+  /**
+   * Relative offset will be calculated from the beginning of the stream or DVR window.
+   */
+  START = 'start',
+  /**
+   * Relative offset will be calculated from the end of the stream or the live edge in case of a live stream with DVR window.
+   */
+  END = 'end',
+}
+
 /**
  * Represents a source configuration that be loaded into a player instance.
  */
@@ -86,6 +120,10 @@ export interface SourceConfig extends NativeInstanceConfig {
    * The optional custom metadata. Also sent to the cast receiver when loading the Source.
    */
   metadata?: Record<string, string>;
+  /**
+   * The `SourceOptions` for this configuration.
+   */
+  options?: SourceOptions;
 }
 
 /**