Source: lib/offline/session_deleter.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.offline.SessionDeleter');
  10. goog.require('shaka.log');
  11. goog.require('shaka.media.DrmEngine');
  12. goog.require('shaka.util.ArrayUtils');
  13. goog.requireType('shaka.net.NetworkingEngine');
  16. /**
  17.  * Contains a utility method to delete persistent EME sessions.
  18.  */
  19. shaka.offline.SessionDeleter = class {
  20.   /**
  21.    * Deletes the given sessions.  This never fails and instead logs the error.
  22.    *
  23.    * @param {shaka.extern.DrmConfiguration} config
  24.    * @param {!shaka.net.NetworkingEngine} netEngine
  25.    * @param {!Array.<shaka.extern.EmeSessionDB>} sessions
  26.    * @return {!Promise.<!Array.<string>>} The session IDs that were deleted.
  27.    */
  28.   async delete(config, netEngine, sessions) {
  29.     const SessionDeleter = shaka.offline.SessionDeleter;
  31.     let deleted = [];
  32.     for (const bucket of SessionDeleter.createBuckets_(sessions)) {
  33.       // Run these sequentially to avoid creating multiple CDM instances at one
  34.       // time.  Some embedded platforms may not support multiples.
  35.       const p = this.doDelete_(config, netEngine, bucket);
  36.       const cur = await p;  // eslint-disable-line no-await-in-loop
  37.       deleted = deleted.concat(cur);
  38.     }
  39.     return deleted;
  40.   }
  43.   /**
  44.    * Performs the deletion of the given session IDs.
  45.    *
  46.    * @param {shaka.extern.DrmConfiguration} config
  47.    * @param {!shaka.net.NetworkingEngine} netEngine
  48.    * @param {shaka.offline.SessionDeleter.Bucket_} bucket
  49.    * @return {!Promise.<!Array.<string>>} The sessions that were deleted
  50.    * @private
  51.    */
  52.   async doDelete_(config, netEngine, bucket) {
  53.     /** @type {!shaka.media.DrmEngine} */
  54.     const drmEngine = new shaka.media.DrmEngine({
  55.       netEngine: netEngine,
  56.       onError: () => {},
  57.       onKeyStatus: () => {},
  58.       onExpirationUpdated: () => {},
  59.       onEvent: () => {},
  60.     });
  62.     try {
  63.       drmEngine.configure(config);
  64.       await drmEngine.initForRemoval(
  65.           bucket.info.keySystem, bucket.info.licenseUri,
  66.           bucket.info.serverCertificate,
  67.           bucket.info.audioCapabilities, bucket.info.videoCapabilities);
  68.     } catch (e) {
  69.       shaka.log.warning('Error initializing EME', e);
  70.       await drmEngine.destroy();
  71.       return [];
  72.     }
  74.     /** @type {!Array.<string>} */
  75.     const sessionIds = [];
  76.     await Promise.all(bucket.sessionIds.map(async (sessionId) => {
  77.       // This method is in a .map(), so this starts multiple removes at once,
  78.       // so this removes the sessions in parallel.
  79.       try {
  80.         await drmEngine.removeSession(sessionId);
  81.         sessionIds.push(sessionId);
  82.       } catch (e) {
  83.         shaka.log.warning('Error deleting offline session', e);
  84.       }
  85.     }));
  86.     await drmEngine.destroy();
  87.     return sessionIds;
  88.   }
  91.   /**
  92.    * Collects the given sessions into buckets that can be done at the same time.
  93.    * Since querying with different parameters can give us back different CDMs,
  94.    * we can't just use one CDM instance to delete everything.
  95.    *
  96.    * @param {!Array.<shaka.extern.EmeSessionDB>} sessions
  97.    * @return {!Array.<shaka.offline.SessionDeleter.Bucket_>}
  98.    * @private
  99.    */
  100.   static createBuckets_(sessions) {
  101.     const SessionDeleter = shaka.offline.SessionDeleter;
  103.     /** @type {!Array.<shaka.offline.SessionDeleter.Bucket_>} */
  104.     const ret = [];
  105.     for (const session of sessions) {
  106.       let found = false;
  107.       for (const bucket of ret) {
  108.         if (SessionDeleter.isCompatible_(bucket.info, session)) {
  109.           bucket.sessionIds.push(session.sessionId);
  110.           found = true;
  111.           break;
  112.         }
  113.       }
  114.       if (!found) {
  115.         ret.push({info: session, sessionIds: [session.sessionId]});
  116.       }
  117.     }
  119.     return ret;
  120.   }
  123.   /**
  124.    * Returns whether the given session infos are compatible with each other.
  125.    * @param {shaka.extern.EmeSessionDB} a
  126.    * @param {shaka.extern.EmeSessionDB} b
  127.    * @return {boolean}
  128.    * @private
  129.    */
  130.   static isCompatible_(a, b) {
  131.     const ArrayUtils = shaka.util.ArrayUtils;
  133.     // TODO: Add a way to change the license server in DrmEngine to avoid
  134.     // resetting EME for different license servers.
  135.     const comp = (x, y) =>
  136.       x.robustness == y.robustness && x.contentType == y.contentType;
  137.     return a.keySystem == b.keySystem && a.licenseUri == b.licenseUri &&
  138.         ArrayUtils.hasSameElements(
  139.             a.audioCapabilities, b.audioCapabilities, comp) &&
  140.         ArrayUtils.hasSameElements(
  141.             a.videoCapabilities, b.videoCapabilities, comp);
  142.   }
  143. };
  146. /**
  147.  * @typedef {{
  148.  *   info: shaka.extern.EmeSessionDB,
  149.  *   sessionIds: !Array.<string>
  150.  * }}
  151.  */
  152. shaka.offline.SessionDeleter.Bucket_;