1.首先看看TopActivity效果。
2.TopicActivity是一个继承BaseActivity的。前面分析过BaseActivity了。主要有一个标题栏，有返回的图标。
3.贴一下TopicActivity源代码。
/*
* Copyright 2017 GcsSloop
*
* 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.
*
* Last modified 2017-04-09 19:39:57
*
* GitHub: https://github.com/GcsSloop
* Website: http://www.gcssloop.com
* Weibo: http://weibo.com/GcsSloop
*/
package com.gcssloop.diycode.activity;
import android.content.Context;
import android.content.Intent;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.view.View;
import com.gcssloop.diycode.R;
import com.gcssloop.diycode.base.app.BaseActivity;
import com.gcssloop.diycode.base.app.ViewHolder;
import com.gcssloop.diycode.fragment.NodeTopicListFragment;
/**
* 查看不同分类的 Topic
*/
public class TopicActivity extends BaseActivity {
private static String Key_Node_ID = "Key_Node_ID";
private static String Key_Node_Name = "Key_Node_Name";
public static void newInstance(Context context, int nodeId, String nodeName) {
Intent intent = new Intent(context, TopicActivity.class);
intent.putExtra(Key_Node_ID, nodeId);
intent.putExtra(Key_Node_Name, nodeName);
context.startActivity(intent);
}
@Override protected int getLayoutId() {
return R.layout.activity_fragment;
}
@Override protected void initViews(ViewHolder holder, View root) {
Intent intent = getIntent();
int NodeId = intent.getIntExtra(Key_Node_ID, 0);
String NodeName = intent.getStringExtra(Key_Node_Name);
setTitle(NodeName);
NodeTopicListFragment fragment = NodeTopicListFragment.newInstance(NodeId);
FragmentManager fragmentManager = getSupportFragmentManager();
FragmentTransaction transaction = fragmentManager.beginTransaction();
transaction.add(R.id.fragment, fragment);
transaction.commit();
}
}
4.首先有一个静态函数newInstance，主要就是方便外部调用打开这个Activity吧。
5.实现在BaseActivity中定义的抽象函数getLayoutId()==>主要作用就是得到一个布局的id。
这个布局activity_fragment源码贴一下吧。
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/activity_topic"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context="com.gcssloop.diycode.activity.TopicActivity">
<android.support.v7.widget.Toolbar
android:id="@+id/toolbar"
android:layout_width="match_parent"
android:layout_height="wrap_content"/>
<FrameLayout
android:id="@+id/fragment"
android:layout_width="match_parent"
android:layout_height="match_parent"/>
</LinearLayout>
预览效果就是两个部分，一个是一个Toolbar，大概占了1/8，剩下的是一个FrameLayout
6.实现在BaseActivity中定义的抽象函数initViews(ViewHolder holder,view root)==>主要是加载一些视图。
首先是得到外部传过来的NodeName，将ActionBar的标题通过函数setTitle来设置。
这里用了一个NodeTopicListFragment，不知道是什么东西？==>原来自己定义的一个碎片。
贴一下NodeTopicListFragment的定义。
/*
* Copyright 2017 GcsSloop
*
* 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.
*
* Last modified 2017-04-09 19:30:45
*
* GitHub: https://github.com/GcsSloop
* Website: http://www.gcssloop.com
* Weibo: http://weibo.com/GcsSloop
*/
package com.gcssloop.diycode.fragment;
import android.content.Context;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v7.widget.RecyclerView;
import com.gcssloop.diycode.fragment.base.SimpleRefreshRecyclerFragment;
import com.gcssloop.diycode.fragment.provider.TopicProvider;
import com.gcssloop.diycode_sdk.api.topic.bean.Topic;
import com.gcssloop.diycode_sdk.api.topic.event.GetTopicsListEvent;
import com.gcssloop.recyclerview.adapter.multitype.HeaderFooterAdapter;
/**
* 分类 topic 列表
*/
public class NodeTopicListFragment extends SimpleRefreshRecyclerFragment<Topic, GetTopicsListEvent> {
private static String Key_Node_ID = "Key_Node_ID";
private int mNodeId = 0;
public static NodeTopicListFragment newInstance(int nodeId) {
Bundle args = new Bundle();
args.putInt(Key_Node_ID, nodeId);
NodeTopicListFragment fragment = new NodeTopicListFragment();
fragment.setArguments(args);
return fragment;
}
@Override public void initData(HeaderFooterAdapter adapter) {
mNodeId = getArguments().getInt(Key_Node_ID, 0);
loadMore();
}
@Override
protected void setAdapterRegister(Context context, RecyclerView recyclerView,
HeaderFooterAdapter adapter) {
adapter.register(Topic.class, new TopicProvider(getContext()));
}
@NonNull @Override protected String request(int offset, int limit) {
return mDiycode.getTopicsList(null, mNodeId, offset, limit);
}
}
6.1但是这个NodeTopicListFragment继承了一个SimpleRefreshRecyclerFragment<Topic,GetTopicListEvent>又不知道什么意思呢！
贴一下SimpleRefreshRecyclerFragment代码吧。
/*
* Copyright 2017 GcsSloop
*
* 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.
*
* Last modified 2017-04-09 21:16:47
*
* GitHub: https://github.com/GcsSloop
* Website: http://www.gcssloop.com
* Weibo: http://weibo.com/GcsSloop
*/
package com.gcssloop.diycode.fragment.base;
import android.support.annotation.NonNull;
import android.support.v7.widget.RecyclerView;
import com.gcssloop.recyclerview.layoutmanager.SpeedyLinearLayoutManager;
import com.gcssloop.diycode_sdk.api.base.event.BaseEvent;
import com.gcssloop.recyclerview.adapter.multitype.HeaderFooterAdapter;
import java.util.List;
public abstract class SimpleRefreshRecyclerFragment<T, Event extends BaseEvent<List<T>>> extends
RefreshRecyclerFragment<T, Event> {
@NonNull @Override protected RecyclerView.LayoutManager getRecyclerViewLayoutManager() {
return new SpeedyLinearLayoutManager(getContext());
}
@Override protected void onRefresh(Event event, HeaderFooterAdapter adapter) {
adapter.clearDatas();
adapter.addDatas(event.getBean());
toast("刷新成功");
}
@Override protected void onLoadMore(Event event, HeaderFooterAdapter adapter) {
adapter.addDatas(event.getBean());
}
@Override protected void onError(Event event, String postType) {
if (postType.equals(POST_LOAD_MORE)) {
toast("加载更多失败");
} else if (postType.equals(POST_REFRESH)) {
toast("刷新数据失败");
}
}
}
6.1.1代码中第一段都无法理解：public abstract class SimpleRefreshRecyclerFragment<T,Event extends BaseEvent<List<T>>> extends RefreshRecyclerFragment<T,Event>。
首先理解一下这个BaseEvent。
/**
* 所有 Event 的基类
* <p>
* T 为对应的实体类
* <p>
* HTTP Status
* -1 - 可能是网络未连接
* 200, 201 - 请求成功，或执行成功
* 400 - 参数不符合 API 的要求、或者数据格式验证没有通过，请配合 Response Body 里面的 error 信息确定问题。
* 401 - 用户认证失败，或缺少认证信息，比如 access_token 过期，或没传，可以尝试用 refresh_token 方式获得新的 access_token。
* 403 - 当前用户对资源没有操作权限
* 404 - 资源不存在。
* 500 - 服务器异常
*/
然后它继承了一个RefreshRecycleFragment<T,Event>，这个也是在这个项目中的一个类，贴一下这个Fragment代码吧。
/*
* Copyright 2017 GcsSloop
*
* 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.
*
* Last modified 2017-04-09 21:16:47
*
* GitHub: https://github.com/GcsSloop
* Website: http://www.gcssloop.com
* Weibo: http://weibo.com/GcsSloop
*/
package com.gcssloop.diycode.fragment.base;
import android.content.Context;
import android.support.annotation.NonNull;
import android.support.v4.util.ArrayMap;
import android.support.v4.widget.SwipeRefreshLayout;
import android.support.v7.widget.RecyclerView;
import android.view.View;
import com.gcssloop.diycode.R;
import com.gcssloop.diycode.base.app.ViewHolder;
import com.gcssloop.diycode.fragment.bean.Footer;
import com.gcssloop.diycode.fragment.provider.FooterProvider;
import com.gcssloop.diycode_sdk.api.base.event.BaseEvent;
import com.gcssloop.recyclerview.adapter.multitype.HeaderFooterAdapter;
import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;
import java.util.List;
import static android.support.v7.recyclerview.R.styleable.RecyclerView;
/**
* 具有下拉刷新和上拉加载的 Fragment
*/
public abstract class RefreshRecyclerFragment<T, Event extends BaseEvent<List<T>>> extends
BaseFragment {
// 请求状态 - 下拉刷新 还是 加载更多
public static final String POST_LOAD_MORE = "load_more";
public static final String POST_REFRESH = "refresh";
private ArrayMap<String, String> mPostTypes = new ArrayMap<>(); // 请求类型
// 当前状态
private static final int STATE_NORMAL = 0; // 正常
private static final int STATE_NO_MORE = 1; // 正在
private static final int STATE_LOADING = 2; // 加载
private static final int STATE_REFRESH = 3; // 刷新
private int mState = STATE_NORMAL;
// 分页加载
protected int pageIndex = 0; // 当面页码
protected int pageCount = 20; // 每页个数
// View
private SwipeRefreshLayout mRefreshLayout;
protected RecyclerView mRecyclerView;
// 状态
private boolean refreshEnable = true; // 是否允许刷新
private boolean loadMoreEnable = true; // 是否允许加载
// 适配器
protected HeaderFooterAdapter mAdapter;
protected FooterProvider mFooterProvider;
protected boolean isFirstAddFooter = true;
@Override
protected int getLayoutId() {
return R.layout.fragment_refresh_recycler;
}
@Override
protected void initViews(ViewHolder holder, View root) {
// 适配器
mAdapter = new HeaderFooterAdapter();
mFooterProvider = new FooterProvider(getContext()) {
@Override
public void needLoadMore() {
if (isFirstAddFooter) {
isFirstAddFooter = false;
return;
}
loadMore();
}
};
mFooterProvider.setFooterNormal();
mAdapter.registerFooter(new Footer(), mFooterProvider);
// refreshLayout
mRefreshLayout = holder.get(R.id.refresh_layout);
mRefreshLayout.setProgressViewOffset(false, -20, 80);
mRefreshLayout.setColorSchemeColors(getResources().getColor(R.color.diy_red));
mRefreshLayout.setEnabled(true);
// RecyclerView
mRecyclerView = holder.get(R.id.recycler_view);
mRecyclerView.setHasFixedSize(true);
mRecyclerView.setAdapter(mAdapter);
mRecyclerView.setLayoutManager(getRecyclerViewLayoutManager());
setAdapterRegister(getContext(), mRecyclerView, mAdapter);
// 监听 RefreshLayout 下拉刷新
mRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
@Override
public void onRefresh() {
refresh();
}
});
initData(mAdapter);
}
protected void refresh() {
if (!refreshEnable) return;
pageIndex = 0;
String uuid = request(pageIndex * pageCount, pageCount);
mPostTypes.put(uuid, POST_REFRESH);
pageIndex++;
mState = STATE_REFRESH;
}
protected void loadMore() {
if (!loadMoreEnable) return;
if (mState == STATE_NO_MORE) return;
String uuid = request(pageIndex * pageCount, pageCount);
mPostTypes.put(uuid, POST_LOAD_MORE);
pageIndex++;
mState = STATE_LOADING;
mFooterProvider.setFooterLoading();
}
@Subscribe(threadMode = ThreadMode.MAIN)
public void onResultEvent(Event event) {
String postType = mPostTypes.get(event.getUUID());
if (event.isOk()) {
if (postType.equals(POST_LOAD_MORE)) {
onLoadMore(event);
} else if (postType.equals(POST_REFRESH)) {
onRefresh(event);
}
} else {
onError(event);
}
mPostTypes.remove(event.getUUID());
}
protected void onRefresh(Event event) {
mState = STATE_NORMAL;
mRefreshLayout.setRefreshing(false);
onRefresh(event, mAdapter);
}
protected void onLoadMore(Event event) {
if (event.getBean().size() < pageCount) {
mState = STATE_NO_MORE;
mFooterProvider.setFooterNormal();
} else {
mState = STATE_NORMAL;
mFooterProvider.setFooterNormal();
}
onLoadMore(event, mAdapter);
}
protected void onError(Event event) {
mState = STATE_NORMAL; // 状态重置为正常，以便可以重试，否则进入异常状态后无法再变为正常状态
String postType = mPostTypes.get(event.getUUID());
if (postType.equals(POST_LOAD_MORE)) {
mFooterProvider.setFooterError(new View.OnClickListener() {
@Override
public void onClick(View v) {
pageIndex--;
loadMore();
}
});
} else if (postType.equals(POST_REFRESH)) {
mRefreshLayout.setRefreshing(false);
mFooterProvider.setFooterNormal();
}
onError(event, postType);
}
public void setRefreshEnable(boolean refreshEnable) {
this.refreshEnable = refreshEnable;
mRefreshLayout.setEnabled(refreshEnable);
}
public void setLoadMoreEnable(boolean loadMoreEnable) {
this.loadMoreEnable = loadMoreEnable;
}
public void quickToTop() {
mRecyclerView.smoothScrollToPosition(0);
}
@Override
public void onStart() {
super.onStart();
EventBus.getDefault().register(this);
}
@Override
public void onStop() {
super.onStop();
EventBus.getDefault().unregister(this);
}
//--- 需要继承类处理的部分 ----------------------------------------------------------------------
/**
* 加载数初始化数据，可以从缓存或者其他地方加载，
* 如果没有初始数据，一般调用 loadMore() 即可。
*
* @param adapter 适配器
*/
public abstract void initData(HeaderFooterAdapter adapter);
/**
* 为 RecyclerView 的 Adapter 注册数据类型
* 例如： adapter.register(Bean.class, new BeanProvider(getContext()));
*
* @param context 上下文
* @param recyclerView RecyclerView
* @param adapter Adapter
*/
protected abstract void setAdapterRegister(Context context, RecyclerView recyclerView,
HeaderFooterAdapter adapter);
/**
* 获取 RecyclerView 的 LayoutManager
* 例如： return new LinerLayoutManager(context);
*
* @return LayoutManager
*/
@NonNull protected abstract RecyclerView.LayoutManager getRecyclerViewLayoutManager();
/**
* 请求数据，并返回请求的 uuid
* 例如：return mDiycode.getTopicsList(null, mNodeId, offset, limit);
*
* @param offset 偏移量
* @param limit 请求数量
* @return uuid
*/
@NonNull protected abstract String request(int offset, int limit);
/**
* 数据刷新成功的回调，由于不同页面可能要对数据进行处理，例如重新排序，清理掉一些无效数据等，所以由子类自己实现，
* 如果不需要特殊处理，一般像下面这样写就行:
* adapter.clearDatas();
* adapter.addDatas(event.geiBean());
*
* @param event Event
* @param adapter Adapter
*/
protected abstract void onRefresh(Event event, HeaderFooterAdapter adapter);
/**
* 数据加载成功时调用，如果不需要对数据进行特殊处理，这样写就行：
* adapter.addDatas(event.getBean());
*
* @param event Event
* @param adapter Adapter
*/
protected abstract void onLoadMore(Event event, HeaderFooterAdapter adapter);
/**
* 数据加载错误时调用，你可以在这里获取错误类型并进行处理，如果不需要特殊处理，弹出一个 toast 提醒用户即可。
* if (postType.equals(POST_LOAD_MORE)) {
* toast("加载更多失败");
* } else if (postType.equals(POST_REFRESH)) {
* toast("刷新数据失败");
* }
*
* @param event
* @param postType
*/
protected abstract void onError(Event event, String postType);
}
然后这个RefreshRecylerFragment<T,Event extends BaseEvent<List<T>>>继承了一个BaseFragment，也是自己写的一个类。贴一下。
/*
* Copyright 2017 GcsSloop
*
* 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.
*
* Last modified 2017-04-09 21:16:47
*
* GitHub: https://github.com/GcsSloop
* Website: http://www.gcssloop.com
* Weibo: http://weibo.com/GcsSloop
*/
package com.gcssloop.diycode.fragment.base;
import android.os.Bundle;
import android.support.annotation.LayoutRes;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Toast;
import com.gcssloop.diycode.base.app.ViewHolder;
import com.gcssloop.diycode.utils.Config;
import com.gcssloop.diycode.utils.DataCache;
import com.gcssloop.diycode_sdk.api.Diycode;
/**
* 提供基础内容和生命周期控制
*/
public abstract class BaseFragment extends Fragment {
private ViewHolder mViewHolder; // View 管理
// 数据
protected Config mConfig; // 配置(状态信息)
protected Diycode mDiycode; // 在线(服务器)
protected DataCache mDataCache; // 缓存(本地)
@Override public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mConfig = Config.getSingleInstance();
mDiycode = Diycode.getSingleInstance();
mDataCache = new DataCache(getContext());
}
@LayoutRes
protected abstract int getLayoutId();
public ViewHolder getViewHolder() {
return mViewHolder;
}
@Nullable
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
mViewHolder = new ViewHolder(inflater, container, getLayoutId());
return mViewHolder.getRootView();
}
protected abstract void initViews(ViewHolder holder, View root);
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
initViews(mViewHolder, mViewHolder.getRootView());
}
protected void toast(String text) {
Toast.makeText(getContext(), text, Toast.LENGTH_SHORT).show();
}
}
BaseFragment中定义了4个变量。
这里有3个重要的类，Config定义在Utils中，DataCache也定义在Utils中，都是自己写的类，比较复杂，先不贴了。
然后在BaseFragement中还有一个onCreate函数，定义了一些初始化的东西。
然后定义了一个抽象函数，用来获得布局资源的id。
然后一个onCreateView函数，用来获得mViewHolder的。
然后又定义了一个抽象函数初始化ViewHolder的。在继承者中必须实现的。
然后执行到onActivityCreated，在 执行initViews()函数。
然后这里面定义一个toast函数。
好了，现在又回到RefreshRecyclerFragment中了。==>其实它的作用就是具有下拉刷新和上拉加载的Fragment。和数据一点耦合也没有。因为是继承BaseFragment的，只要实现BaseFragment的的两个抽象方法，用来处理数据，其实就是获得数据，然后利用这个可以下拉刷新和上拉加载的Fragment来处理即可。
然后这里面有两个适配器。
==>主要作用就是刷新的一些视图，比价刷新成功，加载失败，加载完毕等。
然后实现了BaseFragment中的抽象方法==>getLayoutId()，加载的布局文件为：R.layout.fragment_refresh_recycler==>代码如下：
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<android.support.v4.widget.SwipeRefreshLayout
android:id="@+id/refresh_layout"
android:layout_width="match_parent"
android:layout_height="match_parent">
<android.support.v7.widget.RecyclerView
android:id="@+id/recycler_view"
android:layout_width="match_parent"
android:layout_height="wrap_content"/>
</android.support.v4.widget.SwipeRefreshLayout>
</LinearLayout>
这里面有一个SwipeRefreshLayout其实就是那个下拉刷新的图标，id为：refresh_layout。
然后实现了BaseFragment中的抽象方法==>initViews(ViewHolder holder,View root)从适配器中获得数据。然后在RefreshRecyclerFragment修改了刷新图标的颜色和偏移量。
这里有布局中id叫做recycler_view的RecyclerView非常关键，如果没有setAdapter，那么所有数据都无法显示了。mAdapter事先注册了一个mFooterProvider数据的。
然后实现了两个抽象方法：
需要在继承者中实现。然后是监听RefreshLayout下拉刷新：
如何刷新呢？
request函数也是一个抽象函数，在继承者中具体实现。
然后是加载更多==>loadMore()
好像都是先一个request函数，返回一个字段，然后将这个字段放在本地的一个ArrayMap中，这个是请求类型，第二个字段是请求类型是“load_more”或者“refresh”。
这里使用了一个注解：@Subscribe(threadMode=ThreadMode.MAIN)==>表示该函数在主线程即UI线程中执行。
这里是返回事件，即成功刷新，或者成功加载，或者刷新失败，加载失败后的结果。
其实这里也只是过渡，其实还是没有处理数据，还是交给继承者来处理。真正的刷新和加载要和mAdapter挂钩的呢。
这里有一个onError方法，先处理一些状态，判断是刷新还是加载更多，真正的出错还要交给继承者来处理。
然后是设置一些基本方法，包括能否刷新，能否加载更多，能否到返回到顶部。
然后是进入onStart()和onStop()环节了。
==>EventBus是一个Android事件发布/订阅框架，通过解耦发布者和订阅者简化Android事件传递，这里的事件可以理解为消息。事件传递可以用于Android四大组件间通讯，也可以用于异步线程和主线程间通讯等。传统的事件传递方式包括：Handler,BroadcastReceiver,Interface回调，相比之下EventBus的特点是代码简洁，使用简单，并将事件发布和订阅充分解耦。
然后是需要继承类处理的部分
第一个抽象函数是加载初始化数据。
第二个抽象函数是注册数据类型。
第三个抽象函数获取RecyclerView的LayoutManager。
第四个抽象函数是：请求数据了，返回请求的uuid。
第五个抽象函数是onRefresh==>数据刷新成功后的回调。
第六个抽象函数是onLoadMore==>数据加载成功是的回调。
第七个抽象函数是：onError==>数据加载错误时调
6.1.2.回到SimpleRefreshRecyclerFragment。其实这三个类是一层接一层
==>BaseFragment->RefreshRecycleFragment->SimpleRefreshRecyclerFragment。
这个SimpleRefreshRecycleFragment也只是一个抽象类，所以虽然继承了RefreshRecycleFragment，但是并没有时间所有7个抽象方法，只实现了4个。
6.1.3.第一个是getRecyclerViewLayoutManager==>
这个SpeedyLinearLayoutManager是什么鬼？自己定义的一个类，附上源代码吧！
/*
* Copyright 2017 GcsSloop
*
* 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.
*
* Last modified 2017-04-10 20:16:42
*
* GitHub: https://github.com/GcsSloop
* Website: http://www.gcssloop.com
* Weibo: http://weibo.com/GcsSloop
*/
package com.gcssloop.recyclerview.layoutmanager;
import android.content.Context;
import android.graphics.PointF;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.LinearSmoothScroller;
import android.support.v7.widget.RecyclerView;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
/**
* 支持快速返回的 LinerLayoutManager
*/
public class SpeedyLinearLayoutManager extends LinearLayoutManager {
private static final float MILLISECONDS_PER_INCH = 6f; //default is 25f (bigger = slower)
public SpeedyLinearLayoutManager(Context context) {
super(context);
}
public SpeedyLinearLayoutManager(Context context, int orientation, boolean reverseLayout) {
super(context, orientation, reverseLayout);
}
public SpeedyLinearLayoutManager(Context context, AttributeSet attrs, int defStyleAttr, int
defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
}
@Override
public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state, int
position) {
final LinearSmoothScroller linearSmoothScroller = new LinearSmoothScroller(recyclerView
.getContext()) {
@Override
public PointF computeScrollVectorForPosition(int targetPosition) {
return SpeedyLinearLayoutManager.this.computeScrollVectorForPosition
(targetPosition);
}
@Override
protected float calculateSpeedPerPixel(DisplayMetrics displayMetrics) {
return MILLISECONDS_PER_INCH / displayMetrics.densityDpi;
}
};
linearSmoothScroller.setTargetPosition(position);
startSmoothScroll(linearSmoothScroller);
}
}
其实是自定义的LinearLayoutManager，这又是啥？ ==>就是一个线性布局管理器，这里用到快速到顶部。
这里复写3个构造函数，在Override一个smoothScrollToPosition函数即可。这是一个支持快速返回的LinearLayoutManager。
如下图是Override的smoothSrollToPosition函数。
这里有一个LinearSmoothScroller，作用就是决定视图滑动的一些属性。这里有一个MILLISECONDS_PER_INCH决定了滑动的速度。如果设置得很大的话，滑动的就比较慢，如果设置的值很小，滑动的速度就很快。
6.1.4.然后回到SimpleRefreshRecyclerFragment中，第二个Override的函数是onRefresh()，
adapter首先清空，然后添加数据。
这里先了解一下HeaderFooterAdapter。源代码如下：
/*
* Copyright 2017 GcsSloop
*
* 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.
*
* Last modified 2017-04-08 16:14:18
*
* GitHub: https://github.com/GcsSloop
* WeiBo: http://weibo.com/GcsSloop
* WebSite: http://www.gcssloop.com
*/
package com.gcssloop.recyclerview.adapter.multitype;
import android.support.annotation.NonNull;
import android.support.v7.widget.RecyclerView;
import android.view.ViewGroup;
import com.gcssloop.recyclerview.adapter.base.RecyclerViewHolder;
import java.util.ArrayList;
import java.util.List;
/**
* 带有头部和底部的适配器
* 使用步骤：
* 1. 创建实体类 Bean
* 2. 创建对应的 provider 并继承自 BaseViewProvider， 在对应的 provider 的 onBindView 里面处理内容
* 3. 使用 adapter.register(bean, provider.class) 来将数据实体和 provider 对应起来
* 4. 注册 Header 或者 Footer
* 5. 将数据 data 使用 ArrayList<Object> 类型存储起来， 使用 adapter.addDatas(data) 添加数据
* 6. 大功告成
*/
public class HeaderFooterAdapter extends RecyclerView.Adapter<RecyclerViewHolder>
implements TypePool {
private List<Object> mItems = new ArrayList<>();
private MultiTypePool mTypePool;
private boolean hasHeader = false;
private boolean hasFooter = false;
public HeaderFooterAdapter() {
mTypePool = new MultiTypePool();
}
@Override
public int getItemCount() {
assert mItems != null;
return mItems.size();
}
@Override
public int getItemViewType(int position) {
assert mItems != null;
Object item = mItems.get(position);
int index = mTypePool.indexOf(item.getClass());
if (index >= 0) {
return index;
}
return mTypePool.indexOf(item.getClass());
}
@Override
public void register(@NonNull Class<?> clazz, @NonNull BaseViewProvider provider) {
mTypePool.register(clazz, provider);
}
public void registerHeader(@NonNull Object object, @NonNull BaseViewProvider provider) {
if (hasHeader) return;
mTypePool.register(object.getClass(), provider);
mItems.add(0, object);
hasHeader = true;
notifyDataSetChanged();
}
public void unRegisterHeader() {
if (!hasHeader) return;
mItems.remove(0);
hasHeader = false;
notifyDataSetChanged();
}
public void registerFooter(@NonNull Object object, @NonNull BaseViewProvider provider) {
if (hasFooter) return;
mTypePool.register(object.getClass(), provider);
mItems.add(object);
hasFooter = true;
notifyDataSetChanged();
}
public void unRegisterFooter() {
if (!hasFooter) return;
mItems.remove(mItems.size() - 1);
hasFooter = false;
notifyDataSetChanged();
}
@Override
public RecyclerViewHolder onCreateViewHolder(ViewGroup parent, int indexViewType) {
BaseViewProvider provider = getProviderByIndex(indexViewType);
return provider.onCreateViewHolder(parent);
}
@Override
public void onBindViewHolder(RecyclerViewHolder holder, int position) {
assert mItems != null;
Object item = mItems.get(position);
BaseViewProvider provider = getProviderByClass(item.getClass());
provider.onBindView(holder, item);
}
@Override
public int indexOf(@NonNull Class<?> clazz) {
return mTypePool.indexOf(clazz);
}
@Override
public List<BaseViewProvider> getProviders() {
return mTypePool.getProviders();
}
@Override
public BaseViewProvider getProviderByIndex(int index) {
return mTypePool.getProviderByIndex(index);
}
@Override
public <T extends BaseViewProvider> T getProviderByClass(@NonNull Class<?> clazz) {
return mTypePool.getProviderByClass(clazz);
}
public void addDatas(List<?> items) {
if (hasFooter) {
mItems.addAll(mItems.size() - 1, items);
} else {
mItems.addAll(items);
}
notifyDataSetChanged();
}
/**
* 获取纯数据 (不包含 Header 和 Footer)
*/
public List<Object> getDatas() {
int startIndex = 0;
int endIndex = mItems.size();
if (hasHeader) {
startIndex++;
}
if (hasFooter) {
endIndex--;
}
return mItems.subList(startIndex, endIndex);
}
/**
* 获取全部数据 (包含 Header 和 Footer)
*/
public List<Object> getFullDatas() {
return mItems;
}
public void clearDatas() {
int startIndex = 0;
int endIndex = mItems.size();
if (hasHeader) {
startIndex++;
}
if (hasFooter) {
endIndex--;
}
for (int i = endIndex - 1; i >= startIndex; i--) {
mItems.remove(i);
}
notifyDataSetChanged();
}
}
这是一个带有头部和底部的适配器。这个类其实是在另外一个模块中的。现在先不了解了。
这里之后直接用adapter.addDatas(event.getBean)添加了数据。注意：这里不仅仅只是添加了一个bean，而是一个List<T>，所以可能会有很多数据都放在这里面了。而adapter只要调用一个addDatas方法就行了。
6.1.5.然后是一个onLoadMore方法。
6.1.6.最后是一个onError方法。
6.2.终于回到NodeTopicListFragment中了。它继承了一个Topic的bean类。看一下Topic的定义吧。
/*
* Copyright 2017 GcsSloop
*
* 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.
*
* Last modified 2017-03-08 01:01:18
*
* GitHub: https://github.com/GcsSloop
* Website: http://www.gcssloop.com
* Weibo: http://weibo.com/GcsSloop
*/
package com.gcssloop.diycode_sdk.api.topic.bean;
import com.gcssloop.diycode_sdk.api.base.bean.Abilities;
import com.gcssloop.diycode_sdk.api.user.bean.User;
import java.io.Serializable;
/**
* topic 简略信息
*/
public class Topic implements Serializable {
private int id; // 唯一 id
private String title; // 标题
private String created_at; // 创建时间
private String updated_at; // 更新时间
private String replied_at; // 最近一次回复时间
private int replies_count; // 回复总数量
private String node_name; // 节点名称
private int node_id; // 节点 id
private int last_reply_user_id; // 最近一次回复的用户 id
private String last_reply_user_login; // 最近一次回复的用户登录名
private User user; // 创建该话题的用户(信息)
private boolean deleted; // 是否是被删除的
private boolean excellent; // 是否是加精的
private Abilities abilities; // 当前用户对该话题拥有的权限
public void setId(int id) {
this.id = id;
}
public int getId() {
return this.id;
}
public void setTitle(String title) {
this.title = title;
}
public String getTitle() {
return this.title;
}
public void setCreated_at(String created_at) {
this.created_at = created_at;
}
public String getCreated_at() {
return this.created_at;
}
public void setUpdated_at(String updated_at) {
this.updated_at = updated_at;
}
public String getUpdated_at() {
return this.updated_at;
}
public void setReplied_at(String replied_at) {
this.replied_at = replied_at;
}
public String getReplied_at() {
return this.replied_at;
}
public void setReplies_count(int replies_count) {
this.replies_count = replies_count;
}
public int getReplies_count() {
return this.replies_count;
}
public void setNode_name(String node_name) {
this.node_name = node_name;
}
public String getNode_name() {
return this.node_name;
}
public void setNode_id(int node_id) {
this.node_id = node_id;
}
public int getNode_id() {
return this.node_id;
}
public void setLast_reply_user_id(int last_reply_user_id) {
this.last_reply_user_id = last_reply_user_id;
}
public int getLast_reply_user_id() {
return this.last_reply_user_id;
}
public void setLast_reply_user_login(String last_reply_user_login) {
this.last_reply_user_login = last_reply_user_login;
}
public String getLast_reply_user_login() {
return this.last_reply_user_login;
}
public void setUser(User user) {
this.user = user;
}
public User getUser() {
return this.user;
}
public void setDeleted(boolean deleted) {
this.deleted = deleted;
}
public boolean getDeleted() {
return this.deleted;
}
public void setExcellent(boolean excellent) {
this.excellent = excellent;
}
public boolean getExcellent() {
return this.excellent;
}
public void setAbilities(Abilities abilities) {
this.abilities = abilities;
}
public Abilities getAbilities() {
return this.abilities;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Topic)) {
return false;
}
Topic temp = (Topic) obj;
if (temp.getId() == getId()) {
return true;
}
return false;
}
}
这个也是在diycode_sdk中的API中定义的。
总共有14个信息。这里面有一个Override==>判断一个对象是否是Topic。
6.3.==>T对应Topic，==>GetTopicsListEvent对应BaseEvent<List<Topic>>(其实GetTopicsListEvent就是继承BaseEvent<List<Topic>>的)，这些在sdk-API中已经表现，就不深究了。
6.4.首先一个静态方法==>newInstance(int nodeId)返回一个NodeTopicListFragment。
返回一个fragment,可以知道，这个Fragment已经具备了下拉刷新，上拉加载更多的功能。具备了返回到顶部的功能。具备了toast功能。
6.5.实现了在RefreshRecycleFragment中定义的抽象方法==>initData()
6.6.实现了在RefreshRecycleFragment中定义的抽象方法==>setAdapterRegister()
6.7.实现在RefreshRecycleFragment中定义的抽象方法==>request(),这里是调用API了。
7.回到TopicActivity中。进入initViews方法。
其实NodeTopicListFragment就是一个Fragment，可以刷新和加载更多的Fragment，同时也设置了Adapter的注册数据类型，还利用API调用了请求方法。
8.Android Fragment动态添加 ==>就是将上面那个碎片添加到topicActivity中。
总结一下吧：
1.首先这个TopicActivity是继承一个BaseActivity的。就是一个标题栏中左上角，其实这个BaseActivity就是处理标题栏的吧。
2.然后又一个关键的静态函数newInstance，就是实例化一个Topic吧。可能是外部函数想调用话题这个活动，这个函数的意义就是跳转到话题这个活动。
3.然后是得到布局的id，这个也是BaseActivity中定义的抽象函数，就是整个界面的布局函数，有一个Toolbar，然后是一个FrameLayout占据了其他所有空间。
4.然后是实现了BaseActivity中定义的抽象函数，初始化视图，将多次继承的fragment赋给这个FrameLayout。就是将碎片给到这个FrameLayout。采用了动态添加方法。
5.其实，事先，要从Intent中获得NodeId，才能利用这个NodeId，获得相应的碎片，调用了NodeTopicListFragment的newInstance方法，NodeId就是里面的参数。然后从Intent从获得的NodeName作为标题栏的Title。
6.这个NodeTopicListFragment其实是非常复杂的，它首先是继承了SimpleRefreshRecyclerFragment<Topic,GetTopicsListEvent>类的，这个SimpleRefreshRecyclerFragment是有一个静态的newInstanse方法，供别人调用。然后是实现了3个抽象方法，分别是initData()，setAdapterRegister()，request()三个函数。
7.SimpleRefreshRecyclerFragment继承了RefreshRecyclerFragment<T,Event>这个Event是从它自己的构造函数中的Event extends BaseEvent<List<T>>获得的，然后这个BaseEvent其实是API中定义的。然后这个SimpleRefreshRecyclerFragment实现了4个抽象方法，都是和加载或者刷新有关系的。
8.RefreshRecyclerFragment<T,Event extends BaseEvent<List<T>>> 继承了BaseFragment。它是一个具有下拉刷新和上拉加载的Fragment。这个类比较关键，定义了很多抽象函数。主要处理刷新和加载的根本逻辑。包括刷新的图标的颜色，一页最多有多少个数据行。刷新后的状态的变更，和加载成功或者失败后状态的变更。以及EventBus的注册和解注册。
9.BaseFragment就是继承Fragment的了。这个就是最基本的碎片了。里面有一个配置状态信息的Config类。有一个在线服务器Diycode类，有一个DataCache缓存本地数据的类。然后定义了两个抽象方法和一个onCreateView函数获得ViewHolder，一个onCreate函数初始化一些数据，onActivityCreate函数初始化视图。
10.其实这个TopicActivity和很多东西挂钩，现在了解了最外层的东西，知道了基本流程，但是很多细节还是要深究一下，比如刷新和加载，还有自定义的Adapter都是涉及到的东西比较多的。