安卓基礎開發庫，讓開發簡單點。
DevRing & Demo地址：https://github.com/LJYcoder/DevRing

前言

基類對于開發是很重要的一部分。在基類中一般可以進行以下操作
1.把一些頻繁調用的代碼封裝起來。
2.提供抽象方法給子類實現，從而簡化操作、得到更直接的數據。
使用好基類可以減少代碼量，方便統一拓展，提高發開效率。

但由于Java單繼承的特性，有時別人提供的基類不一定能應用到自己的項目里去，所以下面也會介紹通過LifecycleCallback的方法來實現Activity/Fragment基類的功能（該方式是從這里學習的）。

介紹

下面介紹demo中用到的基類，如Activity基類、Fragment基類、Adapter基類、Presenter基類。
基類的具體實現請根據自己的需求來定制，下面僅供參考。

1. Activity基類

1.1 BaseActivity

public abstract class BaseActivity<P extends BasePresenter> extends AppCompatActivity implements IBaseActivity {

    @BindColor(R.color.colorPrimary)
    int mColor;
    @Inject
    @Nullable
    protected P mPresenter;

    protected abstract int getContentLayout();//返回頁面布局id
    protected abstract void initView(Bundle savedInstanceState);//做視圖相關的初始化工作
    protected abstract void initData(Bundle savedInstanceState);//做數據相關的初始化工作
    protected abstract void initEvent();//做監聽事件相關的初始化工作

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        if (getContentLayout() != 0) {
            setContentView(getContentLayout());
            ButterKnife.bind(this);
        }
        initBarColor();//初始化狀態欄/導航欄顏色，需在設置了布局后再調用
        initView(savedInstanceState);
        initData(savedInstanceState);
        initEvent();
    }

    private void initBarColor() {
        ColorBar.newColorBuilder()
                .applyNav(true)
                .navColor(mColor).navDepth(0)
                .statusColor(mColor)
                .statusDepth(0)
                .build(this)
                .apply();
    }

    @Override
    public boolean isUseEventBus() {
        return false;
    }

    @Override
    public boolean isUseFragment() {
        return true;
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mPresenter != null) {
            mPresenter.destroy();
            mPresenter = null;
        }
    }
}

BaseActivity的作用如下：

重寫onCreate。
這樣具體的Activity就不需要重寫onCreate()方法，而只需重寫getContentLayout()、initView(Bundle savedInstanceState);、initData(Bundle savedInstanceState)、initEvent()并在其中進行相應的操作即可
設置狀態欄導航欄顏色。
很多時候，我們需要對app頂部的狀態欄以及底部的導航欄（含有虛擬按鍵的那一欄）進行顏色設置從而實現沉浸式效果。對于Andriod4.4、5.0版本，它們設置顏色的方式有區別，所以需要做兼容處理。demo中使用的是UltimateBar開源庫，它內部已經做了兼容操作，并提供了幾個方法來設置顏色，如不透明的、半透明的、全透明的、隱藏等。
銷毀Presenter層對View層的引用。
這里涉及MVP開發模式，不了解的可以先點這里。由于Activity經常需要銷毀Presenter層對View層的引用，所以移至基類中實現。
實現IBaseActivity接口。
實現該接口，以便通過Application.ActivityLifecycleCallbacks完成部分"基類操作"，看完1.2你就懂了。

1.2 通過ActivityLifecycleCallbacks實現基類操作

顧名思義--- Activity生命周期回調。
當注冊了該回調用，每個Activity進入相關生命周期時都會觸發相關回調。
所以我們可以通過Application.registerActivityLifecycleCallbacks(callback)方法注冊回調，然后在ActivityLifecycleCallbacks里實現一些基類操作。
不多說，直接上代碼。（代碼涉及了一些Dagger2，可以點這里了解）

@Singleton
public class ActivityLifeCallback implements Application.ActivityLifecycleCallbacks {

    @Inject
    SimpleArrayMap<String, IActivityLife> mMapActivityLife;
    @Inject
    Provider<IActivityLife> mActivityLifeProvider;
    @Inject
    Lazy<FragmentLifeCallback> mFragmentLifeCallbackProvider;

