Add shuffle mode parameter to Timeline interface methods.

This parameter is used by methods such as getNextWindowIndex
and getPreviousWindowIndex to determine the playback order.
Additionally, there are method to query the first and last
window index given the shuffle mode.

None of the timeline implementations nor the ExoPlayer
implementation supports shuffling so far.

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=166170229

extensions/mediasession/src/main/java/com/google/android/exoplayer2/ext/mediasession/TimelineQueueNavigator.java

@@ -127,7 +127,7 @@ public abstract class TimelineQueueNavigator implements MediaSessionConnector.Qu
       return;
       return;
     }
     }
     int previousWindowIndex = timeline.getPreviousWindowIndex(player.getCurrentWindowIndex(),
     int previousWindowIndex = timeline.getPreviousWindowIndex(player.getCurrentWindowIndex(),
-        player.getRepeatMode());
+        player.getRepeatMode(), false);
     if (player.getCurrentPosition() > MAX_POSITION_FOR_SEEK_TO_PREVIOUS
     if (player.getCurrentPosition() > MAX_POSITION_FOR_SEEK_TO_PREVIOUS
         || previousWindowIndex == C.INDEX_UNSET) {
         || previousWindowIndex == C.INDEX_UNSET) {
       player.seekTo(0);
       player.seekTo(0);
@@ -155,7 +155,7 @@ public abstract class TimelineQueueNavigator implements MediaSessionConnector.Qu
       return;
       return;
     }
     }
     int nextWindowIndex = timeline.getNextWindowIndex(player.getCurrentWindowIndex(),
     int nextWindowIndex = timeline.getNextWindowIndex(player.getCurrentWindowIndex(),
-        player.getRepeatMode());
+        player.getRepeatMode(), false);
     if (nextWindowIndex != C.INDEX_UNSET) {
     if (nextWindowIndex != C.INDEX_UNSET) {
       player.seekTo(nextWindowIndex, C.TIME_UNSET);
       player.seekTo(nextWindowIndex, C.TIME_UNSET);
     }
     }

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

