Map live interstitials to ad playback state

After this change, updates of the live HLS playlists are  reflected
in the ad playback state. Interstitials are inserted into new
or existing ad groups according to the current ad playback state.

PiperOrigin-RevId: 735733207

Author: marcbaechinger

libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsInterstitialsAdsLoader.java

@@ -15,11 +15,14 @@
  */
 package androidx.media3.exoplayer.hls;
 
+import static androidx.media3.common.AdPlaybackState.AD_STATE_UNAVAILABLE;
 import static androidx.media3.common.Player.DISCONTINUITY_REASON_AUTO_TRANSITION;
 import static androidx.media3.common.util.Assertions.checkArgument;
 import static androidx.media3.common.util.Assertions.checkNotNull;
 import static androidx.media3.common.util.Assertions.checkState;
 import static androidx.media3.common.util.Assertions.checkStateNotNull;
+import static androidx.media3.exoplayer.hls.playlist.HlsMediaPlaylist.Interstitial.CUE_TRIGGER_POST;
+import static androidx.media3.exoplayer.hls.playlist.HlsMediaPlaylist.Interstitial.CUE_TRIGGER_PRE;
 import static java.lang.Math.max;
 
 import android.content.Context;
@@ -48,6 +51,7 @@
 import androidx.media3.exoplayer.source.ads.AdsLoader;
 import androidx.media3.exoplayer.source.ads.AdsMediaSource;
 import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy;
+import com.google.common.collect.ImmutableList;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -283,6 +287,7 @@ default void onStop(MediaItem mediaItem, Object adsId, AdPlaybackState adPlaybac
   private final PlayerListener playerListener;
   private final Map<Object, EventListener> activeEventListeners;
   private final Map<Object, AdPlaybackState> activeAdPlaybackStates;
+  private final Map<Object, Set<String>> insertedInterstitialIds;
   private final List<Listener> listeners;
   private final Set<Object> unsupportedAdsIds;
 
@@ -294,6 +299,7 @@ public HlsInterstitialsAdsLoader() {
     playerListener = new PlayerListener();
     activeEventListeners = new HashMap<>();
     activeAdPlaybackStates = new HashMap<>();
+    insertedInterstitialIds = new HashMap<>();
     listeners = new ArrayList<>();
     unsupportedAdsIds = new HashSet<>();
   }
@@ -366,16 +372,15 @@ public void start(
     }
     activeEventListeners.put(adsId, eventListener);
     MediaItem mediaItem = adsMediaSource.getMediaItem();
-    if (player != null && isSupportedMediaItem(mediaItem, player.getCurrentTimeline())) {
+    if (isHlsMediaItem(mediaItem)) {
       // Mark with NONE. Update and notify later when timeline with interstitials arrives.
       activeAdPlaybackStates.put(adsId, AdPlaybackState.NONE);
+      insertedInterstitialIds.put(adsId, new HashSet<>());
       notifyListeners(listener -> listener.onStart(mediaItem, adsId, adViewProvider));
     } else {
       putAndNotifyAdPlaybackStateUpdate(adsId, new AdPlaybackState(adsId));
-      if (player != null) {
-        Log.w(TAG, "Unsupported media item. Playing without ads for adsId=" + adsId);
-        unsupportedAdsIds.add(adsId);
-      }
+      Log.w(TAG, "Unsupported media item. Playing without ads for adsId=" + adsId);
+      unsupportedAdsIds.add(adsId);
     }
   }
 
@@ -387,24 +392,43 @@ public void handleContentTimelineChanged(AdsMediaSource adsMediaSource, Timeline
       if (eventListener != null) {
         unsupportedAdsIds.remove(adsId);
         AdPlaybackState adPlaybackState = checkNotNull(activeAdPlaybackStates.remove(adsId));
+        insertedInterstitialIds.remove(adsId);
         if (adPlaybackState.equals(AdPlaybackState.NONE)) {
           // Play without ads after release to not interrupt playback.
           eventListener.onAdPlaybackState(new AdPlaybackState(adsId));
         }
       }
       return;
     }
+
     AdPlaybackState adPlaybackState = checkNotNull(activeAdPlaybackStates.get(adsId));
-    if (!adPlaybackState.equals(AdPlaybackState.NONE)) {
-      // VOD only. Updating the playback state is not supported yet.
+    if (!adPlaybackState.equals(AdPlaybackState.NONE)
+        && !adPlaybackState.endsWithLivePostrollPlaceHolder()) {
+      // Multiple timeline updates for VOD not supported.
       return;
     }
-    adPlaybackState = new AdPlaybackState(adsId);
+
+    if (adPlaybackState.equals(AdPlaybackState.NONE)) {
+      // Setup initial ad playback state for VOD or live.
+      adPlaybackState = new AdPlaybackState(adsId);
+      if (isLiveMediaItem(adsMediaSource.getMediaItem(), timeline)) {
+        adPlaybackState =
+            adPlaybackState.withLivePostrollPlaceholderAppended(/* isServerSideInserted= */ false);
+      }
+    }
+
     Window window = timeline.getWindow(0, new Window());
     if (window.manifest instanceof HlsManifest) {
+      HlsMediaPlaylist mediaPlaylist = ((HlsManifest) window.manifest).mediaPlaylist;
       adPlaybackState =
-          mapHlsInterstitialsToAdPlaybackState(
-              ((HlsManifest) window.manifest).mediaPlaylist, adPlaybackState);
+          window.isLive()
+              ? mapInterstitialsForLive(
+                  mediaPlaylist,
+                  adPlaybackState,
+                  window.positionInFirstPeriodUs,
+                  checkNotNull(insertedInterstitialIds.get(adsId)))
+              : mapInterstitialsForVod(
+                  mediaPlaylist, adPlaybackState, checkNotNull(insertedInterstitialIds.get(adsId)));
     }
     putAndNotifyAdPlaybackStateUpdate(adsId, adPlaybackState);
     if (!unsupportedAdsIds.contains(adsId)) {
@@ -464,6 +488,7 @@ public void stop(AdsMediaSource adsMediaSource, EventListener eventListener) {
                   adsMediaSource.getAdsId(),
                   checkNotNull(adPlaybackState)));
     }
+    insertedInterstitialIds.remove(adsId);
     unsupportedAdsIds.remove(adsId);
   }
 