    @Inject
    public ActivityLifeCallback() {
    }

    @Override
    public void onActivityCreated(Activity activity, Bundle bundle) {
        if (activity instanceof IBaseActivity) {
            IActivityLife iActivityLife = mMapActivityLife.get(activity.toString());
            if (iActivityLife == null) {
                iActivityLife = mActivityLifeProvider.get();
                mMapActivityLife.put(activity.toString(), iActivityLife);
            }
            iActivityLife.onCreate(activity, bundle);
        }

        boolean isUseFragment = activity instanceof IBaseActivity ? ((IBaseActivity) activity).isUseFragment() : true;
        if (activity instanceof FragmentActivity && isUseFragment) {
            ((FragmentActivity) activity).getSupportFragmentManager().registerFragmentLifecycleCallbacks(mFragmentLifeCallbackProvider.get(), true);
        }
    }

    @Override
    public void onActivityStarted(Activity activity) {
        IActivityLife iActivityLife = mMapActivityLife.get(activity.toString());
        if (iActivityLife != null) {
            iActivityLife.onStart();
        }
    }

    @Override
    public void onActivityResumed(Activity activity) {
        IActivityLife iActivityLife = mMapActivityLife.get(activity.toString());
        if (iActivityLife != null) {
            iActivityLife.onResume();
        }
    }

    @Override
    public void onActivityPaused(Activity activity) {
        IActivityLife iActivityLife = mMapActivityLife.get(activity.toString());
        if (iActivityLife != null) {
            iActivityLife.onPause();
        }
    }

    @Override
    public void onActivityStopped(Activity activity) {
        IActivityLife iActivityLife = mMapActivityLife.get(activity.toString());
        if (iActivityLife != null) {
            iActivityLife.onStop();
        }
    }

    @Override
    public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {
        IActivityLife iActivityLife = mMapActivityLife.get(activity.toString());
        if (iActivityLife != null) {
            iActivityLife.onSaveInstanceState(bundle);
        }
    }

    @Override
    public void onActivityDestroyed(Activity activity) {
        IActivityLife iActivityLife = mMapActivityLife.get(activity.toString());
        if (iActivityLife != null) {
            iActivityLife.onDestroy();
        }
        mMapActivityLife.remove(activity.toString());
    }

}

我把各生命周期具體要做的事情放到ActivityLife里執行了，下面貼上ActivityLife的代碼：

public class ActivityLife implements IActivityLife {

    private Activity mActivity;
    private final PublishSubject<ActivityEvent> mLifecycleSubject = PublishSubject.create();

    @Override
    public void onCreate(Activity activity, Bundle savedInstanceState) {
        mActivity = activity;

        mLifecycleSubject.onNext(ActivityEvent.CREATE);

        DevRing.activityStackManager().pushOneActivity(mActivity);

        if (((IBaseActivity) mActivity).isUseEventBus()) {
            DevRing.busManager().register(mActivity);
        }
    }

    @Override
    public void onStart() {
        mLifecycleSubject.onNext(ActivityEvent.START);
    }

    @Override
    public void onResume() {
        mLifecycleSubject.onNext(ActivityEvent.RESUME);
    }

    @Override
    public void onPause() {
        mLifecycleSubject.onNext(ActivityEvent.PAUSE);
    }

    @Override
    public void onStop() {
        mLifecycleSubject.onNext(ActivityEvent.STOP);
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {

    }

    @Override
    public void onDestroy() {
        mLifecycleSubject.onNext(ActivityEvent.DESTROY);

        DevRing.activityStackManager().popOneActivity(mActivity);

        if (((IBaseActivity) mActivity).isUseEventBus()) {
            DevRing.busManager().unregister(mActivity);
        }
        mActivity = null;
    }
}

接下來，只要你的Activity實現了IBaseActivity接口，即可通過ActivityLifecycleCallbacks完成以下"基類操作"：

幫助控制網絡請求的生命周期。
通過PublishSubject的操作，在onPause()/onStop()/onDestroy()中發射終止事件，以便控制Retrofit網絡請求在頁面進入特定狀態時終止。
EventBus的訂閱/解除訂閱。
根據isUseEventBus()來決定是否進行EventBus的注冊/注銷。
Activity棧管理的入棧與出棧。
以便后面可通過ActivityStackManager進行頁面銷毀工作。
FragmentLifecycleCallbacks的注冊。
根據isUseFragment()來決定是否注冊FragmentLifecycleCallbacks。

IBaseActivity接口代碼：

public interface IBaseActivity {
    /**
     * 該Activity是否訂閱事件總線
     * @return true則自動進行注冊/注銷操作，false則不注冊
     */
    boolean isUseEventBus();