@@ -488,7 +488,7 @@ import java.io.IOException;
     }
     }
     while (true) {
     while (true) {
       int nextPeriodIndex = timeline.getNextPeriodIndex(lastValidPeriodHolder.info.id.periodIndex,
       int nextPeriodIndex = timeline.getNextPeriodIndex(lastValidPeriodHolder.info.id.periodIndex,
-          period, window, repeatMode);
+          period, window, repeatMode, false);
       while (lastValidPeriodHolder.next != null
       while (lastValidPeriodHolder.next != null
           && !lastValidPeriodHolder.info.isLastInTimelinePeriod) {
           && !lastValidPeriodHolder.info.isLastInTimelinePeriod) {
         lastValidPeriodHolder = lastValidPeriodHolder.next;
         lastValidPeriodHolder = lastValidPeriodHolder.next;
@@ -1122,7 +1122,7 @@ import java.io.IOException;
     while (periodHolder.next != null) {
     while (periodHolder.next != null) {
       MediaPeriodHolder previousPeriodHolder = periodHolder;
       MediaPeriodHolder previousPeriodHolder = periodHolder;
       periodHolder = periodHolder.next;
       periodHolder = periodHolder.next;
-      periodIndex = timeline.getNextPeriodIndex(periodIndex, period, window, repeatMode);
+      periodIndex = timeline.getNextPeriodIndex(periodIndex, period, window, repeatMode, false);
       if (periodIndex != C.INDEX_UNSET
       if (periodIndex != C.INDEX_UNSET
           && periodHolder.uid.equals(timeline.getPeriod(periodIndex, period, true).uid)) {
           && periodHolder.uid.equals(timeline.getPeriod(periodIndex, period, true).uid)) {
         // The holder is consistent with the new timeline. Update its index and continue.
         // The holder is consistent with the new timeline. Update its index and continue.
@@ -1204,7 +1204,8 @@ import java.io.IOException;
     int newPeriodIndex = C.INDEX_UNSET;
     int newPeriodIndex = C.INDEX_UNSET;
     int maxIterations = oldTimeline.getPeriodCount();
     int maxIterations = oldTimeline.getPeriodCount();
     for (int i = 0; i < maxIterations && newPeriodIndex == C.INDEX_UNSET; i++) {
     for (int i = 0; i < maxIterations && newPeriodIndex == C.INDEX_UNSET; i++) {
-      oldPeriodIndex = oldTimeline.getNextPeriodIndex(oldPeriodIndex, period, window, repeatMode);
+      oldPeriodIndex = oldTimeline.getNextPeriodIndex(oldPeriodIndex, period, window, repeatMode,
+          false);
       if (oldPeriodIndex == C.INDEX_UNSET) {
       if (oldPeriodIndex == C.INDEX_UNSET) {
         // We've reached the end of the old timeline.
         // We've reached the end of the old timeline.
         break;
         break;

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

@@ -162,7 +162,7 @@ import com.google.android.exoplayer2.source.MediaSource.MediaPeriodId;
     // timeline is updated, to avoid repeatedly checking the same timeline.
     // timeline is updated, to avoid repeatedly checking the same timeline.
     if (currentMediaPeriodInfo.isLastInTimelinePeriod) {
     if (currentMediaPeriodInfo.isLastInTimelinePeriod) {
       int nextPeriodIndex = timeline.getNextPeriodIndex(currentMediaPeriodInfo.id.periodIndex,
       int nextPeriodIndex = timeline.getNextPeriodIndex(currentMediaPeriodInfo.id.periodIndex,
-          period, window, repeatMode);
+          period, window, repeatMode, false);
       if (nextPeriodIndex == C.INDEX_UNSET) {
       if (nextPeriodIndex == C.INDEX_UNSET) {
         // We can't create a next period yet.
         // We can't create a next period yet.
         return null;
         return null;
@@ -353,7 +353,7 @@ import com.google.android.exoplayer2.source.MediaSource.MediaPeriodId;
   private boolean isLastInTimeline(MediaPeriodId id, boolean isLastMediaPeriodInPeriod) {
   private boolean isLastInTimeline(MediaPeriodId id, boolean isLastMediaPeriodInPeriod) {
     int windowIndex = timeline.getPeriod(id.periodIndex, period).windowIndex;
     int windowIndex = timeline.getPeriod(id.periodIndex, period).windowIndex;
     return !timeline.getWindow(windowIndex, window).isDynamic
     return !timeline.getWindow(windowIndex, window).isDynamic
-        && timeline.isLastPeriod(id.periodIndex, period, window, repeatMode)
+        && timeline.isLastPeriod(id.periodIndex, period, window, repeatMode, false)
         && isLastMediaPeriodInPeriod;
         && isLastMediaPeriodInPeriod;
   }
   }
 
 

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

@@ -553,20 +553,24 @@ public abstract class Timeline {
 
 
   /**
   /**
    * Returns the index of the window after the window at index {@code windowIndex} depending on the
    * Returns the index of the window after the window at index {@code windowIndex} depending on the
-   * {@code repeatMode}.
+   * {@code repeatMode} and whether shuffling is enabled.
    *
    *
    * @param windowIndex Index of a window in the timeline.
    * @param windowIndex Index of a window in the timeline.
    * @param repeatMode A repeat mode.
    * @param repeatMode A repeat mode.
+   * @param shuffleModeEnabled Whether shuffling is enabled.
    * @return The index of the next window, or {@link C#INDEX_UNSET} if this is the last window.
    * @return The index of the next window, or {@link C#INDEX_UNSET} if this is the last window.
    */
    */
-  public int getNextWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode) {
+  public int getNextWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode,
+      boolean shuffleModeEnabled) {
     switch (repeatMode) {
     switch (repeatMode) {
       case Player.REPEAT_MODE_OFF:
       case Player.REPEAT_MODE_OFF:
-        return windowIndex == getWindowCount() - 1 ? C.INDEX_UNSET : windowIndex + 1;
+        return windowIndex == getLastWindowIndex(shuffleModeEnabled)  ? C.INDEX_UNSET
+            : windowIndex + 1;
       case Player.REPEAT_MODE_ONE:
       case Player.REPEAT_MODE_ONE:
         return windowIndex;
         return windowIndex;
       case Player.REPEAT_MODE_ALL:
       case Player.REPEAT_MODE_ALL:
-        return windowIndex == getWindowCount() - 1 ? 0 : windowIndex + 1;
+        return windowIndex == getLastWindowIndex(shuffleModeEnabled)
+            ? getFirstWindowIndex(shuffleModeEnabled) : windowIndex + 1;
       default:
       default:
         throw new IllegalStateException();
         throw new IllegalStateException();
     }
     }
@@ -574,26 +578,52 @@ public abstract class Timeline {
 
 
   /**
   /**
    * Returns the index of the window before the window at index {@code windowIndex} depending on the
    * Returns the index of the window before the window at index {@code windowIndex} depending on the
-   * {@code repeatMode}.
+   * {@code repeatMode} and whether shuffling is enabled.
    *
    *
    * @param windowIndex Index of a window in the timeline.
    * @param windowIndex Index of a window in the timeline.
    * @param repeatMode A repeat mode.
    * @param repeatMode A repeat mode.
+   * @param shuffleModeEnabled Whether shuffling is enabled.
    * @return The index of the previous window, or {@link C#INDEX_UNSET} if this is the first window.
    * @return The index of the previous window, or {@link C#INDEX_UNSET} if this is the first window.
    */
    */
-  public int getPreviousWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode) {
+  public int getPreviousWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode,
+      boolean shuffleModeEnabled) {
     switch (repeatMode) {
     switch (repeatMode) {
       case Player.REPEAT_MODE_OFF:
       case Player.REPEAT_MODE_OFF:
-        return windowIndex == 0 ? C.INDEX_UNSET : windowIndex - 1;
+        return windowIndex == getFirstWindowIndex(shuffleModeEnabled) ? C.INDEX_UNSET
+            : windowIndex - 1;
       case Player.REPEAT_MODE_ONE:
       case Player.REPEAT_MODE_ONE:
         return windowIndex;
         return windowIndex;
       case Player.REPEAT_MODE_ALL:
       case Player.REPEAT_MODE_ALL:
-        return windowIndex == 0 ? getWindowCount() - 1 : windowIndex - 1;
+        return windowIndex == getFirstWindowIndex(shuffleModeEnabled)
+            ? getLastWindowIndex(shuffleModeEnabled) : windowIndex - 1;
       default:
       default:
         throw new IllegalStateException();
         throw new IllegalStateException();
     }
     }
   }
   }
 
 
   /**
   /**
+   * Returns the index of the last window in the playback order depending on whether shuffling is
+   * enabled.
+   *
+   * @param shuffleModeEnabled Whether shuffling is enabled.
+   * @return The index of the last window in the playback order.
+   */
+  public int getLastWindowIndex(boolean shuffleModeEnabled) {
+    return getWindowCount() - 1;
+  }
+
+  /**
+   * Returns the index of the first window in the playback order depending on whether shuffling is
+   * enabled.
+   *
+   * @param shuffleModeEnabled Whether shuffling is enabled.
+   * @return The index of the first window in the playback order.
+   */
+  public int getFirstWindowIndex(boolean shuffleModeEnabled) {
+    return 0;
+  }
+
+  /**
    * Populates a {@link Window} with data for the window at the specified index. Does not populate
    * Populates a {@link Window} with data for the window at the specified index. Does not populate
    * {@link Window#id}.
    * {@link Window#id}.
    *
    *
@@ -614,7 +644,7 @@ public abstract class Timeline {
    *     null. The caller should pass false for efficiency reasons unless the field is required.
    *     null. The caller should pass false for efficiency reasons unless the field is required.
    * @return The populated {@link Window}, for convenience.
    * @return The populated {@link Window}, for convenience.
    */
    */
-  public Window getWindow(int windowIndex, Window window, boolean setIds) {
+  public final Window getWindow(int windowIndex, Window window, boolean setIds) {
     return getWindow(windowIndex, window, setIds, 0);
     return getWindow(windowIndex, window, setIds, 0);
   }
   }
 
 
@@ -639,19 +669,20 @@ public abstract class Timeline {
 
 
   /**
   /**
    * Returns the index of the period after the period at index {@code periodIndex} depending on the
    * Returns the index of the period after the period at index {@code periodIndex} depending on the
-   * {@code repeatMode}.
+   * {@code repeatMode} and whether shuffling is enabled.
    *
    *
    * @param periodIndex Index of a period in the timeline.
    * @param periodIndex Index of a period in the timeline.
    * @param period A {@link Period} to be used internally. Must not be null.
    * @param period A {@link Period} to be used internally. Must not be null.
    * @param window A {@link Window} to be used internally. Must not be null.
    * @param window A {@link Window} to be used internally. Must not be null.
    * @param repeatMode A repeat mode.
    * @param repeatMode A repeat mode.
+   * @param shuffleModeEnabled Whether shuffling is enabled.
    * @return The index of the next period, or {@link C#INDEX_UNSET} if this is the last period.
    * @return The index of the next period, or {@link C#INDEX_UNSET} if this is the last period.
    */
    */
   public final int getNextPeriodIndex(int periodIndex, Period period, Window window,
   public final int getNextPeriodIndex(int periodIndex, Period period, Window window,
-      @Player.RepeatMode int repeatMode) {
+      @Player.RepeatMode int repeatMode, boolean shuffleModeEnabled) {
     int windowIndex = getPeriod(periodIndex, period).windowIndex;
     int windowIndex = getPeriod(periodIndex, period).windowIndex;
     if (getWindow(windowIndex, window).lastPeriodIndex == periodIndex) {
     if (getWindow(windowIndex, window).lastPeriodIndex == periodIndex) {
-      int nextWindowIndex = getNextWindowIndex(windowIndex, repeatMode);
+      int nextWindowIndex = getNextWindowIndex(windowIndex, repeatMode, shuffleModeEnabled);
       if (nextWindowIndex == C.INDEX_UNSET) {
       if (nextWindowIndex == C.INDEX_UNSET) {
         return C.INDEX_UNSET;
         return C.INDEX_UNSET;
       }
       }
@@ -662,17 +693,19 @@ public abstract class Timeline {
 
 
   /**
   /**
    * Returns whether the given period is the last period of the timeline depending on the
    * Returns whether the given period is the last period of the timeline depending on the
-   * {@code repeatMode}.
+   * {@code repeatMode} and whether shuffling is enabled.
    *
    *
    * @param periodIndex A period index.
    * @param periodIndex A period index.
    * @param period A {@link Period} to be used internally. Must not be null.
    * @param period A {@link Period} to be used internally. Must not be null.
    * @param window A {@link Window} to be used internally. Must not be null.
    * @param window A {@link Window} to be used internally. Must not be null.
    * @param repeatMode A repeat mode.
    * @param repeatMode A repeat mode.
+   * @param shuffleModeEnabled Whether shuffling is enabled.
    * @return Whether the period of the given index is the last period of the timeline.
    * @return Whether the period of the given index is the last period of the timeline.
    */
    */
   public final boolean isLastPeriod(int periodIndex, Period period, Window window,
   public final boolean isLastPeriod(int periodIndex, Period period, Window window,
-      @Player.RepeatMode int repeatMode) {
-    return getNextPeriodIndex(periodIndex, period, window, repeatMode) == C.INDEX_UNSET;
+      @Player.RepeatMode int repeatMode, boolean shuffleModeEnabled) {
+    return getNextPeriodIndex(periodIndex, period, window, repeatMode, shuffleModeEnabled)
+        == C.INDEX_UNSET;
   }
   }
 
 
   /**
   /**

library/core/src/main/java/com/google/android/exoplayer2/offline/DownloadException.java

+/*
+ * Copyright (C) 2017 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.offline;
+
+import com.google.android.exoplayer2.util.ClosedSource;
+import java.io.IOException;
+
+/** Thrown on an error during downloading. */
+@ClosedSource(reason = "Not ready yet")
+public final class DownloadException extends IOException {
+
+  /** @param message The message for the exception. */
+  public DownloadException(String message) {
+    super(message);
+  }
+
+}

library/core/src/main/java/com/google/android/exoplayer2/offline/Downloader.java

+/*
+ * Copyright (C) 2017 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.offline;
+
+import android.support.annotation.Nullable;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.util.ClosedSource;
+import java.io.IOException;
+
+/**
+ * An interface for stream downloaders.
+ */
+@ClosedSource(reason = "Not ready yet")
+public interface Downloader {
+
+  /**
+   * Listener notified when download progresses.
+   * <p>
+   * No guarantees are made about the thread or threads on which the listener is called, but it is
+   * guaranteed that listener methods will be called in a serial fashion (i.e. one at a time) and in
+   * the same order as events occurred.
+   */
+  interface ProgressListener {
+    /**
+     * Called during the download. Calling intervals depend on the {@link Downloader}
+     * implementation.
+     *
+     * @param downloader The reporting instance.
+     * @param downloadPercentage The download percentage. This value can be an estimation.
+     * @param downloadedBytes Total number of downloaded bytes.
+     * @see #download(ProgressListener)
+     */
+    void onDownloadProgress(Downloader downloader, float downloadPercentage, long downloadedBytes);
+  }
+
+  /**
+   * Initializes the downloader.
+   *
+   * @throws DownloadException Thrown if the media cannot be downloaded.
+   * @throws InterruptedException If the thread has been interrupted.
+   * @throws IOException Thrown when there is an io error while reading from cache.
+   * @see #getDownloadedBytes()
+   * @see #getDownloadPercentage()
+   */
+  void init() throws InterruptedException, IOException;
+
+  /**
+   * Downloads the media.
+   *
+   * @param listener If not null, called during download.
+   * @throws DownloadException Thrown if the media cannot be downloaded.
+   * @throws InterruptedException If the thread has been interrupted.
+   * @throws IOException Thrown when there is an io error while downloading.
+   */
+  void download(@Nullable ProgressListener listener)
+      throws InterruptedException, IOException;
+
+  /**
+   * Removes all of the downloaded data of the media.
+   *
+   * @throws InterruptedException Thrown if the thread was interrupted.
+   */
+  void remove() throws InterruptedException;
+
+  /**
+   * Returns the total number of downloaded bytes, or {@link C#LENGTH_UNSET} if it hasn't been
+   * calculated yet.
+   *
+   * @see #init()
+   */
+  long getDownloadedBytes();
+
+  /**
+   * Returns the download percentage, or {@link Float#NaN} if it can't be calculated yet. This
+   * value can be an estimation.
+   *
+   * @see #init()
+   */
+  float getDownloadPercentage();
+
+}

library/core/src/main/java/com/google/android/exoplayer2/offline/DownloaderConstructorHelper.java

+/*
+ * Copyright (C) 2017 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.offline;
+
+import android.support.annotation.Nullable;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.upstream.DataSink;
+import com.google.android.exoplayer2.upstream.DataSource;
+import com.google.android.exoplayer2.upstream.DataSource.Factory;
+import com.google.android.exoplayer2.upstream.DummyDataSource;
+import com.google.android.exoplayer2.upstream.FileDataSource;
+import com.google.android.exoplayer2.upstream.PriorityDataSource;
+import com.google.android.exoplayer2.upstream.cache.Cache;
+import com.google.android.exoplayer2.upstream.cache.CacheDataSink;
+import com.google.android.exoplayer2.upstream.cache.CacheDataSource;
+import com.google.android.exoplayer2.util.Assertions;
+import com.google.android.exoplayer2.util.ClosedSource;
+import com.google.android.exoplayer2.util.PriorityTaskManager;
+
+/** A helper class that holds necessary parameters for {@link Downloader} construction. */
+@ClosedSource(reason = "Not ready yet")
+public final class DownloaderConstructorHelper {
+
+  private final Cache cache;
+  private final Factory upstreamDataSourceFactory;
+  private final Factory cacheReadDataSourceFactory;
+  private final DataSink.Factory cacheWriteDataSinkFactory;
+  private final PriorityTaskManager priorityTaskManager;
+
+  /**
+   * @param cache Cache instance to be used to store downloaded data.
+   * @param upstreamDataSourceFactory A {@link Factory} for downloading data.
+   */
+  public DownloaderConstructorHelper(Cache cache, Factory upstreamDataSourceFactory) {
+    this(cache, upstreamDataSourceFactory, null, null, null);
+  }
+
+  /**
+   * @param cache Cache instance to be used to store downloaded data.
+   * @param upstreamDataSourceFactory A {@link Factory} for downloading data.
+   * @param cacheReadDataSourceFactory A {@link Factory} for reading data from the cache.
+   *     If null, null is passed to {@link Downloader} constructor.
+   * @param cacheWriteDataSinkFactory A {@link DataSink.Factory} for writing data to the cache. If
+   *     null, null is passed to {@link Downloader} constructor.
+   * @param priorityTaskManager If one is given then the download priority is set lower than
+   *     loading. If null, null is passed to {@link Downloader} constructor.
+   */
+  public DownloaderConstructorHelper(Cache cache, Factory upstreamDataSourceFactory,
+      @Nullable Factory cacheReadDataSourceFactory,
+      @Nullable DataSink.Factory cacheWriteDataSinkFactory,
+      @Nullable PriorityTaskManager priorityTaskManager) {
+    Assertions.checkNotNull(upstreamDataSourceFactory);
+    this.cache = cache;
+    this.upstreamDataSourceFactory = upstreamDataSourceFactory;
+    this.cacheReadDataSourceFactory = cacheReadDataSourceFactory;
+    this.cacheWriteDataSinkFactory = cacheWriteDataSinkFactory;
+    this.priorityTaskManager = priorityTaskManager;
+  }
+
+  /** Returns the {@link Cache} instance. */
+  public Cache getCache() {
+    return cache;
+  }
+
+  /** Returns a {@link PriorityTaskManager} instance.*/
+  public PriorityTaskManager getPriorityTaskManager() {
+    // Return a dummy PriorityTaskManager if none is provided. Create a new PriorityTaskManager
+    // each time so clients don't affect each other over the dummy PriorityTaskManager instance.
+    return priorityTaskManager != null ? priorityTaskManager : new PriorityTaskManager();
+  }
+
+  /**
+   * Returns a new {@link CacheDataSource} instance. If {@code offline} is true, it can only read
+   * data from the cache.
+   */
+  public CacheDataSource buildCacheDataSource(boolean offline) {
+    DataSource cacheReadDataSource = cacheReadDataSourceFactory != null
+        ? cacheReadDataSourceFactory.createDataSource() : new FileDataSource();
+    if (offline) {
+      return new CacheDataSource(cache, DummyDataSource.INSTANCE,
+          cacheReadDataSource, null, CacheDataSource.FLAG_BLOCK_ON_CACHE, null);
+    } else {
+      DataSink cacheWriteDataSink = cacheWriteDataSinkFactory != null
+          ? cacheWriteDataSinkFactory.createDataSink()
+          : new CacheDataSink(cache, CacheDataSource.DEFAULT_MAX_CACHE_FILE_SIZE);
+      DataSource upstream = upstreamDataSourceFactory.createDataSource();
+      upstream = priorityTaskManager == null ? upstream
+          : new PriorityDataSource(upstream, priorityTaskManager, C.PRIORITY_DOWNLOAD);
+      return new CacheDataSource(cache, upstream, cacheReadDataSource,
+          cacheWriteDataSink, CacheDataSource.FLAG_BLOCK_ON_CACHE, null);
+    }
+  }
+
+}

library/core/src/main/java/com/google/android/exoplayer2/offline/ProgressiveDownloader.java

+/*
+ * Copyright (C) 2017 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.offline;
+
+import android.net.Uri;
+import android.support.annotation.Nullable;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.upstream.DataSpec;
+import com.google.android.exoplayer2.upstream.cache.Cache;
+import com.google.android.exoplayer2.upstream.cache.CacheDataSource;
+import com.google.android.exoplayer2.upstream.cache.CacheUtil;
+import com.google.android.exoplayer2.upstream.cache.CacheUtil.CachingCounters;
+import com.google.android.exoplayer2.util.ClosedSource;
+import com.google.android.exoplayer2.util.PriorityTaskManager;
+import java.io.IOException;
+
+/**
+ * A downloader for progressive media streams.
+ */
+@ClosedSource(reason = "Not ready yet")
+public final class ProgressiveDownloader implements Downloader {
+
+  private static final int BUFFER_SIZE_BYTES = 128 * 1024;
+
+  private final DataSpec dataSpec;
+  private final Cache cache;
+  private final CacheDataSource dataSource;
+  private final PriorityTaskManager priorityTaskManager;
+  private final CacheUtil.CachingCounters cachingCounters;
+
+  /**
+   * @param uri Uri of the data to be downloaded.
+   * @param customCacheKey A custom key that uniquely identifies the original stream. Used for cache
+   *     indexing. May be null.
+   * @param constructorHelper a {@link DownloaderConstructorHelper} instance.
+   */
+  public ProgressiveDownloader(
+      String uri, String customCacheKey, DownloaderConstructorHelper constructorHelper) {
+    this.dataSpec = new DataSpec(Uri.parse(uri), 0, C.LENGTH_UNSET, customCacheKey, 0);
+    this.cache = constructorHelper.getCache();
+    this.dataSource = constructorHelper.buildCacheDataSource(false);
+    this.priorityTaskManager = constructorHelper.getPriorityTaskManager();
+    cachingCounters = new CachingCounters();
+  }
+
+  @Override
+  public void init() {
+    CacheUtil.getCached(dataSpec, cache, cachingCounters);
+  }
+
+  @Override
+  public void download(@Nullable ProgressListener listener) throws InterruptedException,
+      IOException {
+    priorityTaskManager.add(C.PRIORITY_DOWNLOAD);
+    try {
+      byte[] buffer = new byte[BUFFER_SIZE_BYTES];
+      CacheUtil.cache(dataSpec, cache, dataSource, buffer, priorityTaskManager, C.PRIORITY_DOWNLOAD,
+          cachingCounters, true);
+      // TODO: Work out how to call onDownloadProgress periodically during the download, or else
+      // get rid of ProgressListener and move to a model where the manager periodically polls
+      // Downloaders.
+      if (listener != null) {
+        listener.onDownloadProgress(this, 100, cachingCounters.contentLength);
+      }
+    } finally {
+      priorityTaskManager.remove(C.PRIORITY_DOWNLOAD);
+    }
+  }
+
+  @Override
+  public void remove() {
+    CacheUtil.remove(cache, CacheUtil.getKey(dataSpec));
+  }
+
+  @Override
+  public long getDownloadedBytes() {
+    return cachingCounters.totalCachedBytes();
+  }
+
+  @Override
+  public float getDownloadPercentage() {
+    long contentLength = cachingCounters.contentLength;
+    return contentLength == C.LENGTH_UNSET ? Float.NaN
+        : ((cachingCounters.totalCachedBytes() * 100f) / contentLength);
+  }
+
+}

library/core/src/main/java/com/google/android/exoplayer2/source/AbstractConcatenatedTimeline.java

@@ -32,12 +32,14 @@ import com.google.android.exoplayer2.Timeline;
   }
   }
 
 
   @Override
   @Override
-  public int getNextWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode) {
+  public int getNextWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode,
+      boolean shuffleModeEnabled) {
     int childIndex = getChildIndexByWindowIndex(windowIndex);
     int childIndex = getChildIndexByWindowIndex(windowIndex);
     int firstWindowIndexInChild = getFirstWindowIndexByChildIndex(childIndex);
     int firstWindowIndexInChild = getFirstWindowIndexByChildIndex(childIndex);
     int nextWindowIndexInChild = getTimelineByChildIndex(childIndex).getNextWindowIndex(
     int nextWindowIndexInChild = getTimelineByChildIndex(childIndex).getNextWindowIndex(
         windowIndex - firstWindowIndexInChild,
         windowIndex - firstWindowIndexInChild,
-        repeatMode == Player.REPEAT_MODE_ALL ? Player.REPEAT_MODE_OFF : repeatMode);
+        repeatMode == Player.REPEAT_MODE_ALL ? Player.REPEAT_MODE_OFF : repeatMode,
+        shuffleModeEnabled);
     if (nextWindowIndexInChild != C.INDEX_UNSET) {
     if (nextWindowIndexInChild != C.INDEX_UNSET) {
       return firstWindowIndexInChild + nextWindowIndexInChild;
       return firstWindowIndexInChild + nextWindowIndexInChild;
     } else {
     } else {
@@ -53,12 +55,14 @@ import com.google.android.exoplayer2.Timeline;
   }
   }
 
 
   @Override
   @Override
-  public int getPreviousWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode) {
+  public int getPreviousWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode,
+      boolean shuffleModeEnabled) {
     int childIndex = getChildIndexByWindowIndex(windowIndex);
     int childIndex = getChildIndexByWindowIndex(windowIndex);
     int firstWindowIndexInChild = getFirstWindowIndexByChildIndex(childIndex);
     int firstWindowIndexInChild = getFirstWindowIndexByChildIndex(childIndex);
     int previousWindowIndexInChild = getTimelineByChildIndex(childIndex).getPreviousWindowIndex(
     int previousWindowIndexInChild = getTimelineByChildIndex(childIndex).getPreviousWindowIndex(
         windowIndex - firstWindowIndexInChild,
         windowIndex - firstWindowIndexInChild,
-        repeatMode == Player.REPEAT_MODE_ALL ? Player.REPEAT_MODE_OFF : repeatMode);
+        repeatMode == Player.REPEAT_MODE_ALL ? Player.REPEAT_MODE_OFF : repeatMode,
+        shuffleModeEnabled);
     if (previousWindowIndexInChild != C.INDEX_UNSET) {
     if (previousWindowIndexInChild != C.INDEX_UNSET) {
       return firstWindowIndexInChild + previousWindowIndexInChild;
       return firstWindowIndexInChild + previousWindowIndexInChild;
     } else {
     } else {

library/core/src/main/java/com/google/android/exoplayer2/source/ConcatenatingMediaSource.java

@@ -198,19 +198,21 @@ public final class ConcatenatingMediaSource implements MediaSource {
     }
     }
 
 
     @Override
     @Override
-    public int getNextWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode) {
+    public int getNextWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode,
+        boolean shuffleModeEnabled) {
       if (isRepeatOneAtomic && repeatMode == Player.REPEAT_MODE_ONE) {
       if (isRepeatOneAtomic && repeatMode == Player.REPEAT_MODE_ONE) {
         repeatMode = Player.REPEAT_MODE_ALL;
         repeatMode = Player.REPEAT_MODE_ALL;
       }
       }
-      return super.getNextWindowIndex(windowIndex, repeatMode);
+      return super.getNextWindowIndex(windowIndex, repeatMode, shuffleModeEnabled);
     }
     }
 
 
     @Override
     @Override
-    public int getPreviousWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode) {
+    public int getPreviousWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode,
+        boolean shuffleModeEnabled) {
       if (isRepeatOneAtomic && repeatMode == Player.REPEAT_MODE_ONE) {
       if (isRepeatOneAtomic && repeatMode == Player.REPEAT_MODE_ONE) {
         repeatMode = Player.REPEAT_MODE_ALL;
         repeatMode = Player.REPEAT_MODE_ALL;
       }
       }
-      return super.getPreviousWindowIndex(windowIndex, repeatMode);
+      return super.getPreviousWindowIndex(windowIndex, repeatMode, shuffleModeEnabled);
     }
     }
 
 
     @Override
     @Override

library/core/src/main/java/com/google/android/exoplayer2/source/ForwardingTimeline.java

@@ -35,13 +35,25 @@ public abstract class ForwardingTimeline extends Timeline {
   }
   }
 
 
   @Override
   @Override
-  public int getNextWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode) {
-    return timeline.getNextWindowIndex(windowIndex, repeatMode);
+  public int getNextWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode,
+      boolean shuffleModeEnabled) {
+    return timeline.getNextWindowIndex(windowIndex, repeatMode, shuffleModeEnabled);
   }
   }
 
 
   @Override
   @Override
-  public int getPreviousWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode) {
-    return timeline.getPreviousWindowIndex(windowIndex, repeatMode);
+  public int getPreviousWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode,
+      boolean shuffleModeEnabled) {
+    return timeline.getPreviousWindowIndex(windowIndex, repeatMode, shuffleModeEnabled);
+  }
+
+  @Override
+  public int getLastWindowIndex(boolean shuffleModeEnabled) {
+    return timeline.getLastWindowIndex(shuffleModeEnabled);
+  }
+
+  @Override
+  public int getFirstWindowIndex(boolean shuffleModeEnabled) {
+    return timeline.getFirstWindowIndex(shuffleModeEnabled);
   }
   }
 
 
   @Override
   @Override

library/core/src/main/java/com/google/android/exoplayer2/source/LoopingMediaSource.java

@@ -167,14 +167,18 @@ public final class LoopingMediaSource implements MediaSource {
     }
     }
 
 
     @Override
     @Override
-    public int getNextWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode) {
-      int childNextWindowIndex = timeline.getNextWindowIndex(windowIndex, repeatMode);
+    public int getNextWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode,
+        boolean shuffleModeEnabled) {
+      int childNextWindowIndex = timeline.getNextWindowIndex(windowIndex, repeatMode,
+          shuffleModeEnabled);
       return childNextWindowIndex == C.INDEX_UNSET ? 0 : childNextWindowIndex;
       return childNextWindowIndex == C.INDEX_UNSET ? 0 : childNextWindowIndex;
     }
     }
 
 
     @Override
     @Override
-    public int getPreviousWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode) {
-      int childPreviousWindowIndex = timeline.getPreviousWindowIndex(windowIndex, repeatMode);
+    public int getPreviousWindowIndex(int windowIndex, @Player.RepeatMode int repeatMode,
+        boolean shuffleModeEnabled) {
+      int childPreviousWindowIndex = timeline.getPreviousWindowIndex(windowIndex, repeatMode,
+          shuffleModeEnabled);
       return childPreviousWindowIndex == C.INDEX_UNSET ? getWindowCount() - 1
       return childPreviousWindowIndex == C.INDEX_UNSET ? getWindowCount() - 1
           : childPreviousWindowIndex;
           : childPreviousWindowIndex;
     }
     }

library/hls/src/androidTest/java/com/google/android/exoplayer2/source/hls/offline/HlsDownloadTestData.java

+/*
+ * Copyright (C) 2017 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.source.hls.offline;
+
+import com.google.android.exoplayer2.util.ClosedSource;
+
+/**
+ * Data for HLS downloading tests.
+ */
+@ClosedSource(reason = "Not ready yet")
+/* package */ interface HlsDownloadTestData {
+
+  String MASTER_PLAYLIST_URI = "test.m3u8";
+
+  String MEDIA_PLAYLIST_0_DIR = "gear0/";
+  String MEDIA_PLAYLIST_0_URI = MEDIA_PLAYLIST_0_DIR + "prog_index.m3u8";
+  String MEDIA_PLAYLIST_1_DIR = "gear1/";
+  String MEDIA_PLAYLIST_1_URI = MEDIA_PLAYLIST_1_DIR + "prog_index.m3u8";
+  String MEDIA_PLAYLIST_2_DIR = "gear2/";
+  String MEDIA_PLAYLIST_2_URI = MEDIA_PLAYLIST_2_DIR + "prog_index.m3u8";
+  String MEDIA_PLAYLIST_3_DIR = "gear3/";
+  String MEDIA_PLAYLIST_3_URI = MEDIA_PLAYLIST_3_DIR + "prog_index.m3u8";
+
+  byte[] MASTER_PLAYLIST_DATA =
+      ("#EXTM3U\n"
+          + "#EXT-X-STREAM-INF:BANDWIDTH=232370,CODECS=\"mp4a.40.2, avc1.4d4015\"\n"
+          + MEDIA_PLAYLIST_1_URI + "\n"
+          + "#EXT-X-STREAM-INF:BANDWIDTH=649879,CODECS=\"mp4a.40.2, avc1.4d401e\"\n"
+          + MEDIA_PLAYLIST_2_URI + "\n"
+          + "#EXT-X-STREAM-INF:BANDWIDTH=991714,CODECS=\"mp4a.40.2, avc1.4d401e\"\n"
+          + MEDIA_PLAYLIST_3_URI + "\n"
+          + "#EXT-X-STREAM-INF:BANDWIDTH=41457,CODECS=\"mp4a.40.2\"\n"
+          + MEDIA_PLAYLIST_0_URI).getBytes();
+
+  byte[] MEDIA_PLAYLIST_DATA =
+      ("#EXTM3U\n"
+          + "#EXT-X-TARGETDURATION:10\n"
+          + "#EXT-X-VERSION:3\n"
+          + "#EXT-X-MEDIA-SEQUENCE:0\n"
+          + "#EXT-X-PLAYLIST-TYPE:VOD\n"
+          + "#EXTINF:9.97667,\n"
+          + "fileSequence0.ts\n"
+          + "#EXTINF:9.97667,\n"
+          + "fileSequence1.ts\n"
+          + "#EXTINF:9.97667,\n"
+          + "fileSequence2.ts\n"
+          + "#EXT-X-ENDLIST").getBytes();
+
+  String ENC_MEDIA_PLAYLIST_URI = "enc_index.m3u8";
+
+  byte[] ENC_MEDIA_PLAYLIST_DATA =
+      ("#EXTM3U\n"
+          + "#EXT-X-TARGETDURATION:10\n"
+          + "#EXT-X-VERSION:3\n"
+          + "#EXT-X-MEDIA-SEQUENCE:0\n"
+          + "#EXT-X-PLAYLIST-TYPE:VOD\n"
+          + "#EXT-X-KEY:METHOD=AES-128,URI=\"enc.key\"\n"
+          + "#EXTINF:9.97667,\n"
+          + "fileSequence0.ts\n"
+          + "#EXTINF:9.97667,\n"
+          + "fileSequence1.ts\n"
+          + "#EXT-X-KEY:METHOD=AES-128,URI=\"enc2.key\"\n"
+          + "#EXTINF:9.97667,\n"
+          + "fileSequence2.ts\n"
+          + "#EXT-X-ENDLIST").getBytes();
+
+}

library/hls/src/androidTest/java/com/google/android/exoplayer2/source/hls/offline/HlsDownloaderTest.java

+/*
+ * Copyright (C) 2017 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.source.hls.offline;
+
+import static com.google.android.exoplayer2.source.hls.offline.HlsDownloadTestData.ENC_MEDIA_PLAYLIST_DATA;
+import static com.google.android.exoplayer2.source.hls.offline.HlsDownloadTestData.ENC_MEDIA_PLAYLIST_URI;
+import static com.google.android.exoplayer2.source.hls.offline.HlsDownloadTestData.MASTER_PLAYLIST_DATA;
+import static com.google.android.exoplayer2.source.hls.offline.HlsDownloadTestData.MASTER_PLAYLIST_URI;
+import static com.google.android.exoplayer2.source.hls.offline.HlsDownloadTestData.MEDIA_PLAYLIST_0_DIR;
+import static com.google.android.exoplayer2.source.hls.offline.HlsDownloadTestData.MEDIA_PLAYLIST_0_URI;
+import static com.google.android.exoplayer2.source.hls.offline.HlsDownloadTestData.MEDIA_PLAYLIST_1_DIR;
+import static com.google.android.exoplayer2.source.hls.offline.HlsDownloadTestData.MEDIA_PLAYLIST_1_URI;
+import static com.google.android.exoplayer2.source.hls.offline.HlsDownloadTestData.MEDIA_PLAYLIST_2_DIR;
+import static com.google.android.exoplayer2.source.hls.offline.HlsDownloadTestData.MEDIA_PLAYLIST_2_URI;
+import static com.google.android.exoplayer2.source.hls.offline.HlsDownloadTestData.MEDIA_PLAYLIST_3_DIR;
+import static com.google.android.exoplayer2.source.hls.offline.HlsDownloadTestData.MEDIA_PLAYLIST_3_URI;
+import static com.google.android.exoplayer2.source.hls.offline.HlsDownloadTestData.MEDIA_PLAYLIST_DATA;
+import static com.google.android.exoplayer2.testutil.CacheAsserts.assertCacheEmpty;
+import static com.google.android.exoplayer2.testutil.CacheAsserts.assertCachedData;
+
+import android.net.Uri;
+import android.test.InstrumentationTestCase;
+import com.google.android.exoplayer2.offline.DownloaderConstructorHelper;
+import com.google.android.exoplayer2.source.hls.playlist.HlsMasterPlaylist;
+import com.google.android.exoplayer2.testutil.FakeDataSet;
+import com.google.android.exoplayer2.testutil.FakeDataSource.Factory;
+import com.google.android.exoplayer2.upstream.cache.NoOpCacheEvictor;
+import com.google.android.exoplayer2.upstream.cache.SimpleCache;
+import com.google.android.exoplayer2.util.ClosedSource;
+import com.google.android.exoplayer2.util.Util;
+import java.io.File;
+
+/** Unit tests for {@link HlsDownloader}. */
+@ClosedSource(reason = "Not ready yet")
+public class HlsDownloaderTest extends InstrumentationTestCase {
+
+  private SimpleCache cache;
+  private File tempFolder;
+  private FakeDataSet fakeDataSet;
+  private HlsDownloader hlsDownloader;
+
+  @Override
+  public void setUp() throws Exception {
+    super.setUp();
+    tempFolder = Util.createTempDirectory(getInstrumentation().getContext(), "ExoPlayerTest");
+    cache = new SimpleCache(tempFolder, new NoOpCacheEvictor());
+
+    fakeDataSet = new FakeDataSet()
+        .setData(MASTER_PLAYLIST_URI, MASTER_PLAYLIST_DATA)
+        .setData(MEDIA_PLAYLIST_1_URI, MEDIA_PLAYLIST_DATA)
+        .setRandomData(MEDIA_PLAYLIST_1_DIR + "fileSequence0.ts", 10)
+        .setRandomData(MEDIA_PLAYLIST_1_DIR + "fileSequence1.ts", 11)
+        .setRandomData(MEDIA_PLAYLIST_1_DIR + "fileSequence2.ts", 12)
+        .setData(MEDIA_PLAYLIST_2_URI, MEDIA_PLAYLIST_DATA)
+        .setRandomData(MEDIA_PLAYLIST_2_DIR + "fileSequence0.ts", 13)
+        .setRandomData(MEDIA_PLAYLIST_2_DIR + "fileSequence1.ts", 14)
+        .setRandomData(MEDIA_PLAYLIST_2_DIR + "fileSequence2.ts", 15);
+    hlsDownloader = getHlsDownloader(MASTER_PLAYLIST_URI);
+  }
+
+  @Override
+  public void tearDown() throws Exception {
+    Util.recursiveDelete(tempFolder);
+    super.tearDown();
+  }
+
+  public void testDownloadManifest() throws Exception {
+    HlsMasterPlaylist manifest = hlsDownloader.getManifest();
+
+    assertNotNull(manifest);
+    assertCachedData(cache, fakeDataSet, MASTER_PLAYLIST_URI);
+  }
+
+  public void testSelectRepresentationsClearsPreviousSelection() throws Exception {
+    hlsDownloader.selectRepresentations(new String[] {MEDIA_PLAYLIST_1_URI});
+    hlsDownloader.selectRepresentations(new String[] {MEDIA_PLAYLIST_2_URI});
+    hlsDownloader.download(null);
+
+    assertCachedData(cache, fakeDataSet, MASTER_PLAYLIST_URI, MEDIA_PLAYLIST_2_URI,
+        MEDIA_PLAYLIST_2_DIR + "fileSequence0.ts",
+        MEDIA_PLAYLIST_2_DIR + "fileSequence1.ts",
+        MEDIA_PLAYLIST_2_DIR + "fileSequence2.ts");
+  }
+
+  public void testCounterMethods() throws Exception {
+    hlsDownloader.selectRepresentations(new String[] {MEDIA_PLAYLIST_1_URI});
+    hlsDownloader.download(null);
+
+    assertEquals(4, hlsDownloader.getTotalSegments());
+    assertEquals(4, hlsDownloader.getDownloadedSegments());
+    assertEquals(MEDIA_PLAYLIST_DATA.length + 10 + 11 + 12, hlsDownloader.getDownloadedBytes());
+  }
+
+  public void testInitStatus() throws Exception {
+    hlsDownloader.selectRepresentations(new String[] {MEDIA_PLAYLIST_1_URI});
+    hlsDownloader.download(null);
+
+    HlsDownloader newHlsDownloader =
+        getHlsDownloader(MASTER_PLAYLIST_URI);
+    newHlsDownloader.selectRepresentations(new String[] {MEDIA_PLAYLIST_1_URI});
+    newHlsDownloader.init();
+
+    assertEquals(4, newHlsDownloader.getTotalSegments());
+    assertEquals(4, newHlsDownloader.getDownloadedSegments());
+    assertEquals(MEDIA_PLAYLIST_DATA.length + 10 + 11 + 12, newHlsDownloader.getDownloadedBytes());
+  }
+
+  public void testDownloadRepresentation() throws Exception {
+    hlsDownloader.selectRepresentations(new String[] {MEDIA_PLAYLIST_1_URI});
+    hlsDownloader.download(null);
+
+    assertCachedData(cache, fakeDataSet, MASTER_PLAYLIST_URI, MEDIA_PLAYLIST_1_URI,
+        MEDIA_PLAYLIST_1_DIR + "fileSequence0.ts",
+        MEDIA_PLAYLIST_1_DIR + "fileSequence1.ts",
+        MEDIA_PLAYLIST_1_DIR + "fileSequence2.ts");
+  }
+
+  public void testDownloadMultipleRepresentations() throws Exception {
+    hlsDownloader.selectRepresentations(new String[] {MEDIA_PLAYLIST_1_URI, MEDIA_PLAYLIST_2_URI});
+    hlsDownloader.download(null);
+
+    assertCachedData(cache, fakeDataSet);
+  }
+
+  public void testDownloadAllRepresentations() throws Exception {
+    // Add data for the rest of the playlists
+    fakeDataSet.setData(MEDIA_PLAYLIST_0_URI, MEDIA_PLAYLIST_DATA)
+        .setRandomData(MEDIA_PLAYLIST_0_DIR + "fileSequence0.ts", 10)
+        .setRandomData(MEDIA_PLAYLIST_0_DIR + "fileSequence1.ts", 11)
+        .setRandomData(MEDIA_PLAYLIST_0_DIR + "fileSequence2.ts", 12)
+        .setData(MEDIA_PLAYLIST_3_URI, MEDIA_PLAYLIST_DATA)
+        .setRandomData(MEDIA_PLAYLIST_3_DIR + "fileSequence0.ts", 13)
+        .setRandomData(MEDIA_PLAYLIST_3_DIR + "fileSequence1.ts", 14)
+        .setRandomData(MEDIA_PLAYLIST_3_DIR + "fileSequence2.ts", 15);
+    hlsDownloader = getHlsDownloader(MASTER_PLAYLIST_URI);
+
+    // hlsDownloader.selectRepresentations() isn't called
+    hlsDownloader.download(null);
+    assertCachedData(cache, fakeDataSet);
+    hlsDownloader.remove();
+
+    // select something random
+    hlsDownloader.selectRepresentations(new String[] {MEDIA_PLAYLIST_1_URI});
+    // clear selection
+    hlsDownloader.selectRepresentations(null);
+    hlsDownloader.download(null);
+    assertCachedData(cache, fakeDataSet);
+    hlsDownloader.remove();
+
+    hlsDownloader.selectRepresentations(new String[0]);
+    hlsDownloader.download(null);
+    assertCachedData(cache, fakeDataSet);
+    hlsDownloader.remove();
+  }
+
+  public void testRemoveAll() throws Exception {
+    hlsDownloader.selectRepresentations(new String[] {MEDIA_PLAYLIST_1_URI, MEDIA_PLAYLIST_2_URI});
+    hlsDownloader.download(null);
+    hlsDownloader.remove();
+
+    assertCacheEmpty(cache);
+  }
+
+  public void testDownloadMediaPlaylist() throws Exception {
+    hlsDownloader = getHlsDownloader(MEDIA_PLAYLIST_1_URI);
+    hlsDownloader.selectRepresentations(new String[] {MEDIA_PLAYLIST_1_URI});
+    hlsDownloader.download(null);
+
+    assertCachedData(cache, fakeDataSet, MEDIA_PLAYLIST_1_URI,
+        MEDIA_PLAYLIST_1_DIR + "fileSequence0.ts",
+        MEDIA_PLAYLIST_1_DIR + "fileSequence1.ts",
+        MEDIA_PLAYLIST_1_DIR + "fileSequence2.ts");
+  }
+
+  public void testDownloadEncMediaPlaylist() throws Exception {
+    fakeDataSet = new FakeDataSet()
+        .setData(ENC_MEDIA_PLAYLIST_URI, ENC_MEDIA_PLAYLIST_DATA)
+        .setRandomData("enc.key", 8)
+        .setRandomData("enc2.key", 9)
+        .setRandomData("fileSequence0.ts", 10)
+        .setRandomData("fileSequence1.ts", 11)
+        .setRandomData("fileSequence2.ts", 12);
+    hlsDownloader =
+        getHlsDownloader(ENC_MEDIA_PLAYLIST_URI);
+    hlsDownloader.selectRepresentations(new String[] {ENC_MEDIA_PLAYLIST_URI});
+    hlsDownloader.download(null);
+
+    assertCachedData(cache, fakeDataSet);
+  }
+
+  private HlsDownloader getHlsDownloader(String mediaPlaylistUri) {
+    Factory factory = new Factory(null).setFakeDataSet(fakeDataSet);
+    return new HlsDownloader(Uri.parse(mediaPlaylistUri),
+        new DownloaderConstructorHelper(cache, factory));
+  }
+
+}

library/hls/src/main/java/com/google/android/exoplayer2/source/hls/offline/HlsDownloadAction.java

+/*
+ * Copyright (C) 2017 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.source.hls.offline;
+
+import android.net.Uri;
+import com.google.android.exoplayer2.offline.DownloadAction;
+import com.google.android.exoplayer2.offline.DownloaderConstructorHelper;
+import com.google.android.exoplayer2.offline.SegmentDownloadAction;
+import com.google.android.exoplayer2.util.ClosedSource;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+/** An action to download or remove downloaded HLS streams. */
+@ClosedSource(reason = "Not ready yet")
+public final class HlsDownloadAction extends SegmentDownloadAction<String> {
+
+  public static final Deserializer DESERIALIZER = new SegmentDownloadActionDeserializer<String>() {
+
+    @Override
+    public String getType() {
+      return TYPE;
+    }
+
+    @Override
+    protected String readKey(DataInputStream input) throws IOException {
+      return input.readUTF();
+    }
+
+    @Override
+    protected String[] createKeyArray(int keyCount) {
+      return new String[0];
+    }
+
+    @Override
+    protected DownloadAction createDownloadAction(Uri manifestUri, boolean removeAction,
+        String[] keys) {
+      return new HlsDownloadAction(manifestUri, removeAction, keys);
+    }
+
+  };
+
+  private static final String TYPE = "HlsDownloadAction";
+
+  /** @see SegmentDownloadAction#SegmentDownloadAction(Uri, boolean, Object[]) */
+  public HlsDownloadAction(Uri manifestUri, boolean removeAction, String... keys) {
+    super(manifestUri, removeAction, keys);
+  }
+
+  @Override
+  public String getType() {
+    return TYPE;
+  }
+
+  @Override
+  public HlsDownloader createDownloader(DownloaderConstructorHelper constructorHelper)
+      throws IOException {
+    HlsDownloader downloader = new HlsDownloader(manifestUri, constructorHelper);
+    if (!isRemoveAction()) {
+      downloader.selectRepresentations(keys);
+    }
+    return downloader;
+  }
+
+  @Override
+  protected void writeKey(DataOutputStream output, String key) throws IOException {
+    output.writeUTF(key);
+  }
+
+}

library/hls/src/main/java/com/google/android/exoplayer2/source/hls/offline/HlsDownloader.java

+/*
+ * Copyright (C) 2017 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.source.hls.offline;
+
+import android.net.Uri;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.offline.DownloaderConstructorHelper;
+import com.google.android.exoplayer2.offline.SegmentDownloader;
+import com.google.android.exoplayer2.source.hls.playlist.HlsMasterPlaylist;
+import com.google.android.exoplayer2.source.hls.playlist.HlsMasterPlaylist.HlsUrl;
+import com.google.android.exoplayer2.source.hls.playlist.HlsMediaPlaylist;
+import com.google.android.exoplayer2.source.hls.playlist.HlsPlaylist;
+import com.google.android.exoplayer2.source.hls.playlist.HlsPlaylistParser;
+import com.google.android.exoplayer2.upstream.DataSource;
+import com.google.android.exoplayer2.upstream.DataSpec;
+import com.google.android.exoplayer2.upstream.ParsingLoadable;
+import com.google.android.exoplayer2.util.ClosedSource;
+import com.google.android.exoplayer2.util.UriUtil;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+
+/**
+ * Helper class to download HLS streams.
+ *
+ * A subset of renditions can be downloaded by selecting them using {@link
+ * #selectRepresentations(Object[])}. As key, string form of the rendition's url is used. The urls
+ * can be absolute or relative to the master playlist url.
+ */
+@ClosedSource(reason = "Not ready yet")
+public final class HlsDownloader extends SegmentDownloader<HlsMasterPlaylist, String> {
+
+  /**
+   * @see SegmentDownloader#SegmentDownloader(Uri, DownloaderConstructorHelper)
+   */
+  public HlsDownloader(Uri manifestUri, DownloaderConstructorHelper constructorHelper)  {
+    super(manifestUri, constructorHelper);
+  }
+
+  @Override
+  protected HlsMasterPlaylist getManifest(DataSource dataSource, Uri uri) throws IOException {
+    HlsPlaylist hlsPlaylist = loadManifest(dataSource, uri);
+    if (hlsPlaylist instanceof HlsMasterPlaylist) {
+      return (HlsMasterPlaylist) hlsPlaylist;
+    } else {
+      return HlsMasterPlaylist.createSingleVariantMasterPlaylist(hlsPlaylist.baseUri);
+    }
+  }
+
+  @Override
+  protected List<Segment> getAllSegments(DataSource dataSource, HlsMasterPlaylist manifest,
+      boolean allowIndexLoadErrors) throws InterruptedException, IOException {
+    ArrayList<String> urls = new ArrayList<>();
+    extractUrls(manifest.variants, urls);
+    extractUrls(manifest.audios, urls);
+    extractUrls(manifest.subtitles, urls);
+    return getSegments(dataSource, manifest, urls.toArray(new String[urls.size()]),
+        allowIndexLoadErrors);
+  }
+
+  @Override
+  protected List<Segment> getSegments(DataSource dataSource, HlsMasterPlaylist manifest,
+      String[] keys, boolean allowIndexLoadErrors) throws InterruptedException, IOException {
+    HashSet<Uri> encryptionKeyUris = new HashSet<>();
+    ArrayList<Segment> segments = new ArrayList<>();
+    for (String playlistUrl : keys) {
+      HlsMediaPlaylist mediaPlaylist = null;
+      Uri uri = UriUtil.resolveToUri(manifest.baseUri, playlistUrl);
+      try {
+        mediaPlaylist = (HlsMediaPlaylist) loadManifest(dataSource, uri);
+      } catch (IOException e) {
+        if (!allowIndexLoadErrors) {
+          throw e;
+        }
+      }
+      segments.add(new Segment(mediaPlaylist != null ? mediaPlaylist.startTimeUs : Long.MIN_VALUE,
+          new DataSpec(uri)));
+      if (mediaPlaylist == null) {
+        continue;
+      }
+
+      HlsMediaPlaylist.Segment initSegment = mediaPlaylist.initializationSegment;
+      if (initSegment != null) {
+        addSegment(segments, mediaPlaylist, initSegment, encryptionKeyUris);
+      }
+
+      List<HlsMediaPlaylist.Segment> hlsSegments = mediaPlaylist.segments;
+      for (int i = 0; i < hlsSegments.size(); i++) {
+        addSegment(segments, mediaPlaylist, hlsSegments.get(i), encryptionKeyUris);
+      }
+    }
+    return segments;
+  }
+
+  private HlsPlaylist loadManifest(DataSource dataSource, Uri uri) throws IOException {
+    DataSpec dataSpec = new DataSpec(uri,
+        DataSpec.FLAG_ALLOW_CACHING_UNKNOWN_LENGTH | DataSpec.FLAG_ALLOW_GZIP);
+    ParsingLoadable<HlsPlaylist> loadable = new ParsingLoadable<>(dataSource, dataSpec,
+        C.DATA_TYPE_MANIFEST, new HlsPlaylistParser());
+    loadable.load();
+    return loadable.getResult();
+  }
+
+  private static void addSegment(ArrayList<Segment> segments, HlsMediaPlaylist mediaPlaylist,
+      HlsMediaPlaylist.Segment hlsSegment, HashSet<Uri> encryptionKeyUris)
+      throws IOException, InterruptedException {
+    long startTimeUs = mediaPlaylist.startTimeUs + hlsSegment.relativeStartTimeUs;
+    if (hlsSegment.isEncrypted) {
+      Uri keyUri = UriUtil.resolveToUri(mediaPlaylist.baseUri, hlsSegment.encryptionKeyUri);
+      if (encryptionKeyUris.add(keyUri)) {
+        segments.add(new Segment(startTimeUs, new DataSpec(keyUri)));
+      }
+    }
+    Uri resolvedUri = UriUtil.resolveToUri(mediaPlaylist.baseUri, hlsSegment.url);
+    segments.add(new Segment(startTimeUs,
+        new DataSpec(resolvedUri, hlsSegment.byterangeOffset, hlsSegment.byterangeLength, null)));
+  }
+
+  private static void extractUrls(List<HlsUrl> hlsUrls, ArrayList<String> urls) {
+    for (int i = 0; i < hlsUrls.size(); i++) {
+      urls.add(hlsUrls.get(i).url);
+    }
+  }
+
+}

library/smoothstreaming/src/main/java/com/google/android/exoplayer2/source/smoothstreaming/offline/SsDownloadAction.java

+/*
+ * Copyright (C) 2017 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.source.smoothstreaming.offline;
+
+import android.net.Uri;
+import com.google.android.exoplayer2.offline.DownloadAction;
+import com.google.android.exoplayer2.offline.DownloaderConstructorHelper;
+import com.google.android.exoplayer2.offline.SegmentDownloadAction;
+import com.google.android.exoplayer2.source.smoothstreaming.manifest.TrackKey;
+import com.google.android.exoplayer2.util.ClosedSource;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+/** An action to download or remove downloaded SmoothStreaming streams. */
+@ClosedSource(reason = "Not ready yet")
+public final class SsDownloadAction extends SegmentDownloadAction<TrackKey> {
+
+  public static final Deserializer DESERIALIZER =
+      new SegmentDownloadActionDeserializer<TrackKey>() {
+
+    @Override
+    public String getType() {
+      return TYPE;
+    }
+
+    @Override
+    protected TrackKey readKey(DataInputStream input) throws IOException {
+      return new TrackKey(input.readInt(), input.readInt());
+    }
+
+    @Override
+    protected TrackKey[] createKeyArray(int keyCount) {
+      return new TrackKey[keyCount];
+    }
+
+    @Override
+    protected DownloadAction createDownloadAction(Uri manifestUri, boolean removeAction,
+        TrackKey[] keys) {
+      return new SsDownloadAction(manifestUri, removeAction, keys);
+    }
+
+  };
+
+  private static final String TYPE = "SsDownloadAction";
+
+  /** @see SegmentDownloadAction#SegmentDownloadAction(Uri, boolean, Object[]) */
+  public SsDownloadAction(Uri manifestUri, boolean removeAction, TrackKey... keys) {
+    super(manifestUri, removeAction, keys);
+  }
+
+  @Override
+  public String getType() {
+    return TYPE;
+  }
+
+  @Override
+  public SsDownloader createDownloader(DownloaderConstructorHelper constructorHelper)
+      throws IOException {
+    SsDownloader downloader = new SsDownloader(manifestUri, constructorHelper);
+    if (!isRemoveAction()) {
+      downloader.selectRepresentations(keys);
+    }
+    return downloader;
+  }
+
+  @Override
+  protected void writeKey(DataOutputStream output, TrackKey key) throws IOException {
+    output.writeInt(key.streamElementIndex);
+    output.writeInt(key.trackIndex);
+  }
+
+}

library/smoothstreaming/src/main/java/com/google/android/exoplayer2/source/smoothstreaming/offline/SsDownloader.java

+/*
+ * Copyright (C) 2017 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.source.smoothstreaming.offline;
+
+import android.net.Uri;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.offline.DownloaderConstructorHelper;
+import com.google.android.exoplayer2.offline.SegmentDownloader;
+import com.google.android.exoplayer2.source.smoothstreaming.manifest.SsManifest;
+import com.google.android.exoplayer2.source.smoothstreaming.manifest.SsManifest.StreamElement;
+import com.google.android.exoplayer2.source.smoothstreaming.manifest.SsManifestParser;
+import com.google.android.exoplayer2.source.smoothstreaming.manifest.TrackKey;
+import com.google.android.exoplayer2.upstream.DataSource;
+import com.google.android.exoplayer2.upstream.DataSpec;
+import com.google.android.exoplayer2.upstream.ParsingLoadable;
+import com.google.android.exoplayer2.util.ClosedSource;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Helper class to download SmoothStreaming streams.
+ *
+ * <p>Except {@link #getTotalSegments()}, {@link #getDownloadedSegments()} and {@link
+ * #getDownloadedBytes()}, this class isn't thread safe.
+ *
+ * <p>Example usage:
+ *
+ * <pre>
+ * {@code
+ * SimpleCache cache = new SimpleCache(downloadFolder, new NoOpCacheEvictor());
+ * DefaultHttpDataSourceFactory factory = new DefaultHttpDataSourceFactory("ExoPlayer", null);
+ * DownloaderConstructorHelper constructorHelper =
+ *     new DownloaderConstructorHelper(cache, factory);
+ * SsDownloader ssDownloader = new SsDownloader(manifestUrl, constructorHelper);
+ * // Select the first track of the first stream element
+ * ssDownloader.selectRepresentations(new TrackKey[] {new TrackKey(0, 0)});
+ * ssDownloader.download(new ProgressListener() {
+ *   @Override
+ *   public void onDownloadProgress(Downloader downloader, float downloadPercentage,
+ *       long downloadedBytes) {
+ *     // Invoked periodically during the download.
+ *   }
+ * });
+ * // Access downloaded data using CacheDataSource
+ * CacheDataSource cacheDataSource =
+ *     new CacheDataSource(cache, factory.createDataSource(), CacheDataSource.FLAG_BLOCK_ON_CACHE);}
+ * </pre>
+ */
+@ClosedSource(reason = "Not ready yet")
+public final class SsDownloader extends SegmentDownloader<SsManifest, TrackKey> {
+
+  /**
+   * @see SegmentDownloader#SegmentDownloader(Uri, DownloaderConstructorHelper)
+   */
+  public SsDownloader(Uri manifestUri, DownloaderConstructorHelper constructorHelper)  {
+    super(manifestUri, constructorHelper);
+  }
+
+  @Override
+  public SsManifest getManifest(DataSource dataSource, Uri uri) throws IOException {
+    DataSpec dataSpec = new DataSpec(uri,
+        DataSpec.FLAG_ALLOW_CACHING_UNKNOWN_LENGTH | DataSpec.FLAG_ALLOW_GZIP);
+    ParsingLoadable<SsManifest> loadable = new ParsingLoadable<>(dataSource, dataSpec,
+        C.DATA_TYPE_MANIFEST, new SsManifestParser());
+    loadable.load();
+    return loadable.getResult();
+  }
+
+  @Override
+  protected List<Segment> getAllSegments(DataSource dataSource, SsManifest manifest,
+      boolean allowIndexLoadErrors) throws InterruptedException, IOException {
+    ArrayList<Segment> segments = new ArrayList<>();
+    for (int i = 0; i < manifest.streamElements.length; i++) {
+      StreamElement streamElement = manifest.streamElements[i];
+      for (int j = 0; j < streamElement.formats.length; j++) {
+        segments.addAll(getSegments(dataSource, manifest, new TrackKey[] {new TrackKey(i, j)},
+            allowIndexLoadErrors));
+      }
+    }
+    return segments;
+  }
+
+  @Override
+  protected List<Segment> getSegments(DataSource dataSource, SsManifest manifest,
+      TrackKey[] keys, boolean allowIndexLoadErrors) throws InterruptedException, IOException {
+    ArrayList<Segment> segments = new ArrayList<>();
+    for (TrackKey key : keys) {
+      StreamElement streamElement = manifest.streamElements[key.streamElementIndex];
+      for (int i = 0; i < streamElement.chunkCount; i++) {
+        segments.add(new Segment(streamElement.getStartTimeUs(i),
+            new DataSpec(streamElement.buildRequestUri(key.trackIndex, i))));
+      }
+    }
+    return segments;
+  }
+
+}

library/ui/src/main/java/com/google/android/exoplayer2/ui/PlaybackControlView.java

@@ -675,9 +675,11 @@ public class PlaybackControlView extends FrameLayout {
       timeline.getWindow(windowIndex, window);
       timeline.getWindow(windowIndex, window);
       isSeekable = window.isSeekable;
       isSeekable = window.isSeekable;
       enablePrevious = isSeekable || !window.isDynamic
       enablePrevious = isSeekable || !window.isDynamic
-          || timeline.getPreviousWindowIndex(windowIndex, player.getRepeatMode()) != C.INDEX_UNSET;
+          || timeline.getPreviousWindowIndex(windowIndex, player.getRepeatMode(), false)
+              != C.INDEX_UNSET;
       enableNext = window.isDynamic
       enableNext = window.isDynamic
-          || timeline.getNextWindowIndex(windowIndex, player.getRepeatMode()) != C.INDEX_UNSET;
+          || timeline.getNextWindowIndex(windowIndex, player.getRepeatMode(), false)
+              != C.INDEX_UNSET;
       if (player.isPlayingAd()) {
       if (player.isPlayingAd()) {
         // Always hide player controls during ads.
         // Always hide player controls during ads.
         hide();
         hide();
@@ -861,7 +863,8 @@ public class PlaybackControlView extends FrameLayout {
     }
     }
     int windowIndex = player.getCurrentWindowIndex();
     int windowIndex = player.getCurrentWindowIndex();
     timeline.getWindow(windowIndex, window);
     timeline.getWindow(windowIndex, window);
-    int previousWindowIndex = timeline.getPreviousWindowIndex(windowIndex, player.getRepeatMode());
+    int previousWindowIndex = timeline.getPreviousWindowIndex(windowIndex, player.getRepeatMode(),
+        false);
     if (previousWindowIndex != C.INDEX_UNSET
     if (previousWindowIndex != C.INDEX_UNSET
         && (player.getCurrentPosition() <= MAX_POSITION_FOR_SEEK_TO_PREVIOUS
         && (player.getCurrentPosition() <= MAX_POSITION_FOR_SEEK_TO_PREVIOUS
         || (window.isDynamic && !window.isSeekable))) {
         || (window.isDynamic && !window.isSeekable))) {
@@ -877,7 +880,7 @@ public class PlaybackControlView extends FrameLayout {
       return;
       return;
     }
     }
     int windowIndex = player.getCurrentWindowIndex();
     int windowIndex = player.getCurrentWindowIndex();
-    int nextWindowIndex = timeline.getNextWindowIndex(windowIndex, player.getRepeatMode());
+    int nextWindowIndex = timeline.getNextWindowIndex(windowIndex, player.getRepeatMode(), false);
     if (nextWindowIndex != C.INDEX_UNSET) {
     if (nextWindowIndex != C.INDEX_UNSET) {
       seekTo(nextWindowIndex, C.TIME_UNSET);
       seekTo(nextWindowIndex, C.TIME_UNSET);
     } else if (timeline.getWindow(windowIndex, window, false).isDynamic) {
     } else if (timeline.getWindow(windowIndex, window, false).isDynamic) {

playbacktests/src/androidTest/java/com/google/android/exoplayer2/playbacktests/gts/DashDownloadTest.java

+/*
+ * Copyright (C) 2017 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.playbacktests.gts;
+
+import android.net.Uri;
+import android.test.ActivityInstrumentationTestCase2;
+import com.google.android.exoplayer2.offline.Downloader;
+import com.google.android.exoplayer2.offline.Downloader.ProgressListener;
+import com.google.android.exoplayer2.offline.DownloaderConstructorHelper;
+import com.google.android.exoplayer2.source.dash.manifest.AdaptationSet;
+import com.google.android.exoplayer2.source.dash.manifest.DashManifest;
+import com.google.android.exoplayer2.source.dash.manifest.Representation;
+import com.google.android.exoplayer2.source.dash.manifest.RepresentationKey;
+import com.google.android.exoplayer2.source.dash.offline.DashDownloader;
+import com.google.android.exoplayer2.testutil.HostActivity;
+import com.google.android.exoplayer2.upstream.DefaultHttpDataSourceFactory;
+import com.google.android.exoplayer2.upstream.DummyDataSource;
+import com.google.android.exoplayer2.upstream.cache.CacheDataSource;
+import com.google.android.exoplayer2.upstream.cache.CacheDataSourceFactory;
+import com.google.android.exoplayer2.upstream.cache.NoOpCacheEvictor;
+import com.google.android.exoplayer2.upstream.cache.SimpleCache;
+import com.google.android.exoplayer2.util.ClosedSource;
+import com.google.android.exoplayer2.util.Util;
+import java.io.File;
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Tests downloaded DASH playbacks.
+ */
+@ClosedSource(reason = "Not ready yet")
+public final class DashDownloadTest extends ActivityInstrumentationTestCase2<HostActivity> {
+
+  private static final String TAG = "DashDownloadTest";
+
+  private DashTestRunner testRunner;
+  private File tempFolder;
+  private SimpleCache cache;
+
+  public DashDownloadTest() {
+    super(HostActivity.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    testRunner = new DashTestRunner(TAG, getActivity(), getInstrumentation())
+        .setManifestUrl(DashTestData.H264_MANIFEST)
+        .setFullPlaybackNoSeeking(true)
+        .setCanIncludeAdditionalVideoFormats(false)
+        .setAudioVideoFormats(DashTestData.AAC_AUDIO_REPRESENTATION_ID,
+            DashTestData.H264_CDD_FIXED);
+    tempFolder = Util.createTempDirectory(getActivity(), "ExoPlayerTest");
+    cache = new SimpleCache(tempFolder, new NoOpCacheEvictor());
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    testRunner = null;
+    Util.recursiveDelete(tempFolder);
+    cache = null;
+    super.tearDown();
+  }
+
+  // Download tests
+
+  public void testDownload() throws Exception {
+    if (Util.SDK_INT < 16) {
+      return; // Pass.
+    }
+
+    // Download manifest only
+    createDashDownloader(false).getManifest();
+    long manifestLength = cache.getCacheSpace();
+
+    // Download representations
+    DashDownloader dashDownloader = downloadContent(false, Float.NaN);
+    assertEquals(cache.getCacheSpace() - manifestLength, dashDownloader.getDownloadedBytes());
+
+    testRunner.setStreamName("test_h264_fixed_download").
+        setDataSourceFactory(newOfflineCacheDataSourceFactory()).run();
+
+    dashDownloader.remove();
+
+    assertEquals("There should be no content left.", 0, cache.getKeys().size());
+    assertEquals("There should be no content left.", 0, cache.getCacheSpace());
+  }
+
+  public void testPartialDownload() throws Exception {
+    if (Util.SDK_INT < 16) {
+      return; // Pass.
+    }
+
+    // Just download the first half and manifest
+    downloadContent(false, 0.5f);
+
+    // Download the rest
+    DashDownloader dashDownloader = downloadContent(false, Float.NaN);
+    long downloadedBytes = dashDownloader.getDownloadedBytes();
+
+    // Make sure it doesn't download any data
+    dashDownloader = downloadContent(true, Float.NaN);
+    assertEquals(downloadedBytes, dashDownloader.getDownloadedBytes());
+
+    testRunner.setStreamName("test_h264_fixed_partial_download")
+        .setDataSourceFactory(newOfflineCacheDataSourceFactory()).run();
+  }
+
+  private DashDownloader downloadContent(boolean offline, float stopAt) throws Exception {
+    DashDownloader dashDownloader = createDashDownloader(offline);
+    DashManifest dashManifest = dashDownloader.getManifest();
+    try {
+      ArrayList<RepresentationKey> keys = new ArrayList<>();
+      for (int pIndex = 0; pIndex < dashManifest.getPeriodCount(); pIndex++) {
+        List<AdaptationSet> adaptationSets = dashManifest.getPeriod(pIndex).adaptationSets;
+        for (int aIndex = 0; aIndex < adaptationSets.size(); aIndex++) {
+          AdaptationSet adaptationSet = adaptationSets.get(aIndex);
+          List<Representation> representations = adaptationSet.representations;
+          for (int rIndex = 0; rIndex < representations.size(); rIndex++) {
+            String id = representations.get(rIndex).format.id;
+            if (DashTestData.AAC_AUDIO_REPRESENTATION_ID.equals(id)
+                || DashTestData.H264_CDD_FIXED.equals(id)) {
+              keys.add(new RepresentationKey(pIndex, aIndex, rIndex));
+            }
+          }
+        }
+        dashDownloader.selectRepresentations(keys.toArray(new RepresentationKey[keys.size()]));
+        TestProgressListener listener = new TestProgressListener(stopAt);
+        dashDownloader.download(listener);
+      }
+    } catch (InterruptedException e) {
+      // do nothing
+    } catch (IOException e) {
+      Throwable exception = e;
+      while (!(exception instanceof InterruptedIOException)) {
+        if (exception == null) {
+          throw e;
+        }
+        exception = exception.getCause();
+      }
+      // else do nothing
+    }
+    return dashDownloader;
+  }
+
+  private DashDownloader createDashDownloader(boolean offline) {
+    DownloaderConstructorHelper constructorHelper = new DownloaderConstructorHelper(cache,
+        offline ? DummyDataSource.FACTORY : new DefaultHttpDataSourceFactory("ExoPlayer", null));
+    return new DashDownloader(Uri.parse(DashTestData.H264_MANIFEST), constructorHelper);
+  }
+
+  private CacheDataSourceFactory newOfflineCacheDataSourceFactory() {
+    return new CacheDataSourceFactory(cache, DummyDataSource.FACTORY,
+        CacheDataSource.FLAG_BLOCK_ON_CACHE);
+  }
+
+  private static class TestProgressListener implements ProgressListener {
+
+    private float stopAt;
+
+    private TestProgressListener(float stopAt) {
+      this.stopAt = stopAt;
+    }
+
+    @Override
+    public void onDownloadProgress(Downloader downloader, float downloadPercentage,
+        long downloadedBytes) {
+      System.out.printf("onDownloadProgress downloadPercentage = [%g], downloadedData = [%d]%n",
+          downloadPercentage, downloadedBytes);
+      if (downloadPercentage >= stopAt) {
+        Thread.currentThread().interrupt();
+      }
+    }
+
+  }
+
+}

testutils/src/main/java/com/google/android/exoplayer2/testutil/TimelineAsserts.java

@@ -74,7 +74,7 @@ public final class TimelineAsserts {
       @Player.RepeatMode int repeatMode, int... expectedPreviousWindowIndices) {
       @Player.RepeatMode int repeatMode, int... expectedPreviousWindowIndices) {
     for (int i = 0; i < timeline.getWindowCount(); i++) {
     for (int i = 0; i < timeline.getWindowCount(); i++) {
       assertEquals(expectedPreviousWindowIndices[i],
       assertEquals(expectedPreviousWindowIndices[i],
-          timeline.getPreviousWindowIndex(i, repeatMode));
+          timeline.getPreviousWindowIndex(i, repeatMode, false));
     }
     }
   }
   }
 
 
@@ -86,14 +86,14 @@ public final class TimelineAsserts {
       int... expectedNextWindowIndices) {
       int... expectedNextWindowIndices) {
     for (int i = 0; i < timeline.getWindowCount(); i++) {
     for (int i = 0; i < timeline.getWindowCount(); i++) {
       assertEquals(expectedNextWindowIndices[i],
       assertEquals(expectedNextWindowIndices[i],
-          timeline.getNextWindowIndex(i, repeatMode));
+          timeline.getNextWindowIndex(i, repeatMode, false));
     }
     }
   }
   }
 
 
   /**
   /**
    * Asserts that period counts for each window are set correctly. Also asserts that
    * Asserts that period counts for each window are set correctly. Also asserts that
    * {@link Window#firstPeriodIndex} and {@link Window#lastPeriodIndex} are set correctly, and it
    * {@link Window#firstPeriodIndex} and {@link Window#lastPeriodIndex} are set correctly, and it
-   * asserts the correct behavior of {@link Timeline#getNextWindowIndex(int, int)}.
+   * asserts the correct behavior of {@link Timeline#getNextWindowIndex(int, int, boolean)}.
    */
    */
   public static void assertPeriodCounts(Timeline timeline, int... expectedPeriodCounts) {
   public static void assertPeriodCounts(Timeline timeline, int... expectedPeriodCounts) {
     int windowCount = timeline.getWindowCount();
     int windowCount = timeline.getWindowCount();
@@ -119,16 +119,19 @@ public final class TimelineAsserts {
       }
       }
       assertEquals(expectedWindowIndex, period.windowIndex);
       assertEquals(expectedWindowIndex, period.windowIndex);
       if (i < accumulatedPeriodCounts[expectedWindowIndex + 1] - 1) {
       if (i < accumulatedPeriodCounts[expectedWindowIndex + 1] - 1) {
-        assertEquals(i + 1, timeline.getNextPeriodIndex(i, period, window, Player.REPEAT_MODE_OFF));
-        assertEquals(i + 1, timeline.getNextPeriodIndex(i, period, window, Player.REPEAT_MODE_ONE));
-        assertEquals(i + 1, timeline.getNextPeriodIndex(i, period, window, Player.REPEAT_MODE_ALL));
+        assertEquals(i + 1, timeline.getNextPeriodIndex(i, period, window, Player.REPEAT_MODE_OFF,
+            false));
+        assertEquals(i + 1, timeline.getNextPeriodIndex(i, period, window, Player.REPEAT_MODE_ONE,
+            false));
+        assertEquals(i + 1, timeline.getNextPeriodIndex(i, period, window, Player.REPEAT_MODE_ALL,
+            false));
       } else {
       } else {
         int nextWindowOff = timeline.getNextWindowIndex(expectedWindowIndex,
         int nextWindowOff = timeline.getNextWindowIndex(expectedWindowIndex,
-            Player.REPEAT_MODE_OFF);
+            Player.REPEAT_MODE_OFF, false);
         int nextWindowOne = timeline.getNextWindowIndex(expectedWindowIndex,
         int nextWindowOne = timeline.getNextWindowIndex(expectedWindowIndex,
-            Player.REPEAT_MODE_ONE);
+            Player.REPEAT_MODE_ONE, false);
         int nextWindowAll = timeline.getNextWindowIndex(expectedWindowIndex,
         int nextWindowAll = timeline.getNextWindowIndex(expectedWindowIndex,
-            Player.REPEAT_MODE_ALL);
+            Player.REPEAT_MODE_ALL, false);
         int nextPeriodOff = nextWindowOff == C.INDEX_UNSET ? C.INDEX_UNSET
         int nextPeriodOff = nextWindowOff == C.INDEX_UNSET ? C.INDEX_UNSET
             : accumulatedPeriodCounts[nextWindowOff];
             : accumulatedPeriodCounts[nextWindowOff];
         int nextPeriodOne = nextWindowOne == C.INDEX_UNSET ? C.INDEX_UNSET
         int nextPeriodOne = nextWindowOne == C.INDEX_UNSET ? C.INDEX_UNSET
@@ -136,11 +139,11 @@ public final class TimelineAsserts {
         int nextPeriodAll = nextWindowAll == C.INDEX_UNSET ? C.INDEX_UNSET
         int nextPeriodAll = nextWindowAll == C.INDEX_UNSET ? C.INDEX_UNSET
             : accumulatedPeriodCounts[nextWindowAll];
             : accumulatedPeriodCounts[nextWindowAll];
         assertEquals(nextPeriodOff, timeline.getNextPeriodIndex(i, period, window,
         assertEquals(nextPeriodOff, timeline.getNextPeriodIndex(i, period, window,
-            Player.REPEAT_MODE_OFF));
+            Player.REPEAT_MODE_OFF, false));
         assertEquals(nextPeriodOne, timeline.getNextPeriodIndex(i, period, window,
         assertEquals(nextPeriodOne, timeline.getNextPeriodIndex(i, period, window,
-            Player.REPEAT_MODE_ONE));
+            Player.REPEAT_MODE_ONE, false));
         assertEquals(nextPeriodAll, timeline.getNextPeriodIndex(i, period, window,
         assertEquals(nextPeriodAll, timeline.getNextPeriodIndex(i, period, window,
-            Player.REPEAT_MODE_ALL));
+            Player.REPEAT_MODE_ALL, false));
       }
       }
     }
     }
   }
   }