@@ -488,6 +513,7 @@ private void putAndNotifyAdPlaybackStateUpdate(Object adsId, AdPlaybackState adP
         eventListener.onAdPlaybackState(adPlaybackState);
       } else {
         activeAdPlaybackStates.remove(adsId);
+        insertedInterstitialIds.remove(adsId);
       }
     }
   }
@@ -498,10 +524,6 @@ private void notifyListeners(Consumer<Listener> callable) {
     }
   }
 
-  private static boolean isSupportedMediaItem(MediaItem mediaItem, Timeline timeline) {
-    return isHlsMediaItem(mediaItem) && !isLiveMediaItem(mediaItem, timeline);
-  }
-
   private static boolean isLiveMediaItem(MediaItem mediaItem, Timeline timeline) {
     int windowIndex = timeline.getFirstWindowIndex(/* shuffleModeEnabled= */ false);
     Window window = new Window();
@@ -523,68 +545,161 @@ private static boolean isHlsMediaItem(MediaItem mediaItem) {
         || Util.inferContentType(localConfiguration.uri) == C.CONTENT_TYPE_HLS;
   }
 
-  private static AdPlaybackState mapHlsInterstitialsToAdPlaybackState(
-      HlsMediaPlaylist hlsMediaPlaylist, AdPlaybackState adPlaybackState) {
-    for (int i = 0; i < hlsMediaPlaylist.interstitials.size(); i++) {
-      Interstitial interstitial = hlsMediaPlaylist.interstitials.get(i);
+  private static AdPlaybackState mapInterstitialsForLive(
+      HlsMediaPlaylist mediaPlaylist,
+      AdPlaybackState adPlaybackState,
+      long windowPositionInPeriodUs,
+      Set<String> insertedInterstitialIds) {
+    ArrayList<Interstitial> interstitials = new ArrayList<>(mediaPlaylist.interstitials);
+    for (int i = 0; i < interstitials.size(); i++) {
+      Interstitial interstitial = interstitials.get(i);
+      long positionInPlaylistWindowUs =
+          interstitial.cue.contains(CUE_TRIGGER_PRE)
+              ? 0L
+              : (interstitial.startDateUnixUs - mediaPlaylist.startTimeUs);
+      if (interstitial.assetUri == null
+          || insertedInterstitialIds.contains(interstitial.id)
+          || interstitial.cue.contains(CUE_TRIGGER_POST)
+          || positionInPlaylistWindowUs < 0) {
+        continue;
+      }
+      long timeUs = windowPositionInPeriodUs + positionInPlaylistWindowUs;
+      int insertionIndex = adPlaybackState.adGroupCount - 1;
+      boolean isNewAdGroup = true;
+      for (int adGroupIndex = adPlaybackState.adGroupCount - 2; // skip live placeholder
+          adGroupIndex >= adPlaybackState.removedAdGroupCount;
+          adGroupIndex--) {
+        AdPlaybackState.AdGroup adGroup = adPlaybackState.getAdGroup(adGroupIndex);
+        if (adGroup.timeUs == timeUs) {
+          // Insert interstitials into or update in existing group.
+          insertionIndex = adGroupIndex;
+          isNewAdGroup = false;
+          break;
+        } else if (adGroup.timeUs < timeUs) {
+          // Insert at index after group before interstitial.
+          insertionIndex = adGroupIndex + 1;
+          break;
+        }
+        // Interstitial is before the ad group. Possible insertion index.
+        insertionIndex = adGroupIndex;
+      }
+      if (isNewAdGroup) {
+        if (insertionIndex < getLowestValidAdGroupInsertionIndex(adPlaybackState)) {
+          Log.w(
+              TAG,
+              "Skipping insertion of interstitial attempted to be inserted before an already"
+                  + " initialized ad group.");
+          continue;
+        }
+        adPlaybackState = adPlaybackState.withNewAdGroup(insertionIndex, timeUs);
+      }
+      adPlaybackState =
+          insertOrUpdateInterstitialInAdGroup(
+              interstitial, /* adGroupIndex= */ insertionIndex, adPlaybackState);
+      insertedInterstitialIds.add(interstitial.id);
+    }
+    return adPlaybackState;
+  }
+
+  private static AdPlaybackState mapInterstitialsForVod(
+      HlsMediaPlaylist mediaPlaylist,
+      AdPlaybackState adPlaybackState,
+      Set<String> insertedInterstitialIds) {
+    checkArgument(adPlaybackState.adGroupCount == 0);
+    ImmutableList<Interstitial> interstitials = mediaPlaylist.interstitials;
+    for (int i = 0; i < interstitials.size(); i++) {
+      Interstitial interstitial = interstitials.get(i);
       if (interstitial.assetUri == null) {
         Log.w(TAG, "Ignoring interstitials with X-ASSET-LIST. Not yet supported.");
         continue;
       }
-      long positionUs;
-      if (interstitial.cue.contains(Interstitial.CUE_TRIGGER_PRE)) {
-        positionUs = 0;
-      } else if (interstitial.cue.contains(Interstitial.CUE_TRIGGER_POST)) {
-        positionUs = C.TIME_END_OF_SOURCE;
+      long timeUs;
+      if (interstitial.cue.contains(CUE_TRIGGER_PRE)) {
+        timeUs = 0L;
+      } else if (interstitial.cue.contains(CUE_TRIGGER_POST)) {
+        timeUs = C.TIME_END_OF_SOURCE;
       } else {
-        positionUs = interstitial.startDateUnixUs - hlsMediaPlaylist.startTimeUs;
+        timeUs = interstitial.startDateUnixUs - mediaPlaylist.startTimeUs;
       }
-      // Check whether and at which index to insert an ad group for the interstitial start time.
       int adGroupIndex =
-          adPlaybackState.getAdGroupIndexForPositionUs(
-              positionUs, /* periodDurationUs= */ hlsMediaPlaylist.durationUs);
+          adPlaybackState.getAdGroupIndexForPositionUs(timeUs, mediaPlaylist.durationUs);
       if (adGroupIndex == C.INDEX_UNSET) {
         // There is no ad group before or at the interstitials position.
         adGroupIndex = 0;
-        adPlaybackState = adPlaybackState.withNewAdGroup(0, positionUs);
-      } else if (adPlaybackState.getAdGroup(adGroupIndex).timeUs != positionUs) {
+        adPlaybackState = adPlaybackState.withNewAdGroup(/* adGroupIndex= */ 0, timeUs);
+      } else if (adPlaybackState.getAdGroup(adGroupIndex).timeUs != timeUs) {
         // There is an ad group before the interstitials. Insert after that index.
         adGroupIndex++;
-        adPlaybackState = adPlaybackState.withNewAdGroup(adGroupIndex, positionUs);
+        adPlaybackState = adPlaybackState.withNewAdGroup(adGroupIndex, timeUs);
       }
+      adPlaybackState =
+          insertOrUpdateInterstitialInAdGroup(interstitial, adGroupIndex, adPlaybackState);
+      insertedInterstitialIds.add(interstitial.id);
+    }
+    return adPlaybackState;
+  }
 
-      int adIndexInAdGroup = max(adPlaybackState.getAdGroup(adGroupIndex).count, 0);
-
-      // Insert duration of new interstitial into existing ad durations.
-      long interstitialDurationUs =
-          getInterstitialDurationUs(interstitial, /* defaultDurationUs= */ C.TIME_UNSET);
-      long[] adDurations;
-      if (adIndexInAdGroup == 0) {
-        adDurations = new long[1];
-      } else {
-        long[] previousDurations = adPlaybackState.getAdGroup(adGroupIndex).durationsUs;
-        adDurations = new long[previousDurations.length + 1];
-        System.arraycopy(previousDurations, 0, adDurations, 0, previousDurations.length);
-      }
-      adDurations[adDurations.length - 1] = interstitialDurationUs;
-
-      long resumeOffsetIncrementUs =
-          interstitial.resumeOffsetUs != C.TIME_UNSET
-              ? interstitial.resumeOffsetUs
-              : (interstitialDurationUs != C.TIME_UNSET ? interstitialDurationUs : 0L);
-      long resumeOffsetUs =
-          adPlaybackState.getAdGroup(adGroupIndex).contentResumeOffsetUs + resumeOffsetIncrementUs;
+  private static AdPlaybackState insertOrUpdateInterstitialInAdGroup(
+      Interstitial interstitial, int adGroupIndex, AdPlaybackState adPlaybackState) {
+    AdPlaybackState.AdGroup adGroup = adPlaybackState.getAdGroup(adGroupIndex);
+    int adIndexInAdGroup = adGroup.getIndexOfAdId(interstitial.id);
+    if (adIndexInAdGroup != C.INDEX_UNSET) {
+      // Interstitial already inserted. Updating not yet supported.
+      return adPlaybackState;
+    }
+
+    // Append to the end of the group.
+    adIndexInAdGroup = max(adGroup.count, 0);
+    // Append duration of new interstitial into existing ad durations.
+    long interstitialDurationUs =
+        getInterstitialDurationUs(interstitial, /* defaultDurationUs= */ C.TIME_UNSET);
+    long[] adDurations;
+    if (adIndexInAdGroup == 0) {
+      adDurations = new long[1];
+    } else {
+      long[] previousDurations = adGroup.durationsUs;
+      adDurations = new long[previousDurations.length + 1];
+      System.arraycopy(previousDurations, 0, adDurations, 0, previousDurations.length);
+    }
+    adDurations[adDurations.length - 1] = interstitialDurationUs;
+    long resumeOffsetIncrementUs =
+        interstitial.resumeOffsetUs != C.TIME_UNSET
+            ? interstitial.resumeOffsetUs
+            : (interstitialDurationUs != C.TIME_UNSET ? interstitialDurationUs : 0L);
+    long resumeOffsetUs = adGroup.contentResumeOffsetUs + resumeOffsetIncrementUs;
+    adPlaybackState =
+        adPlaybackState
+            .withAdCount(adGroupIndex, adIndexInAdGroup + 1)
+            .withAdId(adGroupIndex, adIndexInAdGroup, interstitial.id)
+            .withAdDurationsUs(adGroupIndex, adDurations)
+            .withContentResumeOffsetUs(adGroupIndex, resumeOffsetUs);
+    if (interstitial.assetUri != null) {
       adPlaybackState =
-          adPlaybackState
-              .withAdCount(adGroupIndex, /* adCount= */ adIndexInAdGroup + 1)
-              .withAdDurationsUs(adGroupIndex, adDurations)
-              .withContentResumeOffsetUs(adGroupIndex, resumeOffsetUs)
-              .withAvailableAdMediaItem(
-                  adGroupIndex, adIndexInAdGroup, MediaItem.fromUri(interstitial.assetUri));
+          adPlaybackState.withAvailableAdMediaItem(
+              adGroupIndex,
+              adIndexInAdGroup,
+              new MediaItem.Builder()
+                  .setUri(interstitial.assetUri)
+                  .setMimeType(MimeTypes.APPLICATION_M3U8)
+                  .build());
     }
     return adPlaybackState;
   }
 
+  private static int getLowestValidAdGroupInsertionIndex(AdPlaybackState adPlaybackState) {
+    for (int adGroupIndex = adPlaybackState.adGroupCount - 1;
+        adGroupIndex >= adPlaybackState.removedAdGroupCount;
+        adGroupIndex--) {
+      for (@AdPlaybackState.AdState int state : adPlaybackState.getAdGroup(adGroupIndex).states) {
+        if (state != AD_STATE_UNAVAILABLE) {
+          return adGroupIndex + 1;
+        }
+      }
+    }
+    // All ad groups unavailable.
+    return adPlaybackState.removedAdGroupCount;
+  }
+
   private static long getInterstitialDurationUs(Interstitial interstitial, long defaultDurationUs) {
     if (interstitial.playoutLimitUs != C.TIME_UNSET) {
       return interstitial.playoutLimitUs;