    /**
     * 該Activity是否包含Fragment（是否注冊FragmentLifecycleCallbacks）
     * @return
     * 返回false則不注冊FragmentLifecycleCallbacks，也就是說{@link FragmentLifeCallback}中的操作不會進行
     */
    boolean isUseFragment();
}

2. Fragment基類

2.1 BaseFragment

public abstract class BaseFragment<P extends BasePresenter> extends Fragment implements IBaseFragment {

    protected Activity mActivity;
    //根布局視圖
    private View mContentView;
    //視圖是否已經初始化完畢
    private boolean isViewReady;
    //fragment是否處于可見狀態
    private boolean isFragmentVisible;
    //是否已經初始化加載過
    protected boolean isLoaded;
    //用于butterknife解綁
    private Unbinder unbinder;
    @Inject
    @Nullable
    protected P mPresenter;

    protected abstract boolean isLazyLoad();//是否使用懶加載 (Fragment可見時才進行初始化操作(以下四個方法))
    protected abstract int getContentLayout();//返回頁面布局id
    protected abstract void initView();//做視圖相關的初始化工作
    protected abstract void initData();//做數據相關的初始化工作
    protected abstract void initEvent();//做監聽事件相關的初始化工作

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        mActivity = (Activity) context;
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {

        if (mContentView == null) {
            try {
                mContentView = inflater.inflate(getContentLayout(), container, false);
            } catch (Resources.NotFoundException e) {
                e.printStackTrace();
            }

            Preconditions.checkNotNull(mContentView, "根布局的id非法導致根布局為空,請檢查后重試!");

            unbinder = ButterKnife.bind(this, mContentView);
        }
        return mContentView;
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        //視圖準備完畢
        isViewReady = true;
        if (!isLazyLoad() || isFragmentVisible) {
            init();
        }
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);

        isFragmentVisible = isVisibleToUser;
        //如果視圖準備完畢且Fragment處于可見狀態，則開始初始化操作
        if (isLazyLoad() && isViewReady && isFragmentVisible) {
            init();
        }
    }

    public void init() {
        if (!isLoaded) {
            isLoaded = true;
            initView();
            initData();
            initEvent();
        }
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
        //ButterKnife解綁
        if (unbinder != null) unbinder.unbind();
        isViewReady = false;
        isLoaded = false;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        if (mPresenter != null) {
            mPresenter.destroy();
            mPresenter = null;
        }
    }

    @Override
    public void onSaveState(Bundle bundleToSave) {

    }

    @Override
    public void onRestoreState(Bundle bundleToRestore) {

    }

    @Override
    public boolean isUseEventBus() {
        return false;
    }
}

BaseFragment的作用如下：

延遲加載（懶加載）。 如果Fragment與ViewPager結合使用的話，當加載當前Fragment時，上一頁和下一頁的Fragment都會預先進行加載，這樣如果加載的內容很多，容易造成卡頓、速度慢。
延遲主要就是通過在setUserVisibleHint和onActivityCreated中做判斷來實現的，當視圖準備完畢且Fragment處于可見狀態時，才開始進行初始化操作。重寫isLazyLoad()方法即可決定是否開啟懶加載功能。
然后具體的fragment只需重寫getContentLayout()、initView()、initData()、initEvent()中進行相應的操作即可。
另外有一點需要注意，如果fragment并不是和Viewpager結合使用，而是通過FragmentManager的Transaction進行add/hide/show的話，那么在顯示Fragment的時候，請顯式地調用setUserVisibleHint()，如下：

