1.Android中计时
趁最近两周不忙，自己支配的时间比较多，正好查漏补缺，这两天看了些Thread的基础知识，正好工作有个需求就是要记时。就把想到的记录一下。
在Android中实现计时，有好几种方式，我用过的是单独开启一个Thread和利用Handler。单独开一个线程的话，没有办法直接进行UI更新，想到的依然是借助Handler。感觉还是直接利用Handler比较方便容易一下。效果图，简单还丑。 
2.本Demo中的MVP模式
通过最近的学习，对Android中使用MVP有一些了解，但并没在完整的实际项目开发中使用过。本demo中，也是通过网上的资料以及看Google官方的Demo中的MVP模式后加上自己个人的习惯所写。
我个人的习惯是：
1. 创建 BasePresenter、BaseView接口
2. 创建一个代理contract接口，里面写好Model、View、Presenter所要实现的接口
3. 创建Model
4. 创建Presenter
5. View层实现代理contract接口中的View的接口
2.1BasePresenter和BaseView接口
public interface BasePresenter {
void atFirst();
}
public interface BaseView<T> {
void bindPresenter(T presenter);
}这两个接口都很简单。BasePresenter中这个方法在本demo中并没有用到，是个空的方法，只做了声明并没有实现回调。这个方法可以用来初始化一些资源或者控件。BaseView使用了泛型T，目前对于泛型也只是会一些简单使用，深入的讲解不了。bindPresenter()这个方法顾名思义，就是将Presenter和View层关联起来。
2.2代理contract接口
这个代理接口的作用就是方便管理m，v,p各层的接口。还有个好处就是，一旦定好了方法，接下来的逻辑就会很清晰了，只需要实现这些方法就可以了。这里并不需要在意接口里我声明了哪些方法。看一下形式就可以。稍微需要注意的就是interface MainView extends BaseView<Presenter>这里的泛型
public interface MainContract {
interface MainBiz{
void onStartByHandler(onStartListener onStartListener);
void onStartByThread(onStartListener onStartListener);
void onStop(onStopListener onStopListener);
interface onStartListener{
void start(String time);
}
interface onStopListener{
void stop(String info,boolean b);
}
}
interface MainView extends BaseView<Presenter>{
void initView();
void onStop(String info,boolean b);
}
interface Presenter extends BasePresenter{
void startByHandler();
void startByThread();
void stop();
void initView(TextView tv);
void onRecycler();
}
}2.3创建桥梁Presenter
我并没有按照前面的顺序来，因为Model层里是逻辑关键，先把简单的层给介绍了。
public class MainPresenter implements MainContract.Presenter {
private MainContract.MainView view;
private MainModel model;
private TextView tv;
public static MainPresenter newInstance(MainContract.MainView view) {
return new MainPresenter(view);
}
public MainPresenter(MainContract.MainView view) {
this.view = view;
this.view.bindPresenter(this);
model = new MainModel();
}
@Override
public void initView(TextView tv) {
this.tv = tv;
}
@Override
public void startByHandler() {
model.onStartByHandler(new MainContract.MainBiz.onStartListener() {
@Override
public void start(String time) {
if (view != null) {
view.initView();
if (tv != null) {
tv.setText(time);
}
}
}
});
}
@Override
public void startByThread() {
model.onStartByThread(new MainContract.MainBiz.onStartListener() {
@Override
public void start(String time) {
if (view != null) {
view.initView();
if (tv != null) {
tv.setText(time);
}
}
}
});
}
@Override
public void stop() {
model.onStop(new MainContract.MainBiz.onStopListener() {
@Override
public void stop(String info, boolean b) {
if (view != null)
view.onStop(info, b);
}
});
}
@Override
public void onRecycler() {
if (model != null) model = null;
if (view != null) view = null;
}
@Override
public void atFirst() { }
}这里想说的也就两点，一个是构造方法，一个是onRecycler()方法。
Presnter是Model层和View层的桥梁。构造方法将3者给联系起来。
关于onRecycler()这个方法，我的目的是将创建的Model层、View层和Presenter层的对象置null，这样能被回收，不然这三个对象在内存并不会被回收。这个方法我会在Activity后者Frgment的onDestroy()调用。如果要用到了RecyclerView，可以再加上recyclerView.setAdapter(null)
然而，onRecycler()只是我的个人想法，我目前还没验证清楚，这个方法到底能不能起到些防止内存泄露的作用。若看博客的哪位对于有好的想法，请留言。
2.5View层实现MainContract.MainView接口
public class MainActivity extends AppCompatActivity implements MainContract.MainView {
private MainContract.Presenter presenter;
private Unbinder unbinder;
@BindView(R.id.tv_time_main_activity)
TextView tv;
@BindView(R.id.bt_handler_main_activity)
Button bt_handler;
@BindView(R.id.bt_thread_main_activity)
Button bt_thread;
@BindView(R.id.bt_stop_main_activity)
Button bt_stop;
private boolean isHasClicked = false;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
unbinder = ButterKnife.bind(this);
//初始化MainPresenter
MainPresenter.newInstance(this);
}
/**
* 点击Handler 按钮
*/
@OnClick(R.id.bt_handler_main_activity)
void onClickBtHandler() {
if (presenter != null && !isHasClicked) {
isHasClicked = true;
presenter.startByHandler();
}
}
/**
* 点击 Thread 按钮
*/
@OnClick(R.id.bt_thread_main_activity)
void onClickBtThread() {
if (presenter != null && !isHasClicked) {
isHasClicked = true;
presenter.startByThread();
}
}
/**
* 点击停止按钮
*/
@OnClick(R.id.bt_stop_main_activity)
void onClickBtStop() {
if (presenter != null) {
presenter.stop();
}
}
/**
* 点击按钮时 拿到显示时间的TextView
*/
@Override
public void initView() {
if (tv != null && presenter != null)
presenter.initView(tv);
}
/**
* 结束计时给出提示
*
* @param info
*/
@Override
public void onStop(String info, boolean b) {
isHasClicked = b;
ToastUtils.show(MainActivity.this, info);
}
@Override
public void bindPresenter(MainContract.Presenter presenter) {
this.presenter = presenter;
}
@Override
protected void onDestroy() {
super.onDestroy();
if (presenter != null) presenter.onRecycler();
if (unbinder != null) unbinder.unbind();
}
}
代码很简单，就是接口方法的回调。使用了ButterKnife省了findViewById(),setListener()
记得在合适的时机初始化MainPresenter就可以。
2.6Model层，实现计时逻辑
public class MainModel implements MainContract.MainBiz {
private onStartListener onStartListener;
private final int MSG_WHAT_HANDLER = 101;
private final int MSG_WHAT_THREAD = 102;
private int currentTime;
private int type = 0;
private final int TYPE_DEFAULT = 0;
private final int TYPE_HANDLER = 1;
private final int TYPE_THREAD = 2;
private final String THREAD_NAME = "thread_time";
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
if (msg.what == MSG_WHAT_HANDLER && onStartListener != null) {
onStartListener.start(TimeUitls.milliSecondToMinute(currentTime));
currentTime += 1000;
onStartByHandler(onStartListener);
} else if (msg.what == MSG_WHAT_THREAD && onStartListener != null) {
onStartListener.start(TimeUitls.milliSecondToMinute(currentTime));
currentTime += 1000;
}
}
};
/**
* 使用Handler方式
* @param onStartListener
*/
@Override
public void onStartByHandler(onStartListener onStartListener) {
if (this.onStartListener == null) {
this.onStartListener = onStartListener;
type = TYPE_HANDLER;
}
long now = SystemClock.uptimeMillis();
long next = now + (1000 - now % 1000);
handler.sendEmptyMessageAtTime(MSG_WHAT_HANDLER, next);
}
/**
* 使用单独开启线程
* @param onStartListener
*/
@Override
public void onStartByThread(onStartListener onStartListener) {
if (this.onStartListener == null) {
this.onStartListener = onStartListener;
type = TYPE_THREAD;
}
ThreadUtils.newThread(THREAD_NAME, new Runnable() {
@Override
public void run() {
while (ThreadUtils.isAlive(THREAD_NAME)) {
handler.sendEmptyMessage(MSG_WHAT_THREAD);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
@Override
public void onStop(onStopListener onStopListener) {
if (type == TYPE_DEFAULT) {
onStopListener.stop("计时还没有开始",false);
return;
}
if (type == TYPE_HANDLER) {
handler.removeMessages(MSG_WHAT_HANDLER);
} else if (type == TYPE_THREAD) {
ThreadUtils.killThread(THREAD_NAME);
}
onStopListener.stop("计时结束",false);
currentTime = 0;
onStartListener = null;
type = TYPE_DEFAULT;
}
}在onStartByHandler()方法中，Handler发送一个Message的方法用的是handler.sendEmptyMessageAtTime()，并没有使用handler.sendEmptyMessageDelayed()。这里是看了徐医生大神的博客强迫症的研究——MediaPlayer播放进度条的优化中学习到的一个知识点。long next = now + (1000 - now % 1000);这短短的一行代码可以有误差补偿的作用，算法这玩意果然好神奇。我也直接在Handler的handleMessage()方法中，在onStartByHandler(onStartListener)这句前，直接用Thread.sleep(500)验证了下，拿另外一个手机打开系统带的计时器，同时看两个手机，感觉两次计时的间隔还是1s，也可能是感觉不出来。但设置900后，就明显感觉到两次计时间隔不是1s了。这里还有待继续了解。但目前直接来用，是没有问题的。我把手机放在那不管，一直50分钟也没有问题。
在onStartByThread()方法中，就是开启一个子线程，每隔1s利用Handler发一个空消息。结束一个Thread，就是让run()方法结束就可以了，只需要将while()循环的条件改为false就可以。这里我简单实现了一个工具类，可以直接方便的更改循环条件。
3.最后
上篇博客说实现了两种计时后，就尝试自己来写一下多线程下载一个大文件。这正好可以用来学习Thread和I/O的知识。本打算明天就写的，但明天周末打算回家一趟。既然回家了，就不敲代码了。
代码