rx-player 4.4.1 → 4.5.0-dev.2026012301

package/src/README.md

@@ -22,141 +22,149 @@ There are also several other files and directories those two may depend on.
 To better understand the player's architecture, you can find below a simplified schema for
 it:
 
-``````
-               +---------------------------------------------+
-               |                                             |
-               |               Application/UI                |
-               |                                             |
-               +---------------------------------------------+
-                         |
-                         | call the RxPlayer API
-                         |
--------------------------|- RxPlayer Main Thread ---------------------------
-                         |
-     Front-facing API    v
-     +---------------------------------------+    +--------------------+
-     |               Public API              |uses|     TracksStore    |
-     |          (./main_thread/api)          |--->|(./main_thread/track|
-     +---------------------------------------+    |s_store)            |
-                 |                                +--------------------+
-                 |                                 Facilitate track switching
- Initialize      | creates                         for the API
- playback and    |
- create/connect  |        Negotiate content
- modules         v        decryption
- +--------------------+   +-----------------------+
- |                    |   |   Content Decryptor   |       Renders text
- |      Content       |-->|(./main_thread/decrypt)|       tracks to the
- |    Initializer     |   +-----------------------+       DOM
- |                    |                             +------------------+
- |(./main_thread/init)|            creates          |  Text Displayer  |
- |                    | --------------------------->|(./main_thread/te |
- +--------------------+                             |xt_displayer)     |
-   |  ^                                             +------------------+
-   |  | Message exchanges                                          ^
-   |  |                                                            |
----|--|----------- RxPlayer Core (May run in a WebWorker) ---------|---
-   |  |                                                            |
-   |  |  (*Only if running in a WebWorker)                         +----+
-   |  |  Exchange messages with the main                                |
-   V  |  thread and process them.                                       |
-  +---------------------------+         +----------------------------+  |
-  |                           | creates |                            |  |
-  |        Worker Main*       |-------->|       Manifest Fetcher     |  |
-  |   (./core/main/worker)    |         | (./core/fetchers/manifest) |  |
-  |                           |         |                            |  |
-  +---------------------------+         +----------------------------+  |
-     | Creates             |            Load and     |                  |
-     V                     |            refresh the  | Ask to load      |
-   +-------------------+   |            Manifest     | and parse the    |
-   |                   |   | creates                 | Manifest         |
-   | CMCD data builder |   |                         v                  |
-   |  (./core/cmcd)    |   |        +--------------------+              |   ` Internet
-   |                   |   |        |                    |   request    |   `    ,,,,,
-   +-------------------+   |        |      transport     |--------------+---`-->( CDN )
-   Perform data collection |        |    (./transport)   |              |   `    `````
-   for the "Common Media   |        |                    |<---+         |   `
-   Client Data" (CMCD)     |        +--------------------+     \        |
-   scheme.                 |        Abstract the streaming      \       |
-                           |        protocol (e.g. DASH)         \      |
-                           |                                      \     |
-Stream (./core/stream)     |                                       \    |
-+--------------------------|-------------------------------+        \   |
-|                          v                               |         \  +
-| Create the right        +----------------------------+   |    Ask to\  \
-| PeriodStreams depending |      StreamOrchestrator    |   |    load   \  \
-| on the current position,|(./core/stream/orchestrator)|   |    and     \  \
-| and settings            +----------------------------+   |    parse    \  \
-|                          |            |            |     |    segments  \  \
-|                          | creates    |            |     |               \  \
-|                          |            |            |     |                \  +
-|                 (audio)  v    (video) v     (text) v     |                 + |
-| Create the right +--------+   +--------+    +--------+ uses+------------+  | |
-| AdaptationStream |        |   |        |    |        |---->|SegmentSinks|  | |
-| depending on the | Period |-+ | Period |-+  | Period |-+ | |    Store   |  | |
-| wanted track     | Stream | | | Stream | |  | Stream | | | |(./core/segm|  | |
-| (One per Period  |        | | |        | |  |        | | | |ent_sinks)  |  | |
-| and one per type +--------+ | +--------+ |  +--------+ | | +------------+  | |
-| of media)         |         (./core/stream/period)     | | Create one      | |
-|                   +---------+  +---------+   +---------+ | "sink" per      | |
-|                          |            |             |    | type of media   | |
-|                          | creates    |             |    |                 | |
-|                          |            |             |    |                 | |
-|                          |            |             |    |                 | |
-|                  (audio) v    (video) v     (text)  v  uses+------------+  | |
-|                  +--------+   +--------+    +--------+ --|>|    ARS*    |  | |
-| (Adaptation-     |        |   |        |    |        |   | |(./core/adap|  | |
-| Stream)          |Adapt...|-+ |Adapt...|-+  |Adapt...|-+ | |tive)       |  | |
-| Create the right | Stream | | | Stream | |  | Stream | | | +------------+  | |
-| Representation-  |        | | |        | |  |        | | | *Adaptive       | |
-| Stream depending +--------+ | +--------+ |  +--------+ | | Representation  | |
-| on the current   |        (./core/stream/adaptation)   | | Selector:       | |
-| network,         +---------+  +---------+   +----------+ | Find the best   | |
-| settings...              |            |            |     | Representation  | |
-|                          | creates    |            |     | to play         | |
-|                          |            |            |     |                 | |
-|                          |            |            |     |                 | |
-|                  (audio) v    (video) v     (text) v   uses                | |
-|                  +--------+   +--------+    +--------+ --->+-------------+ | |
-| (Representation- |        |   |        |    |        |   | |   Segment   | | |
-| Stream).         |Repre...|-+ |Repre...|-+  |Repre...|-+ | |    Queue    |-+ |
-| Download and push| Stream | | | Stream | |  | Stream | | | |(./core/fetc |   |
-| segments based on|        | | |        | |  |        | | | |hers/segment)|   |
-| the current      +--------+ | +--------+ |  +--------+ | | +-------------+   |
-| position and      |     (./core/stream/representation)   | Load media        |
-| buffer state      +---------+  +---------+   +---------+ | segments          |
-|                         |               |              | |                   |
-+-------------------------|---------------|--------------|-+                   |
-                          |               |              |                     |
-                          | push media    |              |        add subtitle |
-                          | data          |              |                     |
-                          |               |              |                     |
-                +---------|---------------|--------------|-------+             |
-                |  (audio)v        (video)v        (text)v       |             |
-                |  +------------+  +------------+  +-----------+ |             |
- Media sinks on |  | Audio/Video|  | Audio/Video|  |   Text    | |             |
- which media    |  |   Segment  |  |   Segment  |  |  Segment  | |             |
- data to decode |  |    Sink    |  |    Sink    |  |   Sink    | |             |
- is pushed.     |  +------------+  +------------+  +-----------+ |             |
- Also maintain  |        |               |               |       |             |
- an inventory   |  SegmentSink implementations           |       |             |
- and history of |  (./core/segment_sinks/implementations)|       |             |
- pushed media   +--------|---------------|---------------|-------+             |
-                         |               |               |                     |
-                         | push media    |               |                     |
-                         | data          |               |                     |
-                         |               |               |                     |
-                  (audio)V        (video)V         (text)V                     |
-                    +-----------------------+  +-------------------------+     |
-  Actually pushes   |      MediaSource      |  |      TextDisplayer      |     |
-  audio and video   |       Interface       |  |      Message sender     |-----+
-  data to the right |        (./mse)        |  |      (./core/main)      |
-  low-level buffers +-----------------------+  +-------------------------+
-                                               Small interface
-                                               facilitating communication
-                                               with current TextDisplayer
-                                               implementation
-``````
+```
+               ┌─────────────────────────────────────────────┐
+               │                                             │
+               │               Application/UI                │
+               │                                             │
+               └─────────────────────────────────────────────┘
+                         │
+                         │ call the RxPlayer API
+                         │
+─────────────────────────┼─ RxPlayer Main Thread ───────────────────────────
+                         │
+     Front-facing API    ▼
+     ┌───────────────────────────────────────┐      ┌──────────────────────┐
+     │               Public API              │ uses │      TracksStore     │
+     │          (./main_thread/api)          │─────>│(./main_thread/tracks_│
+     └───────────────────────────────────────┘      │store)                │
+                 │                                  └──────────────────────┘
+                 │                                  Facilitate track switching
+ Initialize      │ creates                          for the API
+ playback and    │
+ create/connect  │        Negotiate content
+ modules         ▼        decryption
+ ┌────────────────────┐   ┌───────────────────────┐
+ │                    │   │   Content Decryptor   │       Renders text
+ │      Content       │──>│(./main_thread/decrypt)│       tracks to the
+ │    Initializer     │   └───────────────────────┘       DOM
+ │                    │                             ┌──────────────────┐
+ │(./main_thread/init)│            creates          │  Text Displayer  │
+ │                    │ ───────────────────────────>│(./main_thread/te │
+ └────────────────────┘                             │xt_displayer)     │
+           │  ▲                                     └──────────────────┘
+           ▼  │                                                       ▲
+ ┌────────────────────────────────┐                                   │
+ │          CoreInterface         │ Link `main_thread`                │
+ │ (./main_thread/core_interface) │ to `core` logic                   │
+ └────────────────────────────────┘                                   │
+   │  ▲                                                               │
+   │  │                                                               │
+   │  │                                                               │
+   │  │ Message exchanges                                             │
+   │  │                                                               │
+   │  │                                                               │
+───┼──┼─────────── RxPlayer Core (May run in a WebWorker) ────────────────
+   │  │                                                               │
+   │  │                                                               │
+   │  │                                                               │
+   │  │    Exchange messages with the main                            │
+   ▼  │    thread and process them.                                   │
+  ┌───────────────────────┐             ┌──────────────────────────┐  │
+  │      Core Entry       │────────────>│     Manifest Fetcher     │  │
+  │    (./core/entry)     │   creates   │(./core/fetchers/manifest)│  │
+  └───────────────────────┘             └──────────────────────────┘  │
+     │ Creates           │              Load and     │                │
+     ▼                   │              refresh the  │ Ask to load    │
+ ┌───────────────────┐   │              Manifest     │ and parse the  │
+ │                   │   │ creates                   │ Manifest       │
+ │ CMCD data builder │   │                           ▼                │ Internet
+ │  (./core/cmcd)    │   │        ┌────────────────────┐              │ `
+ │                   │   │        │                    │   request    │ `  ╭───╮
+ └───────────────────┘   │        │      transport     │──────────────┼─`~>│CDN│
+ Perform data collection │        │    (./transport)   │              │ `  ╰───╯
+ for the "Common Media   │        │                    │<────────┐    │ `
+ Client Data" (CMCD)     │        └────────────────────┘         │    │
+ scheme.                 │        Abstract the streaming         │    │
+                         │        protocol (e.g. DASH)           │    │
+                         │                                       │    │
+Stream (./core/stream)   │                                       │    └──────┐
+┌────────────────────────┼────────────────────────────────┐      │           │
+│                        ▼                                │      └─────────┐ │
+│ Create PeriodStreams  ┌────────────────────────────┐    │       Ask to   │ │
+│ based on the position │      StreamOrchestrator    │    │       load     │ │
+│ and settings          │(./core/stream/orchestrator)│    │       and      │ │
+│                       └────────────────────────────┘    │       parse    │ │
+│                          │            │           │     │       segments │ │
+│                          │ creates    │           │     │                │ │
+│                          │            │           │     │                │ │
+│                 (audio)  ▼    (video) ▼    (text) ▼     │                │ │
+│ Create the right ┌────────┐   ┌────────┐   ┌────────┐ uses┌────────────┐ │ │
+│ AdaptationStream │        │   │        │   │        │────>│SegmentSinks│ │ │
+│ depending on the │ Period │─┐ │ Period │─┐ │ Period │─┐ │ │    Store   │ │ │
+│ wanted track     │ Stream │ │ │ Stream │ │ │ Stream │ │ │ │(./core/segm│ │ │
+│ (One per Period  │        │ │ │        │ │ │        │ │ │ │ent_sinks)  │ │ │
+│ and one per type └────────┘ │ └────────┘ │ └────────┘ │ │ └────────────┘ │ │
+│ of media)         │         (./core/stream/period)    │ │ Create one     │ │
+│                   └─────────┘  └─────────┘  └─────────┘ │ "sink" per     │ │
+│                          │            │            │    │ type of media  │ │
+│                          │ creates    │            │    │                │ │
+│                          │            │            │    │                │ │
+│                          │            │            │    │                │ │
+│                  (audio) ▼    (video) ▼    (text)  ▼  uses┌────────────┐ │ │
+│                  ┌────────┐   ┌────────┐   ┌────────┐ ──> │    ARS*    │ │ │
+│ (Adaptation-     │        │   │        │   │        │   │ │(./core/adap│ │ │
+│ Stream)          │Adapt...│─┐ │Adapt...│─┐ │Adapt...│─┐ │ │tive)       │ │ │
+│ Create the right │ Stream │ │ │ Stream │ │ │ Stream │ │ │ └────────────┘ │ │
+│ Representation-  │        │ │ │        │ │ │        │ │ │ *Adaptive      │ │
+│ Stream depending └────────┘ │ └────────┘ │ └────────┘ │ │ Representation │ │
+│ on the current    │        (./core/stream/adaptation) │ │ Selector:      │ │
+│ network,          └─────────┘  └─────────┘  └─────────┘ │ Find the best  │ │
+│ settings...              │            │           │     │ Representation │ │
+│                          │ creates    │           │     │ to play        │ │
+│                          │            │           │     │                │ │
+│                          │            │           │     │                │ │
+│                  (audio) ▼    (video) ▼    (text) ▼   uses               │ │
+│                  ┌────────┐   ┌────────┐   ┌────────┐ ───>┌─────────────┐│ │
+│ (Representation- │        │   │        │   │        │   │ │   Segment   ││ │
+│ Stream).         │Repre...│─┐ │Repre...│─┐ │Repre...│─┐ │ │    Queue    │┘ │
+│ Download and push│ Stream │ │ │ Stream │ │ │ Stream │ │ │ │(./core/fetc │  │
+│ segments based on│        │ │ │        │ │ │        │ │ │ │hers/segment)│  │
+│ the current      └────────┘ │ └────────┘ │ └────────┘ │ │ └─────────────┘  │
+│ position and      │    (./core/stream/representation) │ │ Load media       │
+│ buffer state      └─────────┘  └─────────┘  └─────────┘ │ segments         │
+│                         │               │             │ │                  │
+└─────────────────────────┼───────────────┼─────────────┼─┘                  │
+                          │               │             │                    │
+                          │ push media    │             │       add subtitle │
+                          │ data          │             │                    │
+                          │               │             │                    │
+                ┌─────────┼───────────────┼─────────────┼───────┐            │
+                │  (audio)▼        (video)▼       (text)▼       │            │
+                │  ┌────────────┐  ┌────────────┐ ┌───────────┐ │            │
+ Media sinks on │  │ Audio/Video│  │ Audio/Video│ │   Text    │ │            │
+ which media    │  │   Segment  │  │   Segment  │ │  Segment  │ │            │
+ data to decode │  │    Sink    │  │    Sink    │ │   Sink    │ │            │
+ is pushed.     │  └────────────┘  └────────────┘ └───────────┘ │            │
+ Also maintain  │        │               │              │       │            │
+ an inventory   │  SegmentSink implementations          │       │            │
+ and history of │ (./core/segment_sinks/implementations)│       │            │
+ pushed media   └───────┼───────────────┼───────────────┼───────┘            │
+                        │               │               │                    │
+                        │ push media    │               │                    │
+                        │ data          │               │                    │
+                        │               │               │                    │
+                 (audio)▼        (video)▼         (text)▼                    │
+                    ┌───────────────────────┐ ┌─────────────────────────┐    │
+  Actually pushes   │      MediaSource      │ │      TextDisplayer      │    │
+  audio and video   │       Interface       │ │      Message sender     │────┘
+  data to the right │        (./mse)        │ │      (./core/enry)      │
+  low-level buffers └───────────────────────┘ └─────────────────────────┘
+                                              Small interface
+                                              facilitating communication
+                                              with current TextDisplayer
+                                              implementation
+```
 
 For the subdirectories and files in this directory not represented in that schema:
 
@@ -207,161 +215,43 @@ For the subdirectories and files in this directory not represented in that schem
   RxPlayer which will run in the WebWorker (and which will have to be loaded separately by
   the application).
 
-## Multithread, Monothread and Directfile code paths
-
-There are actually three different main "code paths" that may be run, depending on the
-current content played.
-
-The previous schema mostly illustrated the most complex code path of the three (the
-"multithread mode"). Yet, to be more exact we need to separate those three cases:
-
-1. For "directfile" contents (contents directly decodable by the browser, e.g. mp4 files
-   or HLS playlists on Safari), the code path is the simplest and follows something like
-   this:
-
-   ```
-                  +---------------------------------------------+
-                  |               Application/UI                |
-                  +---------------------------------------------+
-                            |
-                            | call RxPlayer API
-                            |
-   -------------------------|--- RxPlayer Main Thread ----------------------------
-                            |
-        Front-facing API    v
-        +---------------------------------------+      +-------------------------+
-        |               Public API              | uses | MediaElementTracksStore |
-        |          (./main_thread/api)          |----->|(./main_thread/tracks_sto|
-        +---------------------------------------+      |re)                      |
-                            |                          +-------------------------+
-        Manage playback of  | creates                  Handle track switching
-        a "directfile"      |                          using directly the media
-        content             V                          element's API (`audioTracks`,
-        +---------------------------------------+      `textTracks` etc.)
-        |       DirectfileContentInitializer    |
-        |          (./main_thread/init)         |
-        +---------------------------------------+
-                            |
-                            V
-                           ... Some other RxPlayer modules
-                               (All running in main thread)
-   ```
-
-   As you can see, everything runs in main thread, a specialized module called the
-   `DirectfileContentInitializer` is called by the API to start-up such contents and a
-   specialized `MediaElementTracksStore` is handling tracks specifically for directfile
-   contents (as they are handled differently than for other code paths, here trough API
-   exposed by the browser).
-
-2. A second code path, we may call the "monothreaded code path" apply for non-directfile
-   contents (so, contents which rely on the MSE API instead) loaded in monothreaded mode,
-   which is the default.
-
-   It is much closer to the schema of the previous chapter:
-
-   ```
-                  +---------------------------------------------+
-                  |               Application/UI                |
-                  +---------------------------------------------+
-                            |
-                            | call RxPlayer API
-                            |
-   -------------------------|- RxPlayer Main Thread ---------------------------
-                            |
-        Front-facing API    v
-        +---------------------------------------+    +--------------------+
-        |               Public API              |uses|     TracksStore    |
-        |          (./main_thread/api)          |--->|(./main_thread/track|
-        +---------------------------------------+    |s_store)            |
-                            |                        +--------------------+
-                            |                        Facilitate track switching
-        Manage playback of  | creates                for the API
-        contents relying    |
-        on a MediaSource,   |
-        all in main thread  v
-        +---------------------------------------+
-        |      MediaSourceContentInitializer    | ----> ... Some other RxPlayer
-        |          (./main_thread/init)         |           modules not in ./core
-        +---------------------------------------+
-                                |
-        Actually load and parse |
-        the right manifest and  | creates
-        media segments          |
-        (here in main thread)   V
-        +--------------------------------------+
-        |              Core modules            |
-        |                (./core)              |
-        +--------------------------------------+
-   ```
-
-   As you can see, the part of `./main_thread/init` run by the API is this time different
-   (`MediaSourceContentInitializer`) and the track handling also goes to a differently
-   named `TracksStore` when compared to directfile contents.
-
-   I also summarized all core modules into a single block, you can refer to the previous
-   chapter to have some examples of what they are (you can look at modules in the `./core`
-   directory in that schema - or at the `./core` directory itself).
-
-3. A third code path, the "multithreaded code path" apply for non-directfile contents (so,
-   contents which rely on MSE API instead) loaded in "multithread mode" (which has to be
-   explicitely enabled by the application).
-
-   Here you get all the complexity of the previous chapter, with two threads running. To
-   repeat the schema than the one used for the other code paths here, you would have
-   something like:
-
-   ```
-                  +---------------------------------------------+
-                  |               Application/UI                |
-                  +---------------------------------------------+
-                            |
-                            | call RxPlayer API
-                            |
-   -------------------------|----- RxPlayer Main Thread ---------------------------
-                            |
-        Front-facing API    v
-        +---------------------------------------+    +--------------------+
-        |               Public API              |uses|     TracksStore    |
-        |          (./main_thread/api)          |--->|(./main_thread/track|
-        +---------------------------------------+    |s_store)            |
-                            |                        +--------------------+
-                            |                        Facilitate track switching
-        Manage playback of  | creates                for the API
-        contents relying    |
-        on a MediaSource,   |
-        in multiple threads v
-        +---------------------------------------+
-        |      MultiThreadContentInitializer    | ----> ... Some other RxPlayer
-        |          (./main_thread/init)         |           modules not in ./core
-        +---------------------------------------+
-                                |  ^
-                                |  | postMessage exchanges
-                                |  |
-        ------------------------|--|- RxPlayer WebWorker --------------------------
-                                |  |
-        Actually load and parse |  |
-        the right manifest and  |  |
-        media segments          |  |
-        (here in a Worker)      V  |
-        +--+--------------------------------+--+
-        |  |            Worker Main         |  |
-        |  |        (./core/main/worker)    |  |
-        |  +--------------------------------+  |
-        |              Core modules            |
-        |                (./core)              |
-        +--------------------------------------+
-   ```
-
-   This time, the part of `./main_thread/init` run by the API is the
-   `MultiThreadContentInitializer` and the track handling also goes through the
-   `TracksStore`, like for the monothreaded code path.
-
-   The main difference however is that now all core modules are running completely in a
-   WebWorker, meaning in another thread. It is the role of the
-   `MultiThreadContentInitializer` to send message to it and to process most of the
-   messages the WebWorker sends back.
-
-   Because this time, the core also has to reception and send backs messages from and to
-   the main thread, there's a supplementary core module involved than on the "monothreaded
-   code path", the "Worker Main". It then however relies on the exact same other core
-   modules than for the "monothreaded code path".
+## Directfile mode
+
+The RxPlayer can also play content already natively decodable by the browser, e.g. mp4
+files or HLS playlists on Safari.
+
+When playing such content, the code path is slightly different and simpler:
+
+```
+               ┌─────────────────────────────────────────────┐
+               │               Application/UI                │
+               └─────────────────────────────────────────────┘
+                         │
+                         │ call RxPlayer API
+                         │
+─────────────────────────│─── RxPlayer Main Thread ────────────────────────────
+                         │
+     Front-facing API    ▼
+     ┌───────────────────────────────────────┐      ┌─────────────────────────┐
+     │               Public API              │ uses │ MediaElementTracksStore │
+     │          (./main_thread/api)          │─────>│(./main_thread/tracks_sto│
+     └───────────────────────────────────────┘      │re)                      │
+                         │                          └─────────────────────────┘
+     Manage playback of  │ creates                  Handle track switching
+     a "directfile"      │                          using directly the media
+     content             ▼                          element's API (`audioTracks`,
+     ┌───────────────────────────────────────┐      `textTracks` etc.)
+     │       DirectfileContentInitializer    │
+     │          (./main_thread/init)         │
+     └───────────────────────────────────────┘
+                         │
+                         ▼
+                        ... Some other RxPlayer modules
+                            (All running in main thread)
+```
+
+As you can see, everything runs in main thread, a specialized module called the
+`DirectfileContentInitializer` is called by the API to start-up such contents and a
+specialized `MediaElementTracksStore` is handling tracks specifically for directfile
+contents (as they are handled differently than for other code paths, here trough API
+exposed by the browser).

package/src/compat/disable_remote_playback_on_managed_media_source.ts

@@ -0,0 +1,39 @@
+import type { CancellationSignal } from "../utils/task_canceller";
+import { isManagedMediaSource, type IMediaElement } from "./browser_compatibility_types";
+
+/**
+ * Temporarily disables remote playback on a media element by setting the
+ * `disableRemotePlayback` attribute to `true` when using a `ManagedMediaSource`.
+ * The original value of the `disableRemotePlayback` attribute is restored when
+ * the cancellation signal is triggered.
+ *
+ * This is useful when the `ManagedMediaSource` is being used and
+ * the media element needs to ensure that remote playback (e.g., Airplay) is disabled
+ * during the playback session.
+ * @param {HTMLElement} mediaElement - The media element whose `disableRemotePlayback`
+ * attribute will be modified.
+ * @param {CancellationSignal} cancellationSignal - The signal that, when triggered,
+ * restores the `disableRemotePlayback` attribute to its original value.
+ */
+export default function disableRemotePlaybackOnManagedMediaSource(
+  mediaElement: IMediaElement,
+  cancellationSignal: CancellationSignal,
+) {
+  if (isManagedMediaSource && "disableRemotePlayback" in mediaElement) {
+    const disableRemotePlaybackPreviousValue = mediaElement.disableRemotePlayback;
+    cancellationSignal.register(() => {
+      /**
+       * Restore the `disableRemotePlayback` attribute to its previous value.
+       * This ensures that the media element's state is the same as it was before
+       * calling `RxPlayer.loadVideo` in the application.
+       */
+      mediaElement.disableRemotePlayback = disableRemotePlaybackPreviousValue;
+    });
+    /**
+     * Using ManagedMediaSource needs to disableRemotePlayback or to provide
+     * an Airplay source alternative, such as HLS.
+     * https://github.com/w3c/media-source/issues/320
+     */
+    mediaElement.disableRemotePlayback = true;
+  }
+}

package/src/compat/eme/close_session.ts

@@ -33,16 +33,16 @@ import type { IMediaKeySession } from "../browser_compatibility_types";
  * @returns {Promise.<undefined>}
  */
 export default function closeSession(session: IMediaKeySession): Promise<void> {
-  const timeoutCanceller = new TaskCanceller();
+  const timeoutCanceller = new TaskCanceller("MediaKeySession close timeout");
 
   return Promise.race([
     session.close().then(() => {
-      timeoutCanceller.cancel();
+      timeoutCanceller.cancel("MediaKeySession close method resolved");
     }),
     // The `closed` promise may resolve, even if `close()` result has not
     // (seen at some point on Firefox).
     session.closed.then(() => {
-      timeoutCanceller.cancel();
+      timeoutCanceller.cancel("MediaKeySession closed property resolved");
     }),
     waitTimeoutAndCheck(),
   ]);

package/src/compat/eme/custom_media_keys/ie11_media_keys.ts

@@ -43,7 +43,7 @@ class IE11MediaKeySession
     this.expiration = NaN;
     this.keyStatuses = new Map();
     this._mk = mk;
-    this._sessionClosingCanceller = new TaskCanceller();
+    this._sessionClosingCanceller = new TaskCanceller("IE11 MediaKeySession Closing");
     this.closed = new Promise((resolve) => {
       this._sessionClosingCanceller.signal.register(() =>
         resolve("closed-by-application"),
@@ -117,7 +117,7 @@ class IE11MediaKeySession
         this._ss.close();
         this._ss = undefined;
       }
-      this._sessionClosingCanceller.cancel();
+      this._sessionClosingCanceller.cancel("IE11 MediaKeySession close");
       resolve();
     });
   }