//包含多個Fragment的Activity中的代碼

//顯示或隱藏Fragment，用于切換Fragment的展示
private void addOrShowFragment(FragmentTransaction transaction, BaseFragment fragment, String tag) {
    if (mCurrentFragment == fragment) return;

    if (!fragment.isAdded()) {
        transaction.hide(mCurrentFragment).add(R.id.fl_movie, fragment, tag).commit();
    } else {
        transaction.hide(mCurrentFragment).show(fragment).commit();
    }

    //不與ViewPager嵌套的話，需要顯式調用setUserVisibleHint
    mCurrentFragment.setUserVisibleHint(false);
    mCurrentFragment = fragment;
    mCurrentFragment.setUserVisibleHint(true);
}

銷毀Presenter層對View層的引用。
這里涉及MVP開發模式，不了解的可以先點這里。由于Fragment經常需要銷毀Presenter層對View層的引用，所以移至基類中實現。
實現IBaseFragment接口。
實現該接口，以便通過FragmentManager.FragmentLifecycleCallbacks完成部分"基類操作"，看完2.2你就懂了。

2.2 通過FragmentManager.FragmentLifecycleCallbacks實現

同樣顧名思義 --- Fragment生命周期回調。
當注冊了該回調用，每個Fragment進入相關生命周期時都會觸發相關回調。
所以我們可以通過((FragmentActivity) activity).getSupportFragmentManager().registerFragmentLifecycleCallbacks(callback, true)方法注冊回調，然后在
FragmentLifecycleCallbacks里實現一些基類操作。
不多說，直接上代碼。（代碼涉及了一些Dagger2，可以點這里了解）

@Singleton
public class FragmentLifeCallback extends FragmentManager.FragmentLifecycleCallbacks {

    @Inject
    SimpleArrayMap<String, IFragmentLife> mMapFragmentLife;
    @Inject
    Provider<IFragmentLife> mFragmentLifeProvider;

    @Inject
    public FragmentLifeCallback() {
    }

    @Override
    public void onFragmentAttached(FragmentManager fm, Fragment f, Context context) {
        if (f instanceof IBaseFragment) {
            IFragmentLife iFragmentLife = mMapFragmentLife.get(f.toString());
            if (iFragmentLife == null || !iFragmentLife.isAdded()) {
                iFragmentLife = mFragmentLifeProvider.get();
                mMapFragmentLife.put(f.toString(), iFragmentLife);
//                RingLog.e("onCreate activity:" + activity.toString());
//                RingLog.e("onCreate iActivityLife:" + iActivityLife.toString());
            }
            iFragmentLife.onAttach(f, context);
        }
    }

    @Override
    public void onFragmentCreated(FragmentManager fm, Fragment f, Bundle savedInstanceState) {
        IFragmentLife iFragmentLife = mMapFragmentLife.get(f.toString());
        if (iFragmentLife != null) {
            iFragmentLife.onCreate(savedInstanceState);
        }
    }

    @Override
    public void onFragmentActivityCreated(FragmentManager fm, Fragment f, Bundle savedInstanceState) {
        IFragmentLife iFragmentLife = mMapFragmentLife.get(f.toString());
        if (iFragmentLife != null) {
            iFragmentLife.onActivityCreate(savedInstanceState);
        }
    }

    @Override
    public void onFragmentViewCreated(FragmentManager fm, Fragment f, View v, Bundle savedInstanceState) {
        IFragmentLife iFragmentLife = mMapFragmentLife.get(f.toString());
        if (iFragmentLife != null) {
            iFragmentLife.onCreateView(v,savedInstanceState);
        }
    }

    @Override
    public void onFragmentStarted(FragmentManager fm, Fragment f) {
        IFragmentLife iFragmentLife = mMapFragmentLife.get(f.toString());
        if (iFragmentLife != null) {
            iFragmentLife.onStart();
        }
    }

    @Override
    public void onFragmentResumed(FragmentManager fm, Fragment f) {
        IFragmentLife iFragmentLife = mMapFragmentLife.get(f.toString());
        if (iFragmentLife != null) {
            iFragmentLife.onResume();
        }
    }

