Paging Library源碼淺析
首先仍是放上官方文檔地址:developer.android.google.cn/topic/libra…html
若是你還不知道這個庫是能夠作什麼事,能夠看官方文檔事例或者參考我以前寫的這篇文章:android
目前該庫還處於測試階段,因此我就按上篇文章的內容進行部分簡單的源碼分析,從中你應該能夠了解到該庫的設計思路.bash
直接進入正題,先寫簡單的demo,首先建立咱們的model.網絡
MainData:多線程
public class MainData extends AndroidViewModel {
/**
* 每次須要10個數據.
*/
private static final int NEED_NUMBER = 10;
/**
* 福利第一頁.
*/
private static final int PAGE_FIRST = 1;
/**
* 分頁.
*/
private int mPage = PAGE_FIRST;
/**
* 列表數據.
*/
private LiveData<PagedList<GankData>> mDataLiveData;
public MainData(@NonNull Application application) {
super(application);
}
public LiveData<PagedList<GankData>> getDataLiveData() {
initPageList();
return mDataLiveData;
}
/**
* 初始化pageList.
*/
private void initPageList() {
//獲取dataSource,列表數據都從這裏獲取,
final DataSource<Integer, GankData> tiledDataSource = new TiledDataSource<GankData>() {
/**
* 須要的總個數,若是數量不定,就傳COUNT_UNDEFINED.
*/
@Override
public int countItems() {
return DataSource.COUNT_UNDEFINED;
}
/**
* 返回須要加載的數據.
* 這裏是在線程異步中執行的,因此咱們能夠同步請求數據而且返回
* @param startPosition 如今第幾個數據
* @param count 加載的數據數量
*/
@Override
public List<GankData> loadRange(int startPosition, int count) {
List<GankData> gankDataList = new ArrayList<>();
//這裏咱們用retrofit獲取數據,每次獲取十條數據,數量不爲空,則讓mPage+1
try {
Response<BaseResponse<List<GankData>>> execute = RetrofitApi.getInstance().mRetrofit.create(AppService.class)
.getWelfare1(mPage, NEED_NUMBER).execute();
gankDataList.addAll(execute.body().getResults());
if (!gankDataList.isEmpty()) {
mPage++;
}
} catch (IOException e) {
e.printStackTrace();
}
return gankDataList;
}
};
//這裏咱們建立LiveData<PagedList<GankData>>數據,
mDataLiveData = new LivePagedListProvider<Integer, GankData>() {
@Override
protected DataSource<Integer, GankData> createDataSource() {
return tiledDataSource;
}
}.create(0, new PagedList.Config.Builder()
.setPageSize(NEED_NUMBER) //每次加載的數據數量
//距離本頁數據幾個時候開始加載下一頁數據(例如如今加載10個數據,設置prefetchDistance爲2,則滑到第八個數據時候開始加載下一頁數據).
.setPrefetchDistance(NEED_NUMBER)
//這裏設置是否設置PagedList中的佔位符,若是設置爲true,咱們的數據數量必須固定,因爲網絡數據數量不固定,因此設置false.
.setEnablePlaceholders(false)
.build());
}
}複製代碼
這裏咱們須要建立LiveData<PagedList<GankData>>這個對象,對於LiveData以前已經講過了,若是你還不知道這個原理,能夠去看下我以前文章:juejin.im/post/5a03ed…app
首先咱們來看下PageList究竟是什麼:首先PageList是個抽象類,而且提供Build模式填充數據,首先看下它的build類:異步
public static class Builder<Key, Value> {
private DataSource<Key, Value> mDataSource;
private Executor mMainThreadExecutor;
private Executor mBackgroundThreadExecutor;
private Config mConfig;
private Key mInitialKey;
/**
* Creates a {@link PagedList} with the given parameters.
* <p>
* This call will initial data and perform any counting needed to initialize the PagedList,
* therefore it should only be called on a worker thread.
* <p>
* While build() will always return a PagedList, it's important to note that the PagedList * initial load may fail to acquire data from the DataSource. This can happen for example if * the DataSource is invalidated during its initial load. If this happens, the PagedList * will be immediately {@link PagedList#isDetached() detached}, and you can retry * construction (including setting a new DataSource). * * @return The newly constructed PagedList */ @WorkerThread @NonNull public PagedList<Value> build() { if (mDataSource == null) { throw new IllegalArgumentException("DataSource required"); } if (mMainThreadExecutor == null) { throw new IllegalArgumentException("MainThreadExecutor required"); } if (mBackgroundThreadExecutor == null) { throw new IllegalArgumentException("BackgroundThreadExecutor required"); } if (mConfig == null) { throw new IllegalArgumentException("Config required"); } return PagedList.create( mDataSource, mMainThreadExecutor, mBackgroundThreadExecutor, mConfig, mInitialKey); }複製代碼
這裏咱們看到必須填的數據有至少有四個,第一個DataSource,不用說,本身手動要建立的,兩個線程池,一個Config和一個key,咱們再來看下Config:async
public static class Config {
final int mPageSize;
final int mPrefetchDistance;
final boolean mEnablePlaceholders;
final int mInitialLoadSizeHint;
private Config(int pageSize, int prefetchDistance,
boolean enablePlaceholders, int initialLoadSizeHint) {
mPageSize = pageSize;
mPrefetchDistance = prefetchDistance;
mEnablePlaceholders = enablePlaceholders;
mInitialLoadSizeHint = initialLoadSizeHint;
}
/**
* Builder class for {@link Config}.
* <p>
* You must at minimum specify page size with {@link #setPageSize(int)}.
*/
public static class Builder {
private int mPageSize = -1;
private int mPrefetchDistance = -1;
private int mInitialLoadSizeHint = -1;
private boolean mEnablePlaceholders = true;
/**
* Creates a {@link Config} with the given parameters.
*
* @return A new Config.
*/
public Config build() {
if (mPageSize < 1) {
throw new IllegalArgumentException("Page size must be a positive number");
}
if (mPrefetchDistance < 0) {
mPrefetchDistance = mPageSize;
}
if (mInitialLoadSizeHint < 0) {
mInitialLoadSizeHint = mPageSize * 3;
}
if (!mEnablePlaceholders && mPrefetchDistance == 0) {
throw new IllegalArgumentException("Placeholders and prefetch are the only ways"
+ " to trigger loading of more data in the PagedList, so either"
+ " placeholders must be enabled, or prefetch distance must be > 0.");
}
return new Config(mPageSize, mPrefetchDistance,
mEnablePlaceholders, mInitialLoadSizeHint);
}
}複製代碼
這裏一樣採用Build模式,看下參數:mPageSize表明每次加載數量,mPrefetchDistance表明距離最後多少item數量開始加載下一頁,mInittialLoadSizeHint表明首次加載數量(可是須要配合KeyedDataSource,咱們如今用TiledDataSource,因此忽略這個屬性),mEnablePlaceholders表明是否設置null佔位符,須要加載固定數量時候能夠設置爲true,若是數量不固定則設爲false.ide
由於後面涉及到DataSource,因此咱們接下來先分析TiledDataSource.
TiledDataSource的父類DataSource.
// Since we currently rely on implementation details of two implementations,
// prevent external subclassing, except through exposed subclasses
DataSource() {
}
/**
* 數量不定的標誌.
*/
@SuppressWarnings("WeakerAccess")
public static int COUNT_UNDEFINED = -1;
/**
* 總數量(數量不定返回COUNT_UNDEFINED).
*/
@WorkerThread
public abstract int countItems();
/**
* Returns true if the data source guaranteed to produce a contiguous set of items,
* never producing gaps.
*/
abstract boolean isContiguous();
/**
* Invalidation callback for DataSource.
* <p>
* Used to signal when a DataSource a data source has become invalid, and that a new data source
* is needed to continue loading data.
*/
public interface InvalidatedCallback {
/**
* Called when the data backing the list has become invalid. This callback is typically used
* to signal that a new data source is needed.
* <p>
* This callback will be invoked on the thread that calls {@link #invalidate()}. It is valid
* for the data source to invalidate itself during its load methods, or for an outside
* source to invalidate it.
*/
@AnyThread
void onInvalidated();
}
/**
* 數據可用的標誌.
*/
private AtomicBoolean mInvalid = new AtomicBoolean(false);
/**
* 回調的線程安全集合.
*/
private CopyOnWriteArrayList<InvalidatedCallback> mOnInvalidatedCallbacks =
new CopyOnWriteArrayList<>();
/**
* Add a callback to invoke when the DataSource is first invalidated.
* <p>
* Once invalidated, a data source will not become valid again.
* <p>
* A data source will only invoke its callbacks once - the first time {@link #invalidate()}
* is called, on that thread.
*
* @param onInvalidatedCallback The callback, will be invoked on thread that
* {@link #invalidate()} is called on.
*/
@AnyThread
@SuppressWarnings("WeakerAccess")
public void addInvalidatedCallback(InvalidatedCallback onInvalidatedCallback) {
mOnInvalidatedCallbacks.add(onInvalidatedCallback);
}
/**
* Remove a previously added invalidate callback.
*
* @param onInvalidatedCallback The previously added callback.
*/
@AnyThread
@SuppressWarnings("WeakerAccess")
public void removeInvalidatedCallback(InvalidatedCallback onInvalidatedCallback) {
mOnInvalidatedCallbacks.remove(onInvalidatedCallback);
}
/**
* 對外方法,執行回調(可是未發現任何地方調用了這個方法,估計是爲了之後擴展用).
*/
@AnyThread
public void invalidate() {
if (mInvalid.compareAndSet(false, true)) {
for (InvalidatedCallback callback : mOnInvalidatedCallbacks) {
callback.onInvalidated();
}
}
}
/**
* Returns true if the data source is invalid, and can no longer be queried for data.
*
* @return True if the data source is invalid, and can no longer return data.
*/
@WorkerThread
public boolean isInvalid() {
return mInvalid.get();
}複製代碼
這裏須要先說下AtomicBoolean和CopyOrWriteArrayList,
AtomicBoolean:按照文檔說明,大概意思就是以原子的方式更新bollean值,其中
- compareAndSet(boolean expect, boolean update)這個方法,
- 這個方法主要兩個做用 1. 比較AtomicBoolean和expect的值，若是一致，執行方法內的語句。其實就是一個if語句 2. 把AtomicBoolean的值設成update 比較最要的是這兩件事是一鼓作氣的，這連個動做之間不會被打斷，任何內部或者外部的語句都不可能在兩個動做之間運行。爲多線程的控制提供瞭解決的方案。
CopyOrWriteArrayList是一個線程安全的list,它的 add和remove等一些方法都是加鎖了.
再來看下TiledDataSource:
public abstract class TiledDataSource<Type> extends DataSource<Integer, Type> {
@WorkerThread
@Override
public abstract int countItems();
@Override
boolean isContiguous() {
return false;
}
@WorkerThread
public abstract List<Type> loadRange(int startPosition, int count);
final List<Type> loadRangeWrapper(int startPosition, int count) {
if (isInvalid()) {
return null;
}
List<Type> list = loadRange(startPosition, count);
if (isInvalid()) {
return null;
}
return list;
}
ContiguousDataSource<Integer, Type> getAsContiguous() {
return new TiledAsBoundedDataSource<>(this);
}
/**
* BoundedDataSource是最終繼承ContiguousDataSource的類,這個負責包裝TiledDataSource.
*/
static class TiledAsBoundedDataSource<Value> extends BoundedDataSource<Value> {
final TiledDataSource<Value> mTiledDataSource;
TiledAsBoundedDataSource(TiledDataSource<Value> tiledDataSource) {
mTiledDataSource = tiledDataSource;
}
@WorkerThread
@Nullable
@Override
public List<Value> loadRange(int startPosition, int loadCount) {
return mTiledDataSource.loadRange(startPosition, loadCount);
}
}
}複製代碼
loadRange方法咱們用不到暫時(沒發現調用這個方法的地方),咱們只須要實現countItems和loadRange方法,咱們例子中是無限制數量,因此傳了-1,而loadRange方法是在異步線程中執行,因此這裏能夠用網絡同步請求返回數據.
而後接下來看PagedList的create方法.
@NonNull
private static <K, T> PagedList<T> create(@NonNull DataSource<K, T> dataSource,
@NonNull Executor mainThreadExecutor,
@NonNull Executor backgroundThreadExecutor,
@NonNull Config config,
@Nullable K key) {
if (dataSource.isContiguous() || !config.mEnablePlaceholders) {
if (!dataSource.isContiguous()) {
//noinspection unchecked
dataSource = (DataSource<K, T>) ((TiledDataSource<T>) dataSource).getAsContiguous();
}
ContiguousDataSource<K, T> contigDataSource = (ContiguousDataSource<K, T>) dataSource;
return new ContiguousPagedList<>(contigDataSource,
mainThreadExecutor,
backgroundThreadExecutor,
config,
key);
} else {
return new TiledPagedList<>((TiledDataSource<T>) dataSource,
mainThreadExecutor,
backgroundThreadExecutor,
config,
(key != null) ? (Integer) key : 0);
}
}
複製代碼
根據一系列條件,咱們獲取的PagedList是ContiguousPagedList.
而後咱們能夠來看LiveData<PagedList<GankData>>是怎麼建立的了:
來看下LivePagedListProvider:
public abstract class LivePagedListProvider<Key, Value> {
/**
* Construct a new data source to be wrapped in a new PagedList, which will be returned
* through the LiveData.
*
* @return The data source.
*/
@WorkerThread
protected abstract DataSource<Key, Value> createDataSource();
/**
* Creates a LiveData of PagedLists, given the page size.
* <p>
* This LiveData can be passed to a {@link PagedListAdapter} to be displayed with a
* {@link android.support.v7.widget.RecyclerView}.
*
* @param initialLoadKey Initial key used to load initial data from the data source.
* @param pageSize Page size defining how many items are loaded from a data source at a time.
* Recommended to be multiple times the size of item displayed at once.
*
* @return The LiveData of PagedLists.
*/
@AnyThread
@NonNull
public LiveData<PagedList<Value>> create(@Nullable Key initialLoadKey, int pageSize) {
return create(initialLoadKey,
new PagedList.Config.Builder()
.setPageSize(pageSize)
.build());
}
/**
* Creates a LiveData of PagedLists, given the PagedList.Config.
* <p>
* This LiveData can be passed to a {@link PagedListAdapter} to be displayed with a
* {@link android.support.v7.widget.RecyclerView}.
*
* @param initialLoadKey Initial key to pass to the data source to initialize data with.
* @param config PagedList.Config to use with created PagedLists. This specifies how the
* lists will load data.
*
* @return The LiveData of PagedLists.
*/
@AnyThread
@NonNull
public LiveData<PagedList<Value>> create(@Nullable final Key initialLoadKey,
final PagedList.Config config) {
return new ComputableLiveData<PagedList<Value>>() {
@Nullable
private PagedList<Value> mList;
@Nullable
private DataSource<Key, Value> mDataSource;
private final DataSource.InvalidatedCallback mCallback =
new DataSource.InvalidatedCallback() {
@Override
public void onInvalidated() {
invalidate();
}
};
@Override
protected PagedList<Value> compute() {
@Nullable Key initializeKey = initialLoadKey;
if (mList != null) {
//noinspection unchecked
initializeKey = (Key) mList.getLastKey();
}
do {
if (mDataSource != null) {
mDataSource.removeInvalidatedCallback(mCallback);
}
mDataSource = createDataSource();
mDataSource.addInvalidatedCallback(mCallback);
mList = new PagedList.Builder<Key, Value>()
.setDataSource(mDataSource)
.setMainThreadExecutor(ArchTaskExecutor.getMainThreadExecutor())
.setBackgroundThreadExecutor(
ArchTaskExecutor.getIOThreadExecutor())
.setConfig(config)
.setInitialKey(initializeKey)
.build();
} while (mList.isDetached());
return mList;
}
}.getLiveData();
}
複製代碼
代碼很簡單(忽略那些mCallback,現階段徹底用不到),只要咱們重寫傳入DataSource,建立的主要類是ComputableLiveData幹得,看一下:
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
public abstract class ComputableLiveData<T> {
private final LiveData<T> mLiveData;
private AtomicBoolean mInvalid = new AtomicBoolean(true);
private AtomicBoolean mComputing = new AtomicBoolean(false);
/**
* Creates a computable live data which is computed when there are active observers.
* <p>
* It can also be invalidated via {@link #invalidate()} which will result in a call to
* {@link #compute()} if there are active observers (or when they start observing)
*/
@SuppressWarnings("WeakerAccess")
public ComputableLiveData() {
mLiveData = new LiveData<T>() {
@Override
protected void onActive() {
// TODO if we make this class public, we should accept an executor
ArchTaskExecutor.getInstance().executeOnDiskIO(mRefreshRunnable);
}
};
}
/**
* Returns the LiveData managed by this class.
*
* @return A LiveData that is controlled by ComputableLiveData.
*/
@SuppressWarnings("WeakerAccess")
@NonNull
public LiveData<T> getLiveData() {
return mLiveData;
}
/**
* mInvalid默認爲true,這裏能夠一條線執行下去,PagedList就是上面那個compute裏新建的對象,
* 而且執行了postValue方法,觀察者那邊能夠就收到通知了.
*/
@VisibleForTesting
final Runnable mRefreshRunnable = new Runnable() {
@WorkerThread
@Override
public void run() {
boolean computed;
do {
computed = false;
// compute can happen only in 1 thread but no reason to lock others.
if (mComputing.compareAndSet(false, true)) {
// as long as it is invalid, keep computing.
try {
T value = null;
while (mInvalid.compareAndSet(true, false)) {
computed = true;
value = compute();
}
if (computed) {
mLiveData.postValue(value);
}
} finally {
// release compute lock
mComputing.set(false);
}
}
// check invalid after releasing compute lock to avoid the following scenario.
// Thread A runs compute()
// Thread A checks invalid, it is false
// Main thread sets invalid to true
// Thread B runs, fails to acquire compute lock and skips
// Thread A releases compute lock
// We've left invalid in set state. The check below recovers. } while (computed && mInvalid.get()); } }; // invalidation check always happens on the main thread @VisibleForTesting final Runnable mInvalidationRunnable = new Runnable() { @MainThread @Override public void run() { boolean isActive = mLiveData.hasActiveObservers(); if (mInvalid.compareAndSet(false, true)) { if (isActive) { // TODO if we make this class public, we should accept an executor. ArchTaskExecutor.getInstance().executeOnDiskIO(mRefreshRunnable); } } } }; } 複製代碼
代碼也是很簡單的,先看構造方法,構造方法中直接新建了LiveData,而且在生命週期onStrart後執行mRefreshRunable線程,這個線程直接給LiveData賦值,而後activity註冊的地方就能夠收到PagedList的回調了.
咱們再來看看構造PagedList的默認線程池,追蹤代碼:
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
public class DefaultTaskExecutor extends TaskExecutor {
private final Object mLock = new Object();
private ExecutorService mDiskIO = Executors.newFixedThreadPool(2);
@Nullable
private volatile Handler mMainHandler;
@Override
public void executeOnDiskIO(Runnable runnable) {
mDiskIO.execute(runnable);
}
@Override
public void postToMainThread(Runnable runnable) {
if (mMainHandler == null) {
synchronized (mLock) {
if (mMainHandler == null) {
mMainHandler = new Handler(Looper.getMainLooper());
}
}
}
//noinspection ConstantConditions
mMainHandler.post(runnable);
}
@Override
public boolean isMainThread() {
return Looper.getMainLooper().getThread() == Thread.currentThread();
}
}
複製代碼
就是這個Executors.newFixedThreadPool(2)線程池了,
接下來咱們看PagedList:
public abstract class PagedListAdapter<T, VH extends RecyclerView.ViewHolder>
extends RecyclerView.Adapter<VH> {
private final PagedListAdapterHelper<T> mHelper;
/**
* Creates a PagedListAdapter with default threading and
* {@link android.support.v7.util.ListUpdateCallback}.
*
* Convenience for {@link #PagedListAdapter(ListAdapterConfig)}, which uses default threading
* behavior.
*
* @param diffCallback The {@link DiffCallback} instance to compare items in the list.
*/
protected PagedListAdapter(@NonNull DiffCallback<T> diffCallback) {
mHelper = new PagedListAdapterHelper<>(this, diffCallback);
}
@SuppressWarnings("unused, WeakerAccess")
protected PagedListAdapter(@NonNull ListAdapterConfig<T> config) {
mHelper = new PagedListAdapterHelper<>(new ListAdapterHelper.AdapterCallback(this), config);
}
/**
* Set the new list to be displayed.
* <p>
* If a list is already being displayed, a diff will be computed on a background thread, which
* will dispatch Adapter.notifyItem events on the main thread.
*
* @param pagedList The new list to be displayed.
*/
public void setList(PagedList<T> pagedList) {
mHelper.setList(pagedList);
}
@Nullable
protected T getItem(int position) {
return mHelper.getItem(position);
}
@Override
public int getItemCount() {
return mHelper.getItemCount();
}
/**
* Returns the list currently being displayed by the Adapter.
* <p>
* This is not necessarily the most recent list passed to {@link #setList(PagedList)}, because a
* diff is computed asynchronously between the new list and the current list before updating the
* currentList value.
*
* @return The list currently being displayed.
*/
@Nullable
public PagedList<T> getCurrentList() {
return mHelper.getCurrentList();
}
}複製代碼
能夠看到，PagedListAdapter只是個殼，作事的是PagedListAdapterHelper.
咱們主要看PagedListAdapterHelper的這個幾個方法：
public void setList(final PagedList<T> pagedList) {
if (pagedList != null) {
if (mList == null) {
mIsContiguous = pagedList.isContiguous();
} else {
if (pagedList.isContiguous() != mIsContiguous) {
throw new IllegalArgumentException("AdapterHelper cannot handle both contiguous"
+ " and non-contiguous lists.");
}
}
}
if (pagedList == mList) {
// nothing to do
return;
}
// incrementing generation means any currently-running diffs are discarded when they finish
final int runGeneration = ++mMaxScheduledGeneration;
if (pagedList == null) {
mUpdateCallback.onRemoved(0, mList.size());
mList.removeWeakCallback(mPagedListCallback);
mList = null;
return;
}
if (mList == null) {
// fast simple first insert
mUpdateCallback.onInserted(0, pagedList.size());
mList = pagedList;
pagedList.addWeakCallback(null, mPagedListCallback);
return;
}
if (!mList.isImmutable()) {
// first update scheduled on this list, so capture mPages as a snapshot, removing
// callbacks so we don't have resolve updates against a moving target mList.removeWeakCallback(mPagedListCallback); mList = (PagedList<T>) mList.snapshot(); } final PagedList<T> oldSnapshot = mList; final List<T> newSnapshot = pagedList.snapshot(); mUpdateScheduled = true; mConfig.getBackgroundThreadExecutor().execute(new Runnable() { @Override public void run() { final DiffUtil.DiffResult result; if (mIsContiguous) { result = ContiguousDiffHelper.computeDiff( (NullPaddedList<T>) oldSnapshot, (NullPaddedList<T>) newSnapshot, mConfig.getDiffCallback(), true); } else { result = SparseDiffHelper.computeDiff( (PageArrayList<T>) oldSnapshot, (PageArrayList<T>) newSnapshot, mConfig.getDiffCallback(), true); } mConfig.getMainThreadExecutor().execute(new Runnable() { @Override public void run() { if (mMaxScheduledGeneration == runGeneration) { mUpdateScheduled = false; latchPagedList(pagedList, newSnapshot, result); } } }); } }); } private void latchPagedList( PagedList<T> newList, List<T> diffSnapshot, DiffUtil.DiffResult diffResult) { if (mIsContiguous) { ContiguousDiffHelper.dispatchDiff(mUpdateCallback, (NullPaddedList<T>) mList, (ContiguousPagedList<T>) newList, diffResult); } else { SparseDiffHelper.dispatchDiff(mUpdateCallback, diffResult); } mList = newList; newList.addWeakCallback((PagedList<T>) diffSnapshot, mPagedListCallback); }複製代碼
這個理解成給adapter設置集合，理論上設置一次，這裏對於屢次設置集合作了刷新的比較處理。這裏仍是用到了RecylerView的 DifffUtil工具.
固然這個庫的主要功能是在未滑倒底部時候就進行數據加載，讓用戶無感知加載，這個處理方法就在getItem(int index)裏：
@SuppressWarnings("WeakerAccess")
@Nullable
public T getItem(int index) {
if (mList == null) {
throw new IndexOutOfBoundsException("Item count is zero, getItem() call is invalid");
}
mList.loadAround(index);
return mList.get(index);
}複製代碼
recyclerView滑動加載到第幾個數據時候就會調用adapter的getItem方法，經過判斷當前加載的index位置，還有用戶設置的預加載位置，從而進行提早加載數據。這裏調用的是PagedList的loadAround方法，如今咱們去找這個方法的實如今哪：
ContiguousPageList:
@Override
public void loadAround(int index) {
mLastLoad = index + mPositionOffset;
int prependItems = mConfig.mPrefetchDistance - (index - mLeadingNullCount);
int appendItems = index + mConfig.mPrefetchDistance - (mLeadingNullCount + mList.size());
mPrependItemsRequested = Math.max(prependItems, mPrependItemsRequested);
if (mPrependItemsRequested > 0) {
schedulePrepend();
}
mAppendItemsRequested = Math.max(appendItems, mAppendItemsRequested);
if (mAppendItemsRequested > 0) {
scheduleAppend();
}
}
@MainThread
private void schedulePrepend() {
if (mPrependWorkerRunning) {
return;
}
mPrependWorkerRunning = true;
final int position = mLeadingNullCount + mPositionOffset;
final T item = mList.get(0);
mBackgroundThreadExecutor.execute(new Runnable() {
@Override
public void run() {
if (mDetached.get()) {
return;
}
final List<T> data = mDataSource.loadBefore(position, item, mConfig.mPageSize);
if (data != null) {
mMainThreadExecutor.execute(new Runnable() {
@Override
public void run() {
if (mDetached.get()) {
return;
}
prependImpl(data);
}
});
} else {
detach();
}
}
});
}
@MainThread
private void prependImpl(List<T> before) {
final int count = before.size();
if (count == 0) {
// Nothing returned from source, stop loading in this direction
return;
}
Collections.reverse(before);
mList.addAll(0, before);
final int changedCount = Math.min(mLeadingNullCount, count);
final int addedCount = count - changedCount;
if (changedCount != 0) {
mLeadingNullCount -= changedCount;
}
mPositionOffset -= addedCount;
mNumberPrepended += count;
// only try to post more work after fully prepended (with offsets / null counts updated)
mPrependItemsRequested -= count;
mPrependWorkerRunning = false;
if (mPrependItemsRequested > 0) {
// not done prepending, keep going
schedulePrepend();
}
// finally dispatch callbacks, after prepend may have already been scheduled
for (WeakReference<Callback> weakRef : mCallbacks) {
Callback callback = weakRef.get();
if (callback != null) {
if (changedCount != 0) {
callback.onChanged(mLeadingNullCount, changedCount);
}
if (addedCount != 0) {
callback.onInserted(0, addedCount);
}
}
}
}
複製代碼
因爲咱們傳入的是TiledDataSource,因此這些mDataSource的loadBefore和loadAfter等最終都調用了TiledDataSource的loadRange方法。
到這裏爲止,好像總體流程已經分析完了,總體流程就看這張圖吧:
首先Recyclerview設置PagedListAdater,PagedListAdapter設置對應的PagedList,每次adapter getItme就讓PagedList知道用戶已經滑到第幾個item,PagedList計算這些數量以及設置的各類條件,條件達成就通知DataSource,讓其返回數據,數據返回成功,通知PagedListAdapter,讓其使用進行高效刷新.
目前該庫仍是測試階段,裏面還有方法回調都未被用到,本文只是簡單分析下源碼流程,不過也貌似打開了一些新的思路.
因爲本人水平也不高,文中也有很多理解錯誤之處,也但願能各位指教,一塊兒學習,一塊兒進步.
相關文章
- 1. Paging Library使用及原理
- 2. Vuex2.0源碼淺析
- 3. Tornado源碼淺析
- 4. Axios源碼淺析
- 5. 淺析Struts2.5.2源碼
- 6. AFNetworking源碼淺析
- 7. 淺析Redux源碼
- 8. Koa源碼淺析
- 9. Semaphore 源碼淺析
- 10. MyBatis源碼淺析
- 更多相關文章...
- • Docker 資源彙總 - Docker教程
- • Java操作Neo4j數據庫（附帶源碼） - NoSQL教程
- • 互聯網組織的未來：剖析GitHub員工的任性之源
- • Java Agent入門實戰（二）-Instrumentation源碼概述
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. js中 charCodeAt
- 2. Android中通過ViewHelper.setTranslationY實現View移動控制（NineOldAndroids開源項目）
- 3. 【Android】日常記錄：BottomNavigationView自定義樣式，修改點擊後圖片
- 4. maya 文件檢查 ui和數據分離 （一）
- 5. eclipse 修改項目的jdk版本
- 6. Android InputMethod設置
- 7. Simulink中Bus Selector出現很多? ? ?
- 8. 【Openfire筆記】啓動Mac版Openfire時提示「系統偏好設置錯誤」
- 9. AutoPLP在偏好標籤中的生產與應用
- 10. 數據庫關閉的四種方式
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Paging Library使用及原理
- 2. Vuex2.0源碼淺析
- 3. Tornado源碼淺析
- 4. Axios源碼淺析
- 5. 淺析Struts2.5.2源碼
- 6. AFNetworking源碼淺析
- 7. 淺析Redux源碼
- 8. Koa源碼淺析
- 9. Semaphore 源碼淺析
- 10. MyBatis源碼淺析