Home Reference Source

src/loader/key-loader.ts

  1. /*
  2. * Decrypt key Loader
  3. */
  4. import { Events } from '../events';
  5. import { ErrorTypes, ErrorDetails } from '../errors';
  6. import { logger } from '../utils/logger';
  7. import type Hls from '../hls';
  8. import { Fragment } from './fragment';
  9. import {
  10. LoaderStats,
  11. LoaderResponse,
  12. LoaderContext,
  13. LoaderConfiguration,
  14. LoaderCallbacks,
  15. Loader,
  16. FragmentLoaderContext,
  17. } from '../types/loader';
  18. import type { ComponentAPI } from '../types/component-api';
  19. import type { KeyLoadingData } from '../types/events';
  20.  
  21. interface KeyLoaderContext extends LoaderContext {
  22. frag: Fragment;
  23. }
  24.  
  25. export default class KeyLoader implements ComponentAPI {
  26. private hls: Hls;
  27. public loaders = {};
  28. public decryptkey: Uint8Array | null = null;
  29. public decrypturl: string | null = null;
  30.  
  31. constructor(hls: Hls) {
  32. this.hls = hls;
  33.  
  34. this._registerListeners();
  35. }
  36.  
  37. private _registerListeners() {
  38. this.hls.on(Events.KEY_LOADING, this.onKeyLoading, this);
  39. }
  40.  
  41. private _unregisterListeners() {
  42. this.hls.off(Events.KEY_LOADING, this.onKeyLoading);
  43. }
  44.  
  45. destroy(): void {
  46. this._unregisterListeners();
  47. for (const loaderName in this.loaders) {
  48. const loader = this.loaders[loaderName];
  49. if (loader) {
  50. loader.destroy();
  51. }
  52. }
  53. this.loaders = {};
  54. }
  55.  
  56. onKeyLoading(event: Events.KEY_LOADING, data: KeyLoadingData) {
  57. const { frag } = data;
  58. const type = frag.type;
  59. const loader = this.loaders[type];
  60. if (!frag.decryptdata) {
  61. logger.warn('Missing decryption data on fragment in onKeyLoading');
  62. return;
  63. }
  64.  
  65. // Load the key if the uri is different from previous one, or if the decrypt key has not yet been retrieved
  66. const uri = frag.decryptdata.uri;
  67. if (uri !== this.decrypturl || this.decryptkey === null) {
  68. const config = this.hls.config;
  69. if (loader) {
  70. logger.warn(`abort previous key loader for type:${type}`);
  71. loader.abort();
  72. }
  73. if (!uri) {
  74. logger.warn('key uri is falsy');
  75. return;
  76. }
  77. const Loader = config.loader;
  78. const fragLoader = (frag.loader = this.loaders[type] = new Loader(
  79. config
  80. ) as Loader<FragmentLoaderContext>);
  81. this.decrypturl = uri;
  82. this.decryptkey = null;
  83.  
  84. const loaderContext: KeyLoaderContext = {
  85. url: uri,
  86. frag: frag,
  87. responseType: 'arraybuffer',
  88. };
  89.  
  90. // maxRetry is 0 so that instead of retrying the same key on the same variant multiple times,
  91. // key-loader will trigger an error and rely on stream-controller to handle retry logic.
  92. // this will also align retry logic with fragment-loader
  93. const loaderConfig: LoaderConfiguration = {
  94. timeout: config.fragLoadingTimeOut,
  95. maxRetry: 0,
  96. retryDelay: config.fragLoadingRetryDelay,
  97. maxRetryDelay: config.fragLoadingMaxRetryTimeout,
  98. highWaterMark: 0,
  99. };
  100.  
  101. const loaderCallbacks: LoaderCallbacks<KeyLoaderContext> = {
  102. onSuccess: this.loadsuccess.bind(this),
  103. onError: this.loaderror.bind(this),
  104. onTimeout: this.loadtimeout.bind(this),
  105. };
  106.  
  107. fragLoader.load(loaderContext, loaderConfig, loaderCallbacks);
  108. } else if (this.decryptkey) {
  109. // Return the key if it's already been loaded
  110. frag.decryptdata.key = this.decryptkey;
  111. this.hls.trigger(Events.KEY_LOADED, { frag: frag });
  112. }
  113. }
  114.  
  115. loadsuccess(
  116. response: LoaderResponse,
  117. stats: LoaderStats,
  118. context: KeyLoaderContext
  119. ) {
  120. const frag = context.frag;
  121. if (!frag.decryptdata) {
  122. logger.error('after key load, decryptdata unset');
  123. return;
  124. }
  125. this.decryptkey = frag.decryptdata.key = new Uint8Array(
  126. response.data as ArrayBuffer
  127. );
  128.  
  129. // detach fragment loader on load success
  130. frag.loader = null;
  131. delete this.loaders[frag.type];
  132. this.hls.trigger(Events.KEY_LOADED, { frag: frag });
  133. }
  134.  
  135. loaderror(response: LoaderResponse, context: KeyLoaderContext) {
  136. const frag = context.frag;
  137. const loader = frag.loader;
  138. if (loader) {
  139. loader.abort();
  140. }
  141.  
  142. delete this.loaders[frag.type];
  143. this.hls.trigger(Events.ERROR, {
  144. type: ErrorTypes.NETWORK_ERROR,
  145. details: ErrorDetails.KEY_LOAD_ERROR,
  146. fatal: false,
  147. frag,
  148. response,
  149. });
  150. }
  151.  
  152. loadtimeout(stats: LoaderStats, context: KeyLoaderContext) {
  153. const frag = context.frag;
  154. const loader = frag.loader;
  155. if (loader) {
  156. loader.abort();
  157. }
  158.  
  159. delete this.loaders[frag.type];
  160. this.hls.trigger(Events.ERROR, {
  161. type: ErrorTypes.NETWORK_ERROR,
  162. details: ErrorDetails.KEY_LOAD_TIMEOUT,
  163. fatal: false,
  164. frag,
  165. });
  166. }
  167. }