首先當然是引出要解決的需求，在做一個IM模組時UI是這樣的：上面是水平的聯絡人欄，下面是聊天介面，可以水平滑動切換聯絡人聊天，也就是說是RecyclerView與Viewpager的聯動，為了切換時體驗好需要左右兩邊預載入多個聯絡人的聊天內容，使用者收到新訊息時當前聊天頁變成第一頁(Viewpager頁面要無閃爍或滑動)頂欄頭像移動到第一個，刪除聊天時移除當前聊天頁其他快取的頁不變動，不閃爍，也就是說頁面位置發生變化時已有快取頁的要用快取而不是銷燬重建，大體UI請看圖：
簡書上有朋友讓我寫個demo出來給他，這不今天抽時間寫了 ：
1. 要實現的幾個功能點：
- ViewPager中Fragment多少個不固定，需要動態新增，刪除頁面。
- 更新頁面(Fragment)，使用已有的快取頁面。
- 移動頁面(Fragment)位置，使用已預載入的快取頁面。
問題：
- 呼叫notifyDataSetChanged並沒有去更新內容。
- 新增，刪除，移動頁面後會錯位，position與Fragment對不上。
2. 誤區
在網上搜尋會發現，更新ViewPager的方法基本都是說在apdater的getItemPosition()方法裡返回POSITION_NONE，這確實會更新，但也會導致所有頁面被銷燬重建，會出現閃爍等問題，效能上也會不太好。
3. 原理
要做到動態的更新，新增，刪除ViewPager的資料，我們需要先弄清ViewPager+adapter是怎麼管理頁面的，首先我假設看此文的你已經熟悉了PagerAdapter的各方法作用，如果沒有的話還請先去查一下，這裡以FragmentStatePagerAdapter為例，當呼叫adapter的notifyDataSetChanged後會通知到viewpager檢查更新資料：
void dataSetChanged() {
...
for (int i = 0; i < mItems.size(); i++) {
final ItemInfo ii = mItems.get(i);
final int newPos = mAdapter.getItemPosition(ii.object);
if (newPos == PagerAdapter.POSITION_UNCHANGED) {
continue;
}
if (newPos == PagerAdapter.POSITION_NONE) {
mItems.remove(i);
i--;
if (!isUpdating) {
mAdapter.startUpdate(this);
isUpdating = true;
}
mAdapter.destroyItem(this, ii.position, ii.object);
needPopulate = true;
if (mCurItem == ii.position) {
// Keep the current item in the valid range
newCurrItem = Math.max(0, Math.min(mCurItem, adapterCount - 1));
needPopulate = true;
}
continue;
}
if (ii.position != newPos) {
if (ii.position == mCurItem) {
// Our current item changed position. Follow it.
newCurrItem = newPos;
}
ii.position = newPos;
needPopulate = true;
}
}
...
Collections.sort(mItems, COMPARATOR);
...
}
...
static class ItemInfo {
Object object;
int position;
boolean scrolling;
float widthFactor;
float offset;
}
複製程式碼上面是ViewPager dataSetChanged方法裡的一段程式碼，可以看到ViewPager會遍歷它快取的Item集合，詢問(mAdapter.getItemPosition)Adapter每一個Item是刪除了(POSITION_NONE)，還是更新了位置(ii.position != newPos)，還是沒變化(POSITION_UNCHANGED)，然後對mItems集合根據新賦值的position進行重新排序。 接下來根據我們返回的答案進行操作，如果是沒變則不做更改，也就是不會更新內容(PagerAdapter中的getItemPosition預設是直接返回POSITION_NONE，所以呼叫notifyDataSetChanged預設情況下是不會更新的)，如果是刪除了則從mItems集合中刪除並讓adapter也刪除( mAdapter.destroyItem)，如果是更新了位置則根據位置的變化對頁面進行更新,會重新佈局(requestLayout)。而在ViewPaer的onLayout方法裡會遍歷每個子view然後呼叫infoForChild()方法從mItems裡找到每個子view對應的itemInfo：
ItemInfo infoForChild(View child) {
for (int i = 0; i < mItems.size(); i++) {
ItemInfo ii = mItems.get(i);
if (mAdapter.isViewFromObject(child, ii.object)) {
return ii;
}
}
return null;
}
複製程式碼看上面程式碼我們知道是通過mAdapter.isViewFromObject()來判斷某個ViewPager的子view到底對應的是哪個Fragment的rootView的，所以我們一般在adapter的isViewFromObject方法中會這麼寫：
public boolean isViewFromObject(View view, Object object) {
return ((Fragment)object).getView() == view;
}
複製程式碼這樣就把第幾頁要顯示哪個fragment的view對應上了，在onlayout時通過子view位置與itemInfo中的offset(相當於偏移到第幾頁)完成了按順序排列頁面。
從上面的分析我們知道了adapter的getItemPosition()其實我們不僅僅只可以返回POSITION_NONE與POSITION_UNCHANGED還可以根據我們的需要返回一個更新adapter資料後的新位置
總結一下，ViewPager更新過程分為這幾步：
- adapter呼叫notifyDataSetChanged，ViewPager開始檢測更新.
- 通過adapter相應的方法詢問出ViewPager中快取的頁面在新資料中的更改情況。
- 有更新的話重新調整佈局中View的位置。
4. 處理問題1
弄清理了原理，那麼解決問題1了：我們需要在Viewpager詢問時告訴ViewPagerItem有哪些變化：
- 快取中某個位置的資料是否與新資料一樣
- 快取老資料在新資料中的位置
處理方式參考了此文：FragmentPagerAdapter 和 FragmentStatePagerAdapter 的資料更新問題
public abstract class FixedPagerAdapter<T> extends FragmentStatePagerAdapter {
private List<ItemObject> mCurrentItems = new ArrayList<>();
public FixedPagerAdapter(FragmentManager fragmentManager) {
super(fragmentManager);
}
@Override
public Object instantiateItem(ViewGroup container, int position) {
while (mCurrentItems.size() <= position) {
mCurrentItems.add(null);
}
Fragment fragment = (Fragment) super.instantiateItem(container, position);
ItemObject object = new ItemObject(fragment, getItemData(position));
mCurrentItems.set(position, object);
return object;
}
@Override
public void destroyItem(ViewGroup container, int position, Object object) {
mCurrentItems.set(position, null);
super.destroyItem(container, position, ((ItemObject) object).fragment);
}
@Override
public int getItemPosition(Object object) {
ItemObject itemObject = (ItemObject) object;
if (mCurrentItems.contains(itemObject)) {
T oldData = itemObject.t;
int oldPosition = mCurrentItems.indexOf(itemObject);
T newData = getItemData(oldPosition);
if (equals(oldData, newData)) {
return POSITION_UNCHANGED;
} else {
int newPosition = getDataPosition(oldData);
return newPosition >= 0 ? newPosition : POSITION_NONE;
}
}
return POSITION_UNCHANGED;
}
@Override
public void setPrimaryItem(ViewGroup container, int position, Object object) {
super.setPrimaryItem(container, position, ((ItemObject) object).fragment);
}
@Override
public boolean isViewFromObject(View view, Object object) {
return super.isViewFromObject(view, ((ItemObject) object).fragment);
}
public abstract T getItemData(int position);
public abstract int getDataPosition(T t);
public abstract boolean equals(T oldD, T newD);
public class ItemObject {
public Fragment fragment;
public T t;
public ItemObject(Fragment fragment, T t) {
this.fragment = fragment;
this.t = t;
}
}
}
複製程式碼在Adapter中對當前ViewPger中快取的頁面資料進行了儲存，然後通過三個抽象方法進行對比：getItemData() ，getDataPosition(),equals()，使用時只需要新建一個Adapter類繼承FixedPagerAdapter完成抽象方法的實現。
這樣做後更新確實沒問題了，比較科學，不會閃爍，全部銷燬，但別忘了我們還要動態的新增，刪除，移動位置，這時如果只是這麼處理就會導致頁面錯位問題
原因就是當你新增，刪除，移動頁面時ViewPager是通過getItemPosition方法對它的快取集合進行了對應處理，但我們的FixedPagerAdapter中的快取並沒有做刪除，增加位置，排序。
5. 處理問題2
- 對FragmentStatePagerAdapter的原始碼進行修改，建立一個OpenFragmentStatePagerAdapter類，把原來快取的Fragment List變成快取我們自己的ItemInfo，ItemInfo中儲存了3個資料 ：fragment，資料和頁面所處的位置。
- 在instantiateItem ，destroyItem 時對List中的ItemInfo進行增加，刪除，在getItemPosition時對list中ItemInfo的position按新資料的位置進行賦值。
- 在notifyDataSetChanged後和instantiateItem獲取快取的ItemInfo發現位置不對時進行快取list的排序，增加等調整。
具體請看程式碼，重要位置寫了註釋：
/**
* Created by homgwu on 2018/4/2 14:29.
*/
public abstract class OpenFragmentStatePagerAdapter<T> extends PagerAdapter {
private static final String TAG = "FragmentStatePagerAdapt";
private static final boolean DEBUG = false;
private final FragmentManager mFragmentManager;
private FragmentTransaction mCurTransaction = null;
private ArrayList<Fragment.SavedState> mSavedState = new ArrayList<Fragment.SavedState>();
private ArrayList<ItemInfo<T>> mItemInfos = new ArrayList();
private Fragment mCurrentPrimaryItem = null;
private boolean mNeedProcessCache = false;
public OpenFragmentStatePagerAdapter(FragmentManager fm) {
mFragmentManager = fm;
}
/**
* Return the Fragment associated with a specified position.
*/
public abstract Fragment getItem(int position);
protected Fragment getCachedItem(int position) {
return mItemInfos.size() > position ? mItemInfos.get(position).fragment : null;
}
@Override
public void startUpdate(ViewGroup container) {
if (container.getId() == View.NO_ID) {
throw new IllegalStateException("ViewPager with adapter " + this
+ " requires a view id");
}
}
@Override
public Object instantiateItem(ViewGroup container, int position) {
// If we already have this item instantiated, there is nothing
// to do. This can happen when we are restoring the entire pager
// from its saved state, where the fragment manager has already
// taken care of restoring the fragments we previously had instantiated.
if (mItemInfos.size() > position) {
ItemInfo ii = mItemInfos.get(position);
if (ii != null) {
//判斷位置是否相等，如果不相等說明新資料有增加或刪除(導致了ViewPager那邊有空位)，
// 而這時notifyDataSetChanged方法還沒有完成，ViewPager會先呼叫instantiateItem來獲取新的頁面
//所以為了不取錯頁面，我們需要對快取進行檢查和調整位置：checkProcessCacheChanged
if (ii.position == position) {
return ii;
} else {
checkProcessCacheChanged();
}
}
}
if (mCurTransaction == null) {
mCurTransaction = mFragmentManager.beginTransaction();
}
Fragment fragment = getItem(position);
if (DEBUG) Log.v(TAG, "Adding item #" + position + ": f=" + fragment);
if (mSavedState.size() > position) {
Fragment.SavedState fss = mSavedState.get(position);
if (fss != null) {
fragment.setInitialSavedState(fss);
}
}
while (mItemInfos.size() <= position) {
mItemInfos.add(null);
}
fragment.setMenuVisibility(false);
fragment.setUserVisibleHint(false);
ItemInfo<T> iiNew = new ItemInfo<>(fragment, getItemData(position), position);
mItemInfos.set(position, iiNew);
mCurTransaction.add(container.getId(), fragment);
return iiNew;
}
@Override
public void destroyItem(ViewGroup container, int position, Object object) {
ItemInfo ii = (ItemInfo) object;
if (mCurTransaction == null) {
mCurTransaction = mFragmentManager.beginTransaction();
}
if (DEBUG) Log.v(TAG, "Removing item #" + position + ": f=" + object
+ " v=" + ((Fragment) object).getView());
while (mSavedState.size() <= position) {
mSavedState.add(null);
}
mSavedState.set(position, ii.fragment.isAdded()
? mFragmentManager.saveFragmentInstanceState(ii.fragment) : null);
mItemInfos.set(position, null);
mCurTransaction.remove(ii.fragment);
}
@Override
@SuppressWarnings("ReferenceEquality")
public void setPrimaryItem(ViewGroup container, int position, Object object) {
ItemInfo ii = (ItemInfo) object;
Fragment fragment = ii.fragment;
if (fragment != mCurrentPrimaryItem) {
if (mCurrentPrimaryItem != null) {
mCurrentPrimaryItem.setMenuVisibility(false);
mCurrentPrimaryItem.setUserVisibleHint(false);
}
if (fragment != null) {
fragment.setMenuVisibility(true);
fragment.setUserVisibleHint(true);
}
mCurrentPrimaryItem = fragment;
}
}
@Override
public void finishUpdate(ViewGroup container) {
if (mCurTransaction != null) {
mCurTransaction.commitNowAllowingStateLoss();
mCurTransaction = null;
}
}
@Override
public boolean isViewFromObject(View view, Object object) {
Fragment fragment = ((ItemInfo) object).fragment;
return fragment.getView() == view;
}
@Override
public int getItemPosition(Object object) {
mNeedProcessCache = true;
ItemInfo<T> itemInfo = (ItemInfo) object;
int oldPosition = mItemInfos.indexOf(itemInfo);
if (oldPosition >= 0) {
T oldData = itemInfo.data;
T newData = getItemData(oldPosition);
if (dataEquals(oldData, newData)) {
return POSITION_UNCHANGED;
} else {
ItemInfo<T> oldItemInfo = mItemInfos.get(oldPosition);
int oldDataNewPosition = getDataPosition(oldData);
if (oldDataNewPosition < 0) {
oldDataNewPosition = POSITION_NONE;
}
//把新的位置賦值到快取的itemInfo中，以便調整時使用
if (oldItemInfo != null) {
oldItemInfo.position = oldDataNewPosition;
}
return oldDataNewPosition;
}
}
return POSITION_UNCHANGED;
}
@Override
public void notifyDataSetChanged() {
super.notifyDataSetChanged();
//通知ViewPager更新完成後對快取的ItemInfo List進行調整
checkProcessCacheChanged();
}
private void checkProcessCacheChanged() {
//只有呼叫過getItemPosition(也就是有notifyDataSetChanged)才進行快取的調整
if (!mNeedProcessCache) return;
mNeedProcessCache = false;
ArrayList<ItemInfo<T>> pendingItemInfos = new ArrayList<>(mItemInfos.size());
//先存入空資料
for (int i = 0; i < mItemInfos.size(); i++) {
pendingItemInfos.add(null);
}
//根據快取的itemInfo中的新position把itemInfo入正確的位置
for (ItemInfo<T> itemInfo : mItemInfos) {
if (itemInfo != null) {
if (itemInfo.position >= 0) {
while (pendingItemInfos.size() <= itemInfo.position) {
pendingItemInfos.add(null);
}
pendingItemInfos.set(itemInfo.position, itemInfo);
}
}
}
mItemInfos = pendingItemInfos;
}
@Override
public Parcelable saveState() {
Bundle state = null;
if (mSavedState.size() > 0) {
state = new Bundle();
Fragment.SavedState[] fss = new Fragment.SavedState[mSavedState.size()];
mSavedState.toArray(fss);
state.putParcelableArray("states", fss);
}
for (int i = 0; i < mItemInfos.size(); i++) {
Fragment f = mItemInfos.get(i).fragment;
if (f != null && f.isAdded()) {
if (state == null) {
state = new Bundle();
}
String key = "f" + i;
mFragmentManager.putFragment(state, key, f);
}
}
return state;
}
@Override
public void restoreState(Parcelable state, ClassLoader loader) {
if (state != null) {
Bundle bundle = (Bundle) state;
bundle.setClassLoader(loader);
Parcelable[] fss = bundle.getParcelableArray("states");
mSavedState.clear();
mItemInfos.clear();
if (fss != null) {
for (int i = 0; i < fss.length; i++) {
mSavedState.add((Fragment.SavedState) fss[i]);
}
}
Iterable<String> keys = bundle.keySet();
for (String key : keys) {
if (key.startsWith("f")) {
int index = Integer.parseInt(key.substring(1));
Fragment f = mFragmentManager.getFragment(bundle, key);
if (f != null) {
while (mItemInfos.size() <= index) {
mItemInfos.add(null);
}
f.setMenuVisibility(false);
ItemInfo<T> iiNew = new ItemInfo<>(f, getItemData(index), index);
mItemInfos.set(index, iiNew);
} else {
Log.w(TAG, "Bad fragment at key " + key);
}
}
}
}
}
protected Fragment getCurrentPrimaryItem() {
return mCurrentPrimaryItem;
}
protected Fragment getFragmentByPosition(int position) {
if (position < 0 || position >= mItemInfos.size()) return null;
return mItemInfos.get(position).fragment;
}
abstract T getItemData(int position);
abstract boolean dataEquals(T oldData, T newData);
abstract int getDataPosition(T data);
static class ItemInfo<D> {
Fragment fragment;
D data;
int position;
public ItemInfo(Fragment fragment, D data, int position) {
this.fragment = fragment;
this.data = data;
this.position = position;
}
}
}
複製程式碼這個是抽象的基類，然後我們在具體業務程式碼處寫一個Adapter繼承OpenFragmentStatePagerAdapter，就可以用極少的程式碼來使用了，當需要更新某個具體的頁面時不需要notifyDataSetChanged，只需要用getFragmentByPosition來取出具體頁面，然後區域性更新內容
使用(因為專案中是kotlin寫的，後面有朋友要demo時寫了個java版在文章最後的github地址中)：
/**
* Created by homgwu on 2018/3/23 10:12.
*/
class ListChatViewPagerAdapter(fragmentManager: FragmentManager, val viewPager: ViewPager) : OpenFragmentStatePagerAdapter<SessionItem>(fragmentManager), AnkoLogger {
private var mData: ArrayList<SessionItem> = ArrayList()
constructor(fragmentManager: FragmentManager, viewPager: ViewPager, data: List<SessionItem>?) : this(fragmentManager, viewPager) {
mData.clear()
if (data != null) mData.addAll(data)
}
override fun getItem(position: Int): Fragment {
info {
"getItem position=$position"
}
return ChatListFragment.newInstance(mData[position].data, ChatListFragment.COME_FROM_LIST_CHAT)
}
override fun getCount(): Int {
info {
"getCount count=${mData.size}"
}
return mData.size
}
// override fun getItemPosition(`object`: Any?): Int {
//// return findItemPosition(`object` as ChatListFragment)
// return POSITION_NONE
// }
fun getCurrentFragmentItem(): ChatListFragment? {
return getCurrentPrimaryItem() as? ChatListFragment
}
fun setNewData(data: List<SessionItem>) {
mData.clear()
mData.addAll(data)
notifyDataSetChanged()
}
fun addData(sessionItem: SessionItem) {
mData.add(sessionItem)
notifyDataSetChanged()
}
fun addData(position: Int, sessionItem: SessionItem) {
mData.add(position, sessionItem)
notifyDataSetChanged()
}
fun remove(position: Int) {
mData.removeAt(position)
notifyDataSetChanged()
}
fun moveData(from: Int, to: Int) {
if (from == to) return
Collections.swap(mData, from, to)
// updateByPosition(from, mData[from])
// updateByPosition(to, mData[to])
notifyDataSetChanged()
}
fun moveDataToFirst(from: Int) {
val tempData = mData.removeAt(from)
mData.add(0, tempData)
notifyDataSetChanged()
}
fun updateByPosition(position: Int, sessionItem: SessionItem) {
if (position >= 0 && mData.size > position) {
mData[position] = sessionItem
var targetF = getCachedFragmentByPosition(position)
if (targetF != null) {
targetF.resetData(sessionItem.data)
}
}
}
override fun getItemData(position: Int): SessionItem? {
return if (mData.size > position) mData[position] else null
}
override fun dataEquals(oldData: SessionItem?, newData: SessionItem?): Boolean {
return oldData == newData
}
override fun getDataPosition(data: SessionItem?): Int {
return if (data == null) -1 else mData.indexOf(data)
}
fun getCachedFragmentByPosition(position: Int): ChatListFragment? {
return getFragmentByPosition(position) as? ChatListFragment
}
}
複製程式碼Kotlin版OpenFragmentStatePagerAdapter：
/**
* Created by homgwu on 2018/3/23 09:35.
*/
abstract class OpenFragmentStatePagerAdapter<T>(private val mFragmentManager: FragmentManager) : PagerAdapter() {
private val TAG = "FragmentStatePagerAdapt"
private val DEBUG = false
private var mCurTransaction: FragmentTransaction? = null
private val mSavedState = ArrayList<Fragment.SavedState?>()
private var mItemInfos = ArrayList<ItemInfo<T>?>()
protected var mCurrentPrimaryItem: Fragment? = null
private var mNeedProcessCache = false
/**
* Return the Fragment associated with a specified position.
*/
abstract fun getItem(position: Int): Fragment
protected fun getCachedItem(position: Int): Fragment? = if (mItemInfos.size > position) mItemInfos[position]?.fragment else null
override fun startUpdate(container: ViewGroup) {
if (container.id == View.NO_ID) {
throw IllegalStateException("ViewPager with adapter " + this
+ " requires a view id")
}
}
override fun instantiateItem(container: ViewGroup, position: Int): Any {
// If we already have this item instantiated, there is nothing
// to do. This can happen when we are restoring the entire pager
// from its saved state, where the fragment manager has already
// taken care of restoring the fragments we previously had instantiated.
if (mItemInfos.size > position) {
val ii = mItemInfos[position]
ii?.let {
if (it.position == position) {
return this
} else {
checkProcessCacheChanged()
}
}
}
val fragment = getItem(position)
if (DEBUG) Log.v(TAG, "Adding item #$position: f=$fragment")
if (mSavedState.size > position) {
val fss = mSavedState[position]
if (fss != null) {
fragment.setInitialSavedState(fss)
}
}
while (mItemInfos.size <= position) {
mItemInfos.add(null)
}
fragment.setMenuVisibility(false)
fragment.userVisibleHint = false
val iiNew = ItemInfo(fragment, getItemData(position), position)
mItemInfos[position] = iiNew
if (mCurTransaction == null) {
mCurTransaction = mFragmentManager.beginTransaction()
}
mCurTransaction!!.add(container.id, fragment)
return iiNew
}
override fun destroyItem(container: ViewGroup, position: Int, `object`: Any) {
val ii = `object` as ItemInfo<T>
if (DEBUG)
Log.v(TAG, "Removing item #" + position + ": f=" + `object`
+ " v=" + ii.fragment.view)
while (mSavedState.size <= position) {
mSavedState.add(null)
}
mSavedState[position] = if (ii.fragment.isAdded)
mFragmentManager.saveFragmentInstanceState(ii.fragment)
else
null
mItemInfos[position] = null
if (mCurTransaction == null) {
mCurTransaction = mFragmentManager.beginTransaction()
}
mCurTransaction!!.remove(ii.fragment)
}
override fun setPrimaryItem(container: ViewGroup, position: Int, `object`: Any?) {
val ii = `object` as? ItemInfo<T>
val fragment = ii?.fragment
if (fragment != mCurrentPrimaryItem) {
mCurrentPrimaryItem?.apply {
setMenuVisibility(false)
userVisibleHint = false
}
fragment?.apply {
setMenuVisibility(true)
userVisibleHint = true
}
mCurrentPrimaryItem = fragment
}
}
override fun finishUpdate(container: ViewGroup) {
mCurTransaction?.apply {
commitNowAllowingStateLoss()
}
mCurTransaction = null
}
override fun isViewFromObject(view: View, `object`: Any): Boolean {
val fragment = (`object` as ItemInfo<T>).fragment
return fragment.view === view
}
override fun getItemPosition(`object`: Any?): Int {
mNeedProcessCache = true
val itemInfo: ItemInfo<T> = `object` as ItemInfo<T>
val oldPosition = mItemInfos.indexOf(itemInfo)
if (oldPosition >= 0) {
val oldData: T? = itemInfo.data
val newData: T? = getItemData(oldPosition)
return if (dataEquals(oldData, newData)) {
PagerAdapter.POSITION_UNCHANGED
} else {
val oldItemInfo = mItemInfos[oldPosition]
var oldDataNewPosition = getDataPosition(oldData)
if (oldDataNewPosition < 0) {
oldDataNewPosition = PagerAdapter.POSITION_NONE
}
oldItemInfo?.apply {
position = oldDataNewPosition
}
oldDataNewPosition
}
}
return PagerAdapter.POSITION_UNCHANGED
}
override fun notifyDataSetChanged() {
super.notifyDataSetChanged()
checkProcessCacheChanged()
}
private fun checkProcessCacheChanged() {
if (!mNeedProcessCache) return
mNeedProcessCache = false
val pendingItemInfos = ArrayList<ItemInfo<T>?>(mItemInfos.size)
for (i in 0..(mItemInfos.size - 1)) {
pendingItemInfos.add(null)
}
for (value in mItemInfos) {
value?.apply {
if (position >= 0) {
while (pendingItemInfos.size <= position) {
pendingItemInfos.add(null)
}
pendingItemInfos[value.position] = value
}
}
}
mItemInfos = pendingItemInfos
}
override fun saveState(): Parcelable? {
var state: Bundle? = null
if (mSavedState.size > 0) {
state = Bundle()
val fss = arrayOfNulls<Fragment.SavedState>(mSavedState.size)
mSavedState.toArray(fss)
state.putParcelableArray("states", fss)
}
for (i in mItemInfos.indices) {
val f = mItemInfos[i]?.fragment
if (f != null && f.isAdded) {
if (state == null) {
state = Bundle()
}
val key = "f$i"
mFragmentManager.putFragment(state, key, f)
}
}
return state
}
override fun restoreState(state: Parcelable?, loader: ClassLoader?) {
if (state != null) {
val bundle = state as Bundle?
bundle!!.classLoader = loader
val fss = bundle.getParcelableArray("states")
mSavedState.clear()
mItemInfos.clear()
if (fss != null) {
for (i in fss.indices) {
mSavedState.add(fss[i] as Fragment.SavedState)
}
}
val keys = bundle.keySet()
for (key in keys) {
if (key.startsWith("f")) {
val index = Integer.parseInt(key.substring(1))
val f = mFragmentManager.getFragment(bundle, key)
if (f != null) {
while (mItemInfos.size <= index) {
mItemInfos.add(null)
}
f.setMenuVisibility(false)
val iiNew = ItemInfo(f, getItemData(index), index)
mItemInfos[index] = iiNew
} else {
Log.w(TAG, "Bad fragment at key $key")
}
}
}
}
}
protected fun getCurrentPrimaryItem() = mCurrentPrimaryItem
protected fun getFragmentByPosition(position: Int): Fragment? {
if (position < 0 || position >= mItemInfos.size) return null
return mItemInfos[position]?.fragment
}
abstract fun getItemData(position: Int): T?
abstract fun dataEquals(oldData: T?, newData: T?): Boolean
abstract fun getDataPosition(data: T?): Int
class ItemInfo<D>(var fragment: Fragment, var data: D?, var position: Int)
}
複製程式碼到此，我們已經可以愉快的使用ViewPager+OpenFragmentStatePagerAdapter來動態新增，刪除，移動位置，更新或區域性更新頁面了。原始碼及Demo 在下面的github地址中。
作者：竹塵居士 GitHub：https://github.com/homgwu/OpenPagerAdapter 部落格：http://zhuchen.vip/2018/04/04/android/android-viewpager-adapter-update-move-add.html