package com.android.camera.widget;
|
|
import android.widget.AbsListView;
|
|
import com.android.camera.debug.Log;
|
|
import java.util.Collections;
|
import java.util.List;
|
import java.util.Queue;
|
import java.util.concurrent.LinkedBlockingQueue;
|
|
/**
|
* Responsible for controlling preloading logic. Intended usage is for ListViews that
|
* benefit from initiating a load before the row appear on screen.
|
* @param <T> The type of items this class preload.
|
* @param <Y> The type of load tokens that can be used to cancel loads for the items this class
|
* preloads.
|
*/
|
public class Preloader<T, Y> implements AbsListView.OnScrollListener {
|
private static final Log.Tag TAG = new Log.Tag("Preloader");
|
|
/**
|
* Implemented by the source for items that should be preloaded.
|
*/
|
public interface ItemSource<T> {
|
/**
|
* Returns the objects in the range [startPosition; endPosition).
|
*/
|
public List<T> getItemsInRange(int startPosition, int endPosition);
|
|
/**
|
* Returns the total number of items in the source.
|
*/
|
public int getCount();
|
}
|
|
/**
|
* Responsible for the loading of items.
|
*/
|
public interface ItemLoader<T, Y> {
|
/**
|
* Initiates a load for the specified items and returns a list of 0 or more load tokens that
|
* can be used to cancel the loads for the given items. Should preload the items in the list
|
* order,preloading the 0th item in the list fist.
|
*/
|
public List<Y> preloadItems(List<T> items);
|
|
/**
|
* Cancels all of the loads represented by the given load tokens.
|
*/
|
public void cancelItems(List<Y> loadTokens);
|
}
|
|
private final int mMaxConcurrentPreloads;
|
|
/**
|
* Keep track of the largest/smallest item we requested (depending on scroll direction) so
|
* we don't preload the same items repeatedly. Without this var, scrolling down we preload
|
* 0-5, then 1-6 etc. Using this we instead preload 0-5, then 5-6, 6-7 etc.
|
*/
|
private int mLastEnd = -1;
|
private int mLastStart;
|
|
private final int mLoadAheadItems;
|
private ItemSource<T> mItemSource;
|
private ItemLoader<T, Y> mItemLoader;
|
private Queue<List<Y>> mItemLoadTokens = new LinkedBlockingQueue<List<Y>>();
|
|
private int mLastVisibleItem;
|
private boolean mScrollingDown = false;
|
|
public Preloader(int loadAheadItems, ItemSource<T> itemSource, ItemLoader<T, Y> itemLoader) {
|
mItemSource = itemSource;
|
mItemLoader = itemLoader;
|
mLoadAheadItems = loadAheadItems;
|
// Add an additional item so we don't cancel a preload before we start a real load.
|
mMaxConcurrentPreloads = loadAheadItems + 1;
|
}
|
|
/**
|
* Initiates a pre load.
|
*
|
* @param first The source position to load from
|
* @param increasing The direction we're going in (increasing -> source positions are
|
* increasing -> we're scrolling down the list)
|
*/
|
private void preload(int first, boolean increasing) {
|
final int start;
|
final int end;
|
if (increasing) {
|
start = Math.max(first, mLastEnd);
|
end = Math.min(first + mLoadAheadItems, mItemSource.getCount());
|
} else {
|
start = Math.max(0, first - mLoadAheadItems);
|
end = Math.min(first, mLastStart);
|
}
|
|
Log.v(TAG, "preload first=" + first + " increasing=" + increasing + " start=" + start +
|
" end=" + end);
|
|
mLastEnd = end;
|
mLastStart = start;
|
|
if (start == 0 && end == 0) {
|
return;
|
}
|
|
final List<T> items = mItemSource.getItemsInRange(start, end);
|
if (!increasing) {
|
Collections.reverse(items);
|
}
|
registerLoadTokens(mItemLoader.preloadItems(items));
|
}
|
|
private void registerLoadTokens(List<Y> loadTokens) {
|
mItemLoadTokens.offer(loadTokens);
|
// We pretend that one batch of load tokens corresponds to one item in the list. This isn't
|
// strictly true because we may batch preload multiple items at once when we first start
|
// scrolling in the list or change the direction we're scrolling in. In those cases, we will
|
// have a single large batch of load tokens for multiple items, and then go back to getting
|
// one batch per item as we continue to scroll. This means we may not cancel as many
|
// preloads as we expect when we change direction, but we can at least be sure we won't
|
// cancel preloads for items we still care about. We can't be more precise here because
|
// there is no guarantee that there is a one to one relationship between load tokens
|
// and list items.
|
if (mItemLoadTokens.size() > mMaxConcurrentPreloads) {
|
final List<Y> loadTokensToCancel = mItemLoadTokens.poll();
|
mItemLoader.cancelItems(loadTokensToCancel);
|
}
|
}
|
|
public void cancelAllLoads() {
|
for (List<Y> loadTokens : mItemLoadTokens) {
|
mItemLoader.cancelItems(loadTokens);
|
}
|
mItemLoadTokens.clear();
|
}
|
|
@Override
|
public void onScrollStateChanged(AbsListView absListView, int i) {
|
// Do nothing.
|
}
|
|
@Override
|
public void onScroll(AbsListView absListView, int firstVisible, int visibleItemCount,
|
int totalItemCount) {
|
boolean wasScrollingDown = mScrollingDown;
|
int preloadStart = -1;
|
if (firstVisible > mLastVisibleItem) {
|
// Scrolling list down
|
mScrollingDown = true;
|
preloadStart = firstVisible + visibleItemCount;
|
} else if (firstVisible < mLastVisibleItem) {
|
// Scrolling list Up
|
mScrollingDown = false;
|
preloadStart = firstVisible;
|
}
|
|
if (wasScrollingDown != mScrollingDown) {
|
// If we've changed directions, we don't care about any of our old preloads, so cancel
|
// all of them.
|
cancelAllLoads();
|
}
|
|
// onScroll can be called multiple times with the same arguments, so we only want to preload
|
// if we've actually scrolled at least an item in either direction.
|
if (preloadStart != -1) {
|
preload(preloadStart, mScrollingDown);
|
}
|
|
mLastVisibleItem = firstVisible;
|
}
|
}
|