    @Override
    public void onFragmentPaused(FragmentManager fm, Fragment f) {
        IFragmentLife iFragmentLife = mMapFragmentLife.get(f.toString());
        if (iFragmentLife != null) {
            iFragmentLife.onPause();
        }
    }

    @Override
    public void onFragmentStopped(FragmentManager fm, Fragment f) {
        IFragmentLife iFragmentLife = mMapFragmentLife.get(f.toString());
        if (iFragmentLife != null) {
            iFragmentLife.onStop();
        }
    }

    @Override
    public void onFragmentSaveInstanceState(FragmentManager fm, Fragment f, Bundle outState) {
        IFragmentLife iFragmentLife = mMapFragmentLife.get(f.toString());
        if (iFragmentLife != null) {
            iFragmentLife.onSaveInstanceState(outState);
        }
    }

    @Override
    public void onFragmentViewDestroyed(FragmentManager fm, Fragment f) {
        IFragmentLife iFragmentLife = mMapFragmentLife.get(f.toString());
        if (iFragmentLife != null) {
            iFragmentLife.onDestroyView();
        }
    }

    @Override
    public void onFragmentDestroyed(FragmentManager fm, Fragment f) {
        IFragmentLife iFragmentLife = mMapFragmentLife.get(f.toString());
        if (iFragmentLife != null) {
            iFragmentLife.onDestroy();
        }

        mMapFragmentLife.remove(f.toString());
    }

    @Override
    public void onFragmentDetached(FragmentManager fm, Fragment f) {
        IFragmentLife iFragmentLife = mMapFragmentLife.get(f.toString());
        if (iFragmentLife != null) {
            iFragmentLife.onDetach();
        }
    }
}

我把各生命周期具體要做的事情放到FragmentLife里執行了，下面貼上FragmentLife的代碼：

public class FragmentLife implements IFragmentLife {

    private static final String SAVED_STATE = "saved_state";
    private final PublishSubject<FragmentEvent> mLifecycleSubject = PublishSubject.create();

    private Fragment mFragment;
    private View mContentView;
    private Bundle mSavedState;//用于保存/恢復數據

    @Override
    public void onAttach(Fragment fragment, Context context) {
        mFragment = fragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        mLifecycleSubject.onNext(FragmentEvent.CREATE);
        if (((IBaseFragment) mFragment).isUseEventBus()) {
            DevRing.busManager().register(mFragment);
        }
    }

    @Override
    public void onCreateView(View view, Bundle savedInstanceState) {
        mLifecycleSubject.onNext(FragmentEvent.CREATE_VIEW);
        mContentView = view;
    }

    @Override
    public void onActivityCreate(Bundle savedInstanceState) {
        restoreStateFromArguments();
    }

    @Override
    public void onStart() {
        mLifecycleSubject.onNext(FragmentEvent.START);
    }

    @Override
    public void onResume() {
        mLifecycleSubject.onNext(FragmentEvent.RESUME);
    }

    @Override
    public void onPause() {
        mLifecycleSubject.onNext(FragmentEvent.PAUSE);
    }

    @Override
    public void onStop() {
        mLifecycleSubject.onNext(FragmentEvent.STOP);
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        saveStateToArguments();
    }

    @Override
    public void onDestroyView() {
        mLifecycleSubject.onNext(FragmentEvent.DESTROY_VIEW);

        if (mContentView != null) {
            ViewGroup parent = (ViewGroup) mContentView.getParent();
            if (parent != null) {
                parent.removeView(mContentView);
            }
        }

        saveStateToArguments();
    }

    @Override
    public void onDestroy() {
        mLifecycleSubject.onNext(FragmentEvent.DESTROY);

        if (((IBaseFragment) mFragment).isUseEventBus()) {
            DevRing.busManager().unregister(mFragment);
        }
        mContentView = null;
        mFragment = null;
    }

    @Override
    public void onDetach() {
        mLifecycleSubject.onNext(FragmentEvent.DETACH);
    }

    @Override
    public boolean isAdded() {
        return mFragment != null && mFragment.isAdded();
    }

