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.     try {
  75.       await drmEngine.setServerCertificate();
  76.     } catch (e) {
  77.       shaka.log.warning('Error setting server certificate', e);
  78.       await drmEngine.destroy();
  79.       return [];
  80.     }
  82.     /** @type {!Array.<string>} */
  83.     const sessionIds = [];
  84.     await Promise.all(bucket.sessionIds.map(async (sessionId) => {
  85.       // This method is in a .map(), so this starts multiple removes at once,
  86.       // so this removes the sessions in parallel.
  87.       try {
  88.         await drmEngine.removeSession(sessionId);
  89.         sessionIds.push(sessionId);
  90.       } catch (e) {
  91.         shaka.log.warning('Error deleting offline session', e);
  92.       }
  93.     }));
  94.     await drmEngine.destroy();
  95.     return sessionIds;
  96.   }
  99.   /**
  100.    * Collects the given sessions into buckets that can be done at the same time.
  101.    * Since querying with different parameters can give us back different CDMs,
  102.    * we can't just use one CDM instance to delete everything.
  103.    *
  104.    * @param {!Array.<shaka.extern.EmeSessionDB>} sessions
  105.    * @return {!Array.<shaka.offline.SessionDeleter.Bucket_>}
  106.    * @private
  107.    */
  108.   static createBuckets_(sessions) {
  109.     const SessionDeleter = shaka.offline.SessionDeleter;
  111.     /** @type {!Array.<shaka.offline.SessionDeleter.Bucket_>} */
  112.     const ret = [];
  113.     for (const session of sessions) {
  114.       let found = false;
  115.       for (const bucket of ret) {
  116.         if (SessionDeleter.isCompatible_(bucket.info, session)) {
  117.           bucket.sessionIds.push(session.sessionId);
  118.           found = true;
  119.           break;
  120.         }
  121.       }
  122.       if (!found) {
  123.         ret.push({info: session, sessionIds: [session.sessionId]});
  124.       }
  125.     }
  127.     return ret;
  128.   }
  131.   /**
  132.    * Returns whether the given session infos are compatible with each other.
  133.    * @param {shaka.extern.EmeSessionDB} a
  134.    * @param {shaka.extern.EmeSessionDB} b
  135.    * @return {boolean}
  136.    * @private
  137.    */
  138.   static isCompatible_(a, b) {
  139.     const ArrayUtils = shaka.util.ArrayUtils;
  141.     // TODO: Add a way to change the license server in DrmEngine to avoid
  142.     // resetting EME for different license servers.
  143.     const comp = (x, y) =>
  144.       x.robustness == y.robustness && x.contentType == y.contentType;
  145.     return a.keySystem == b.keySystem && a.licenseUri == b.licenseUri &&
  146.         ArrayUtils.hasSameElements(
  147.             a.audioCapabilities, b.audioCapabilities, comp) &&
  148.         ArrayUtils.hasSameElements(
  149.             a.videoCapabilities, b.videoCapabilities, comp);
  150.   }
  151. };
  154. /**
  155.  * @typedef {{
  156.  *   info: shaka.extern.EmeSessionDB,
  157.  *   sessionIds: !Array.<string>
  158.  * }}
  159.  */
  160. shaka.offline.SessionDeleter.Bucket_;