Make current period a placeholder when a live stream is reset

In case the player is reset while a live stream is playing, the current
period needs to be a placeholder. This makes sure that the default start
position is used when the first live timeline arrives after re-preparing.

#minor-release

PiperOrigin-RevId: 539044360
(cherry picked from commit 538143aad92340ede0891a74c514a213e5513d06)

library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java

@@ -1484,9 +1484,17 @@ import java.util.concurrent.atomic.AtomicBoolean;
     queue.clear();
     shouldContinueLoading = false;
 
+    Timeline timeline = playbackInfo.timeline;
+    if (releaseMediaSourceList && timeline instanceof PlaylistTimeline) {
+      // Wrap the current live timeline to make sure the current period is marked as a placeholder
+      // to force resolving the default start position with the next timeline refresh.
+      timeline =
+          ((PlaylistTimeline) playbackInfo.timeline)
+              .copyWithPlaceholderTimeline(mediaSourceList.getShuffleOrder());
+    }
     playbackInfo =
         new PlaybackInfo(
-            playbackInfo.timeline,
+            timeline,
             mediaPeriodId,
             requestedContentPositionUs,
             /* discontinuityStartPositionUs= */ startPositionUs,

library/core/src/main/java/com/google/android/exoplayer2/MediaSourceList.java

@@ -364,6 +364,11 @@ import org.checkerframework.checker.nullness.compatqual.NullableType;
     return new PlaylistTimeline(mediaSourceHolders, shuffleOrder);
   }
 
