react-native-theoplayer/lib/commonjs/internal/cache/MediaCache.js

A THEOplayer video component for react-native.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.NativeMediaCache = exports.MediaCache = void 0;
var _MediaCacheAPI = require("../../api/cache/MediaCacheAPI");
var _DefaultEventDispatcher = require("../adapter/event/DefaultEventDispatcher");
var _CacheEvent = require("../../api/cache/events/CacheEvent");
var _reactNativeTheoplayer = require("react-native-theoplayer");
var _reactNative = require("react-native");
var _NativeCachingTaskAdapter = require("./NativeCachingTaskAdapter");
var _NativeCachingTaskParametersAdapter = require("./NativeCachingTaskParametersAdapter");
const TAG = 'NativeMediaCache';
const NativeCacheModule = _reactNative.NativeModules.THEORCTCacheModule;
class NativeMediaCache extends _DefaultEventDispatcher.DefaultEventDispatcher {
  _emitter = new _reactNative.NativeEventEmitter(NativeCacheModule);
  _status = _MediaCacheAPI.CacheStatus.uninitialised;
  _tasks = [];
  constructor() {
    super();
    this._emitter.addListener('onCacheStatusChange', this.onCacheStatusChange);
    this._emitter.addListener('onAddCachingTaskEvent', this.onAddCachingTaskEvent);
    this._emitter.addListener('onRemoveCachingTaskEvent', this.onRemoveCachingTaskEvent);
    this._emitter.addListener('onCachingTaskProgressEvent', this.onCachingTaskProgressEvent);
    this._emitter.addListener('onCachingTaskStatusChangeEvent', this.onCachingTaskStatusChangeEvent);
    void this.initialize();
  }
  async createTask(source, parameters) {
    return NativeCacheModule.createTask(source, (0, _NativeCachingTaskParametersAdapter.toNativeCachingTaskParameters)(parameters));
  }
  get status() {
    return this._status;
  }
  get tasks() {
    return this._tasks;
  }
  async initialize() {
    await this.getInitialState();

    // Dispatch status change event here
    if (this._status === _MediaCacheAPI.CacheStatus.initialised) {
      await this.onCacheStatusChange({
        status: this._status
      });
    }
  }
  async getInitialState() {
    const initialState = await NativeCacheModule.getInitialState();
    this._status = initialState.status;
    this._tasks = initialState.tasks.map(task => new _NativeCachingTaskAdapter.NativeCachingTaskAdapter(task));
  }
  onCacheStatusChange = async event => {
    if (this._status === _MediaCacheAPI.CacheStatus.uninitialised) {
      await this.getInitialState();
    }
    this._status = event.status;
    this.dispatchEvent({
      type: _CacheEvent.CacheEventType.statechange,
      date: new Date()
    });
  };
  onAddCachingTaskEvent = event => {
    const task = new _NativeCachingTaskAdapter.NativeCachingTaskAdapter(event.task);
    this._tasks.push(task);
    this.dispatchEvent({
      type: _CacheEvent.CacheEventType.addtask,
      task,
      date: new Date()
    });
  };
  onRemoveCachingTaskEvent = event => {
    const task = this.taskById(event.task.id);
    if (task) {
      this._tasks = this._tasks.filter(task => task.id !== event.task.id);
      this.dispatchEvent({
        type: _CacheEvent.CacheEventType.removetask,
        task,
        date: new Date()
      });
    } else {
      console.warn(TAG, `onRemoveCachingTaskEvent: CachingTask with id ${event.task.id} not found.`);
    }
  };
  onCachingTaskProgressEvent = event => {
    const task = this.taskById(event.id);
    if (task) {
      Object.assign(task, {
        ...event.progress
      });
      task.dispatchEvent({
        type: _reactNativeTheoplayer.CachingTaskEventType.progress,
        date: new Date()
      });
    }
  };
  onCachingTaskStatusChangeEvent = event => {
    const task = this.taskById(event.id);
    if (task) {
      Object.assign(task, {
        ...event
      });
      task.dispatchEvent({
        type: _reactNativeTheoplayer.CachingTaskEventType.statechange,
        date: new Date()
      });
    }
  };
  taskById(id) {
    return this._tasks.find(task => task.id === id);
  }
}

/**
 * The media cache API.
 *
 * @category Caching
 * @public
 */
exports.NativeMediaCache = NativeMediaCache;
const MediaCache = exports.MediaCache = new NativeMediaCache();
//# sourceMappingURL=MediaCache.js.map