    private void saveStateToArguments() {
        if (mFragment.getView() != null) {
            Bundle state = new Bundle();
            ((IBaseFragment) mFragment).onSaveState(state);
            mSavedState = state;
        }
        if (mSavedState != null) {
            Bundle b = mFragment.getArguments();
            if (b != null) {
                b.putBundle(SAVED_STATE, mSavedState);
            }
        }
    }

    private void restoreStateFromArguments() {
        Bundle b = mFragment.getArguments();
        if (b != null) {
            mSavedState = b.getBundle(SAVED_STATE);
            if (mSavedState != null) {
                ((IBaseFragment) mFragment).onRestoreState(mSavedState);
            }
        }
    }
}

接下來，只要你的Fragment實現了IBaseFragment接口（如果你的Activity實現了IBaseActivity，那還要確保isUseFragment()方法返回true），即可通過FragmentLifecycleCallbacks實現以下“基類操作”：

幫助控制網絡請求的生命周期。
通過PublishSubject的操作，在onPause()/onStop()/onDestroy()中發射終止事件，以便控制Retrofit網絡請求在頁面進入特定狀態時終止。
EventBus的訂閱/解除訂閱。
根據isUseEventBus()來決定是否進行EventBus的注冊/注銷。
數據的保存與恢復
fragment在保存和恢復數據方面，要比Activity復雜些，具體可以看這篇文章http://blog.csdn.net/donglynn/article/details/47065999 。
具體Fragment通過實現onSaveState(Bundle bundleToSave)進行數據保存以及onRestoreState(Bundle bundleToRestore);進行數據恢復即可。

IBaseFragment接口代碼：

public interface IBaseFragment {
    /**
     * 需要保存數據時，將數據寫進bundleToSave
     */
    void onSaveState(Bundle bundleToSave);

    /**
     * 從bundleToRestore中獲取你保存金曲的數據
     */
    void onRestoreState(Bundle bundleToRestore);

    /**
     * 該Fragment是否訂閱事件總線
     * @return true則自動進行注冊/注銷操作，false則不注冊
     */
    boolean isUseEventBus();
}

3. Adapter基類

3.1 RecyclerBaseAdapter

public abstract class RecyclerBaseAdapter<T> extends RecyclerView.Adapter<ViewHolder> implements IRecyclerAdapter<T> {
    private static final String TAG = RecyclerBaseAdapter.class.getSimpleName();

    private List<T> mDataList;
    private Context mContext;

    protected RecyclerBaseAdapter(@NonNull Context context, @NonNull List<T> mDataList) {
        if (context == null) {
            throw new NullPointerException("context is not allow null!");
        }
        this.mDataList = mDataList;
        this.mContext = context;
    }

    @Override
    public void onBindViewHolder(final ViewHolder holder, int position) {
        final int p = holder.getLayoutPosition();

        bindDataForView(holder, (mDataList != null && !mDataList.isEmpty()) ? (mDataList.size() > p ? mDataList.get(p) : null) : null, p);

    }

    @Override
    public int getItemCount() {
        return mDataList != null ? mDataList.size() : 0;
    }

    protected abstract void bindDataForView(ViewHolder holder, T t, int position);

    @Override
    public Context getContext() {
        return mContext;
    }

    @Override
    public T getItem(@IntRange(from = 0) int position) {
        if (position <= -1) {
            return null;
        }
        return !CollectionUtil.isEmpty(mDataList) ? mDataList.get(position) : null;
    }

    @Override
    public List<T> getDataList() {
        return mDataList;
    }

    //從某個位置開始，插入一組數據
    @Override
    public void insertItems(@NonNull List<T> list, @IntRange(from = 0) int startIndex) {

        if (mDataList == null) {
            return;
        }

        if (list == null || list.isEmpty()) {
            LogUtil.e(TAG, "插入的數據集為空或長度小于等于零, 請檢查你的數據集!");
            return;
        }

        if (this.mDataList.containsAll(list)) {
            return;
        }

        notifyItemRangeInserted(startIndex, list.size());
        mDataList.addAll(startIndex, list);
        notifyItemRangeChanged(startIndex, getItemCount() - startIndex);
    }

