1.Android中计时

趁最近两周不忙,自己支配的时间比较多,正好查漏补缺,这两天看了些Thread的基础知识,正好工作有个需求就是要记时。就把想到的记录一下。

在Android中实现计时,有好几种方式,我用过的是单独开启一个Thread和利用Handler。单独开一个线程的话,没有办法直接进行UI更新,想到的依然是借助Handler。感觉还是直接利用Handler比较方便容易一下。效果图丑,简单。

PxdsbTrsc5oTahU6.png

计时

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的知识。本打算明天就写的,但明天周末打算回家一趟。既然回家了,就不敲代码了。最后,刚刚学会了一点Android Studio使用Git,就把本篇的代码放了上去。
代码

你可能感兴趣的内容
Android中远程Service浅析 收藏,4284 浏览
0条评论
EC

ecarrizo

这家伙太懒了,什么都没留下
Owner