+  /** Returns the shuffle order */
+  public ShuffleOrder getShuffleOrder() {
+    return shuffleOrder;
+  }
+
   // Internal methods.
 
   private void enableMediaSource(MediaSourceHolder mediaSourceHolder) {

library/core/src/main/java/com/google/android/exoplayer2/PlaylistTimeline.java

@@ -15,6 +15,7 @@
  */
 package com.google.android.exoplayer2;
 
+import com.google.android.exoplayer2.source.ForwardingTimeline;
 import com.google.android.exoplayer2.source.ShuffleOrder;
 import com.google.android.exoplayer2.util.Util;
 import java.util.Arrays;
@@ -37,23 +38,26 @@ import java.util.List;
   public PlaylistTimeline(
       Collection<? extends MediaSourceInfoHolder> mediaSourceInfoHolders,
       ShuffleOrder shuffleOrder) {
+    this(getTimelines(mediaSourceInfoHolders), getUids(mediaSourceInfoHolders), shuffleOrder);
+  }
+
+  private PlaylistTimeline(Timeline[] timelines, Object[] uids, ShuffleOrder shuffleOrder) {
     super(/* isAtomic= */ false, shuffleOrder);
-    int childCount = mediaSourceInfoHolders.size();
+    int childCount = timelines.length;
+    this.timelines = timelines;
     firstPeriodInChildIndices = new int[childCount];
     firstWindowInChildIndices = new int[childCount];
-    timelines = new Timeline[childCount];
-    uids = new Object[childCount];
+    this.uids = uids;
     childIndexByUid = new HashMap<>();
     int index = 0;
     int windowCount = 0;
     int periodCount = 0;
-    for (MediaSourceInfoHolder mediaSourceInfoHolder : mediaSourceInfoHolders) {
-      timelines[index] = mediaSourceInfoHolder.getTimeline();
+    for (Timeline timeline : timelines) {
+      this.timelines[index] = timeline;
       firstWindowInChildIndices[index] = windowCount;
       firstPeriodInChildIndices[index] = periodCount;
-      windowCount += timelines[index].getWindowCount();
-      periodCount += timelines[index].getPeriodCount();
-      uids[index] = mediaSourceInfoHolder.getUid();
+      windowCount += this.timelines[index].getWindowCount();
+      periodCount += this.timelines[index].getPeriodCount();
       childIndexByUid.put(uids[index], index++);
     }
     this.windowCount = windowCount;
@@ -110,4 +114,40 @@ import java.util.List;
   public int getPeriodCount() {
     return periodCount;
   }
+
+  public PlaylistTimeline copyWithPlaceholderTimeline(ShuffleOrder shuffleOrder) {
+    Timeline[] newTimelines = new Timeline[timelines.length];
+    for (int i = 0; i < timelines.length; i++) {
+      newTimelines[i] =
+          new ForwardingTimeline(timelines[i]) {
+            @Override
+            public Period getPeriod(int periodIndex, Period period, boolean setIds) {
+              Period superPeriod = super.getPeriod(periodIndex, period, setIds);
+              superPeriod.isPlaceholder = true;
+              return superPeriod;
+            }
+          };
+    }
+    return new PlaylistTimeline(newTimelines, uids, shuffleOrder);
+  }
+
+  private static Object[] getUids(
+      Collection<? extends MediaSourceInfoHolder> mediaSourceInfoHolders) {
+    Object[] uids = new Object[mediaSourceInfoHolders.size()];
+    int i = 0;
+    for (MediaSourceInfoHolder holder : mediaSourceInfoHolders) {
+      uids[i++] = holder.getUid();
+    }
+    return uids;
+  }
+
+  private static Timeline[] getTimelines(
+      Collection<? extends MediaSourceInfoHolder> mediaSourceInfoHolders) {
+    Timeline[] timelines = new Timeline[mediaSourceInfoHolders.size()];
+    int i = 0;
+    for (MediaSourceInfoHolder holder : mediaSourceInfoHolders) {
+      timelines[i++] = holder.getTimeline();
+    }
+    return timelines;
+  }
 }

library/core/src/test/java/com/google/android/exoplayer2/PlaylistTimelineTest.java

+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.android.exoplayer2.source.ShuffleOrder;
+import com.google.android.exoplayer2.testutil.FakeTimeline;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Unit test for {@link PlaylistTimeline}. */
+@RunWith(AndroidJUnit4.class)
+public class PlaylistTimelineTest {
+
+  @Test
+  public void copyWithPlaceholderTimeline_equalTimelineExceptPlaceholderFlag() {
+    MediaSourceInfoHolder mediaSourceInfoHolder1 = mock(MediaSourceInfoHolder.class);
+    MediaSourceInfoHolder mediaSourceInfoHolder2 = mock(MediaSourceInfoHolder.class);
+    ImmutableList<MediaSourceInfoHolder> mediaSourceInfoHolders =
+        ImmutableList.of(mediaSourceInfoHolder1, mediaSourceInfoHolder2);
+    FakeTimeline fakeTimeline1 = new FakeTimeline(2);
+    FakeTimeline fakeTimeline2 = new FakeTimeline(1);
+    when(mediaSourceInfoHolder1.getTimeline()).thenReturn(fakeTimeline1);
+    when(mediaSourceInfoHolder1.getUid()).thenReturn("uid1");
+    when(mediaSourceInfoHolder2.getTimeline()).thenReturn(fakeTimeline2);
+    when(mediaSourceInfoHolder2.getUid()).thenReturn("uid2");
+    ShuffleOrder.DefaultShuffleOrder shuffleOrder =
+        new ShuffleOrder.DefaultShuffleOrder(mediaSourceInfoHolders.size());
+    PlaylistTimeline playlistTimeline = new PlaylistTimeline(mediaSourceInfoHolders, shuffleOrder);
+
+    PlaylistTimeline playlistTimelineCopy =
+        playlistTimeline.copyWithPlaceholderTimeline(shuffleOrder);
+
+    assertThat(playlistTimelineCopy).isNotEqualTo(playlistTimeline);
+    assertThat(playlistTimelineCopy.getWindowCount()).isEqualTo(playlistTimeline.getWindowCount());
+    assertThat(playlistTimelineCopy.getPeriodCount()).isEqualTo(playlistTimeline.getPeriodCount());
+    List<Timeline> copiedChildTimelines = playlistTimelineCopy.getChildTimelines();
+    List<Timeline> originalChildTimelines = playlistTimeline.getChildTimelines();
+    for (int i = 0; i < copiedChildTimelines.size(); i++) {
+      Timeline childTimeline = copiedChildTimelines.get(i);
+      Timeline originalChildTimeline = originalChildTimelines.get(i);
+      for (int j = 0; j < childTimeline.getWindowCount(); j++) {
+        assertThat(childTimeline.getWindow(/* windowIndex= */ 0, new Timeline.Window()))
+            .isEqualTo(
+                originalChildTimeline.getWindow(/* windowIndex= */ 0, new Timeline.Window()));
+        Timeline.Period expectedPeriod =
+            originalChildTimeline.getPeriod(/* periodIndex= */ 0, new Timeline.Period());
+        Timeline.Period actualPeriod =
+            childTimeline.getPeriod(/* periodIndex= */ 0, new Timeline.Period());
+        assertThat(actualPeriod).isNotEqualTo(expectedPeriod);
+        actualPeriod.isPlaceholder = false;
+        assertThat(actualPeriod).isEqualTo(expectedPeriod);
+      }
+    }
+  }
+}

library/core/src/test/java/com/google/android/exoplayer2/analytics/DefaultAnalyticsCollectorTest.java

@@ -757,7 +757,11 @@ public final class DefaultAnalyticsCollectorTest {
             period0Seq0 /* ENDED */)
         .inOrder();
     assertThat(listener.getEvents(EVENT_TIMELINE_CHANGED))
-        .containsExactly(WINDOW_0 /* prepared */, WINDOW_0 /* prepared */);
+        .containsExactly(
+            WINDOW_0 /* playlist change */,
+            WINDOW_0 /* prepared */,
+            period0Seq0 /* reset after error */,
+            period0Seq0 /* second prepare */);
     assertThat(listener.getEvents(EVENT_POSITION_DISCONTINUITY)).containsExactly(period0Seq0);
     assertThat(listener.getEvents(EVENT_SEEK_STARTED)).containsExactly(period0Seq0);
     assertThat(listener.getEvents(EVENT_IS_LOADING_CHANGED))