    //從最底下插入一組數據
    @Override
    public void insertItems(@NonNull List<T> list) {
        this.insertItems(list, mDataList.size());
    }

    //從某個位置開始，插入一個數據
    @Override
    public void insertItem(@NonNull T t, @IntRange(from = 0) int position) {

        if (mDataList == null) {
            return;
        }

        if (t == null) {
            LogUtil.e(TAG, "插入的數據為空, 請檢查你的數據!");
            return;
        }

        notifyItemInserted(position);
        mDataList.add(position, t);
        notifyItemRangeChanged(position, getItemCount() - position);
    }

    //從最底下插入一個數據
    @Override
    public void insertItem(@NonNull T t) {
        this.insertItem(t, mDataList.size());
    }

    //替換所有數據
    @Override
    public void replaceData(@NonNull List<T> list) {
        if (mDataList == null) {
            return;
        }

        if (list == null || list.isEmpty()) {
            LogUtil.e(TAG, "插入的數據集為空或長度小于等于零, 請檢查你的數據集!");
            return;
        }

        mDataList = list;
        notifyDataSetChanged();
    }

    //從某個位置開始，更新n個數據
    @Override
    public void updateItems(@IntRange(from = 0) int positionStart, @IntRange(from = 0) int itemCount) {
        notifyItemRangeChanged(positionStart, itemCount);
    }

    //更新所有數據
    @Override
    public void updateAll() {
        updateItems(0, mDataList.size());
    }

    //移除某個位置的數據
    @Override
    public void removeItem(@IntRange(from = 0) int position) {
        if (CollectionUtil.isEmpty(mDataList) || position <= -1) {
            return;
        }
        notifyItemRemoved(position);
        mDataList.remove(position);
        notifyItemRangeChanged(position, getItemCount() - position);
    }

    //移除所有數據
    @Override
    public void removeAll() {
        if (CollectionUtil.isEmpty(mDataList)) {
            return;
        }

        notifyItemRangeRemoved(0, getItemCount());
        mDataList.clear();
        notifyItemRangeChanged(0, getItemCount());
    }
}

RecyclerBaseAdapter的作用如下：

重寫onBindViewHolder并提供抽象方法。 由于列表項實體是不確定的，所以用到了泛型。
具體的Adapter繼承該基類，通過泛型傳入具體的實體類型，然后重寫bindDataForView方法，即可更直接地得到實體數據。
插入、刪除、刷新列表項。 提供相關方法，方便子類快速調用。

3.2 LoadMoreBaseAdapter

如果你的RecyclerView需要有上拉加載更多的功能（添加Footer），那么可以繼承LoadMoreBaseAdapter。
它繼承RecyclerBaseAdapter，添加了Footer并提供了方法來設置footer的狀態。

public abstract class LoadMoreBaseAdapter<T> extends RecyclerBaseAdapter<T> {

    // 普通布局
    private final int TYPE_ITEM = 1;
    // 腳布局
    private final int TYPE_FOOTER = 2;
    // 當前加載狀態，默認為加載完成
    private int loadState = 2;
    // 正在加載
    public static final int LOADING = 1;
    // 加載完成
    public static final int LOADING_COMPLETE = 2;
    // 加載到底了（全部數據加載完畢）
    public static final int LOADING_END = 3;

    public LoadMoreBaseAdapter(@NonNull Context context, @NonNull List<T> mDataList) {
        super(context, mDataList);
    }

    @Override
    public int getItemCount() {
        return super.getItemCount() + 1;
    }

    @Override
    public int getItemViewType(int position) {
        // 最后一個item設置為FooterView
        if (position + 1 == getItemCount()) {
            return TYPE_FOOTER;
        } else {
            return TYPE_ITEM;
        }
    }


