QueueTimeline.java

/*
 * Copyright 2021 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 androidx.media3.session;

import static androidx.media3.common.util.Assertions.checkArgument;
import static androidx.media3.common.util.Assertions.checkNotNull;

import android.support.v4.media.MediaMetadataCompat;
import android.support.v4.media.session.MediaSessionCompat.QueueItem;
import androidx.annotation.Nullable;
import androidx.media3.common.C;
import androidx.media3.common.MediaItem;
import androidx.media3.common.Timeline;
import androidx.media3.common.util.Util;
import com.google.common.base.Objects;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * An immutable class to represent the current {@link Timeline} backed by {@linkplain QueueItem
 * queue items}.
 *
 * <p>This timeline supports the case in which the current {@link MediaMetadataCompat} is not
 * included in the queue of the session. In such a case a fake media item is inserted at the end of
 * the timeline and the size of the timeline is by one larger than the size of the corresponding
 * queue in the session.
 */
/* package */ final class QueueTimeline extends Timeline {

  public static final QueueTimeline DEFAULT =
      new QueueTimeline(ImmutableList.of(), ImmutableMap.of(), /* fakeMediaItem= */ null);

  private static final Object FAKE_WINDOW_UID = new Object();

  private final ImmutableList<MediaItem> mediaItems;
  private final ImmutableMap<MediaItem, Long> mediaItemToQueueIdMap;
  @Nullable private final MediaItem fakeMediaItem;

  /** Creates a new instance. */
  public QueueTimeline(QueueTimeline queueTimeline) {
    this.mediaItems = queueTimeline.mediaItems;
    this.mediaItemToQueueIdMap = queueTimeline.mediaItemToQueueIdMap;
    this.fakeMediaItem = queueTimeline.fakeMediaItem;
  }

  private QueueTimeline(
      ImmutableList<MediaItem> mediaItems,
      ImmutableMap<MediaItem, Long> mediaItemToQueueIdMap,
      @Nullable MediaItem fakeMediaItem) {
    this.mediaItems = mediaItems;
    this.mediaItemToQueueIdMap = mediaItemToQueueIdMap;
    this.fakeMediaItem = fakeMediaItem;
  }

  /** Creates a {@link QueueTimeline} from a list of {@linkplain QueueItem queue items}. */
  public static QueueTimeline create(List<QueueItem> queue) {
    ImmutableList.Builder<MediaItem> mediaItemsBuilder = new ImmutableList.Builder<>();
    ImmutableMap.Builder<MediaItem, Long> mediaItemToQueueIdMap = new ImmutableMap.Builder<>();
    for (int i = 0; i < queue.size(); i++) {
      QueueItem queueItem = queue.get(i);
      MediaItem mediaItem = MediaUtils.convertToMediaItem(queueItem);
      mediaItemsBuilder.add(mediaItem);
      mediaItemToQueueIdMap.put(mediaItem, queueItem.getQueueId());
    }
    return new QueueTimeline(
        mediaItemsBuilder.build(), mediaItemToQueueIdMap.buildOrThrow(), /* fakeMediaItem= */ null);
  }

  /**
   * Gets the queue ID of the media item at the given index or {@link QueueItem#UNKNOWN_ID} if not
   * known.
   *
   * @param mediaItemIndex The media item index.
   * @return The corresponding queue ID or {@link QueueItem#UNKNOWN_ID} if not known.
   */
  public long getQueueId(int mediaItemIndex) {
    MediaItem mediaItem = getMediaItemAt(mediaItemIndex);
    @Nullable Long queueId = mediaItemToQueueIdMap.get(mediaItem);
    return queueId == null ? QueueItem.UNKNOWN_ID : queueId;
  }

  /**
   * Copies the timeline with the given fake media item.
   *
   * @param fakeMediaItem The fake media item.
   * @return A new {@link QueueTimeline} reflecting the update.
   */
  public QueueTimeline copyWithFakeMediaItem(@Nullable MediaItem fakeMediaItem) {
    return new QueueTimeline(mediaItems, mediaItemToQueueIdMap, fakeMediaItem);
  }

  /**
   * Replaces the media item at {@code replaceIndex} with the new media item.
   *
   * @param replaceIndex The index at which to replace the media item.
   * @param newMediaItem The new media item that replaces the old one.
   * @return A new {@link QueueTimeline} reflecting the update.
   */
  public QueueTimeline copyWithNewMediaItem(int replaceIndex, MediaItem newMediaItem) {
    checkArgument(
        replaceIndex < mediaItems.size()
            || (replaceIndex == mediaItems.size() && fakeMediaItem != null));
    if (replaceIndex == mediaItems.size()) {
      return new QueueTimeline(mediaItems, mediaItemToQueueIdMap, newMediaItem);
    }
    MediaItem oldMediaItem = mediaItems.get(replaceIndex);
    // Create the new play list.
    ImmutableList.Builder<MediaItem> newMediaItemsBuilder = new ImmutableList.Builder<>();
    newMediaItemsBuilder.addAll(mediaItems.subList(0, replaceIndex));
    newMediaItemsBuilder.add(newMediaItem);
    newMediaItemsBuilder.addAll(mediaItems.subList(replaceIndex + 1, mediaItems.size()));
    // Update the map of items to queue IDs accordingly.
    Map<MediaItem, Long> newMediaItemToQueueIdMap = new HashMap<>(mediaItemToQueueIdMap);
    Long queueId = checkNotNull(newMediaItemToQueueIdMap.remove(oldMediaItem));
    newMediaItemToQueueIdMap.put(newMediaItem, queueId);
    return new QueueTimeline(
        newMediaItemsBuilder.build(), ImmutableMap.copyOf(newMediaItemToQueueIdMap), fakeMediaItem);
  }

  /**
   * Replaces the media item at the given index with a list of new media items. The timeline grows
   * by one less than the size of the new list of items.
   *
   * @param index The index of the media item to be replaced.
   * @param newMediaItems The list of new {@linkplain MediaItem media items} to insert.
   * @return A new {@link QueueTimeline} reflecting the update.
   */
  public QueueTimeline copyWithNewMediaItems(int index, List<MediaItem> newMediaItems) {
    ImmutableList.Builder<MediaItem> newMediaItemsBuilder = new ImmutableList.Builder<>();
    newMediaItemsBuilder.addAll(mediaItems.subList(0, index));
    newMediaItemsBuilder.addAll(newMediaItems);
    newMediaItemsBuilder.addAll(mediaItems.subList(index, mediaItems.size()));
    return new QueueTimeline(newMediaItemsBuilder.build(), mediaItemToQueueIdMap, fakeMediaItem);
  }

  /**
   * Removes the range of media items in the current timeline.
   *
   * @param fromIndex The index to start removing items from.
   * @param toIndex The index up to which to remove items (exclusive).
   * @return A new {@link QueueTimeline} reflecting the update.
   */
  public QueueTimeline copyWithRemovedMediaItems(int fromIndex, int toIndex) {
    ImmutableList.Builder<MediaItem> newMediaItemsBuilder = new ImmutableList.Builder<>();
    newMediaItemsBuilder.addAll(mediaItems.subList(0, fromIndex));
    newMediaItemsBuilder.addAll(mediaItems.subList(toIndex, mediaItems.size()));
    return new QueueTimeline(newMediaItemsBuilder.build(), mediaItemToQueueIdMap, fakeMediaItem);
  }

  /**
   * Moves the defined range of media items to a new position.
   *
   * @param fromIndex The start index of the range to be moved.
   * @param toIndex The (exclusive) end index of the range to be moved.
   * @param newIndex The new index to move the first item of the range to.
   * @return A new {@link QueueTimeline} reflecting the update.
   */
  public QueueTimeline copyWithMovedMediaItems(int fromIndex, int toIndex, int newIndex) {
    List<MediaItem> list = new ArrayList<>(mediaItems);
    Util.moveItems(list, fromIndex, toIndex, newIndex);
    return new QueueTimeline(
        new ImmutableList.Builder<MediaItem>().addAll(list).build(),
        mediaItemToQueueIdMap,
        fakeMediaItem);
  }

  /**
   * Returns the media item index of the given media item in the timeline, or {@link C#INDEX_UNSET}
   * if the item is not part of this timeline.
   *
   * @param mediaItem The media item of interest.
   * @return The index of the item or {@link C#INDEX_UNSET} if the item is not part of the timeline.
   */
  public int indexOf(MediaItem mediaItem) {
    if (mediaItem.equals(fakeMediaItem)) {
      return mediaItems.size();
    }
    int mediaItemIndex = mediaItems.indexOf(mediaItem);
    return mediaItemIndex == -1 ? C.INDEX_UNSET : mediaItemIndex;
  }

  @Nullable
  public MediaItem getMediaItemAt(int mediaItemIndex) {
    if (mediaItemIndex >= 0 && mediaItemIndex < mediaItems.size()) {
      return mediaItems.get(mediaItemIndex);
    }
    return (mediaItemIndex == mediaItems.size()) ? fakeMediaItem : null;
  }

  @Override
  public int getWindowCount() {
    return mediaItems.size() + ((fakeMediaItem == null) ? 0 : 1);
  }

  @Override
  public Window getWindow(int windowIndex, Window window, long defaultPositionProjectionUs) {
    // TODO(b/149713425): Set duration if it's available from MediaMetadataCompat.
    MediaItem mediaItem;
    if (windowIndex == mediaItems.size() && fakeMediaItem != null) {
      mediaItem = fakeMediaItem;
    } else {
      mediaItem = mediaItems.get(windowIndex);
    }
    return getWindow(window, mediaItem, windowIndex);
  }

  @Override
  public int getPeriodCount() {
    return getWindowCount();
  }

  @Override
  public Period getPeriod(int periodIndex, Period period, boolean setIds) {
    // TODO(b/149713425): Set duration if it's available from MediaMetadataCompat.
    period.set(
        /* id= */ null,
        /* uid= */ null,
        /* windowIndex= */ periodIndex,
        /* durationUs= */ C.TIME_UNSET,
        /* positionInWindowUs= */ 0);
    return period;
  }

  @Override
  public int getIndexOfPeriod(Object uid) {
    throw new UnsupportedOperationException();
  }

  @Override
  public Object getUidOfPeriod(int periodIndex) {
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    if (this == obj) {
      return true;
    }
    if (!(obj instanceof QueueTimeline)) {
      return false;
    }
    QueueTimeline other = (QueueTimeline) obj;
    return Objects.equal(mediaItems, other.mediaItems)
        && Objects.equal(mediaItemToQueueIdMap, other.mediaItemToQueueIdMap)
        && Objects.equal(fakeMediaItem, other.fakeMediaItem);
  }

  @Override
  public int hashCode() {
    return Objects.hashCode(mediaItems, mediaItemToQueueIdMap, fakeMediaItem);
  }

  private static Window getWindow(Window window, MediaItem mediaItem, int windowIndex) {
    window.set(
        FAKE_WINDOW_UID,
        mediaItem,
        /* manifest= */ null,
        /* presentationStartTimeMs= */ C.TIME_UNSET,
        /* windowStartTimeMs= */ C.TIME_UNSET,
        /* elapsedRealtimeEpochOffsetMs= */ C.TIME_UNSET,
        /* isSeekable= */ true,
        /* isDynamic= */ false,
        /* liveConfiguration= */ null,
        /* defaultPositionUs= */ 0,
        /* durationUs= */ C.TIME_UNSET,
        /* firstPeriodIndex= */ windowIndex,
        /* lastPeriodIndex= */ windowIndex,
        /* positionInFirstPeriodUs= */ 0);
    return window;
  }
}