    @Override
    protected void bindDataForView(ViewHolder holder, T t, int position) {
        if (holder.getItemViewType() == TYPE_FOOTER) {
            ProgressBar pbLoading = holder.getView(R.id.pb_loading);
            TextView tvLoading = holder.getView(R.id.tv_loading);
            LinearLayout llEnd = holder.getView(R.id.ll_end);

            switch (loadState) {
                case LOADING: // 正在加載
                    pbLoading.setVisibility(View.VISIBLE);
                    tvLoading.setVisibility(View.VISIBLE);
                    llEnd.setVisibility(View.GONE);
                    break;

                case LOADING_COMPLETE: // 加載完成
                    pbLoading.setVisibility(View.INVISIBLE);
                    tvLoading.setVisibility(View.INVISIBLE);
                    llEnd.setVisibility(View.GONE);
                    break;

                case LOADING_END: // 加載到底
                    pbLoading.setVisibility(View.GONE);
                    tvLoading.setVisibility(View.GONE);
                    llEnd.setVisibility(View.VISIBLE);
                    break;

                default:
                    break;

            }
        } else {
            bindDataForView_(holder, t, position);
        }
    }

    @Override
    public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        //進行判斷顯示類型，來創建返回不同的View
        if (viewType == TYPE_FOOTER) {
            View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_load_more_footer, parent, false);
            return new ViewHolder(view);
        } else {
            return onCreateViewHolder_(parent, viewType);
        }
    }

    @Override
    public void onAttachedToRecyclerView(RecyclerView recyclerView) {
        super.onAttachedToRecyclerView(recyclerView);
        RecyclerView.LayoutManager manager = recyclerView.getLayoutManager();
        if (manager instanceof GridLayoutManager) {
            final GridLayoutManager gridManager = ((GridLayoutManager) manager);
            gridManager.setSpanSizeLookup(new GridLayoutManager.SpanSizeLookup() {
                @Override
                public int getSpanSize(int position) {
                    // 如果當前是footer的位置，那么該item占據2個單元格，正常情況下占據1個單元格
                    return getItemViewType(position) == TYPE_FOOTER ? gridManager.getSpanCount() : 1;
                }
            });
        }
    }

    /**
     * 設置上拉加載狀態
     *
     * @param loadState 0.正在加載 1.加載完成 2.加載到底
     */
    public void setLoadState(int loadState) {
        this.loadState = loadState;
        notifyDataSetChanged();
    }

    protected abstract void bindDataForView_(ViewHolder holder, T t, int position);

    protected abstract ViewHolder onCreateViewHolder_(ViewGroup parent, int viewType);
}

當然，完整的上拉加載更多的流程還要配合列表的滾動監聽來實現。完整的流程代碼可以查看demo，效果圖

上拉加載更多

4. Presenter基類

不了解MVP模式的可以先看《安卓開發模式 --- MVP》

public abstract class BasePresenter<V extends IBaseView,M extends IBaseModel>{

    protected V mIView;
    protected M mIModel;

    public BasePresenter(V iView,M iModel) {
        mIView = iView;
        mIModel = iModel;
    }

    public BasePresenter(V iView) {
        mIView = iView;
    }

    public BasePresenter() {
    }

    /**
     * 釋放引用，防止內存泄露，一般在activity和fragment銷毀時調用
     */
    public void destroy() {
        mIView = null;
    }
}

BasePresenter的作用：

提供mIView，mIModel方便子類調用。 由于IView，IModel的具體類型不確定，所以使用了泛型，子類通過泛型傳入具體的IView、IModel類型。
避免內存泄漏。 提供destroy()方法給V層銷毀時調用。

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

關于基類的那些事

關于基類的那些事

前言

介紹

1. Activity基類

1.1 BaseActivity

1.2 通過ActivityLifecycleCallbacks實現基類操作

2. Fragment基類

2.1 BaseFragment

2.2 通過FragmentManager.FragmentLifecycleCallbacks實現

3. Adapter基類

3.1 RecyclerBaseAdapter

3.2 LoadMoreBaseAdapter

4. Presenter基類

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

關于基類的那些事

前言

介紹

1. Activity基類

1.1 BaseActivity

1.2 通過ActivityLifecycleCallbacks實現基類操作

2. Fragment基類

2.1 BaseFragment

2.2 通過FragmentManager.FragmentLifecycleCallbacks實現

3. Adapter基類

3.1 RecyclerBaseAdapter

3.2 LoadMoreBaseAdapter

4. Presenter基類

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频