记得在2013年12月的时候，有系列文章是介绍怎么开发一个智能手表的app，让用户可以在足球比赛中记录停表时间。随着android wear的问世，在可穿戴设备中开发一款这样的app确实是个很不错的想法，但是按照目前对于android wear的架构了解来说，似乎有些困难。所以本系列文章我们就重写这个应用，带领大家进入android wear的世界。
本文不会长篇大论地讲解我们要开发的这款app的用途，因为我们在之前的系列文章已经深入了解过了。这么说吧，这是一个计时类应用，在比赛开始的时候开始执行，在比赛的过程中可以暂停（停表），然后45分钟过去后会有震动提醒，然后比赛进行45分钟后也会有提醒。
在开始之前，很有必要先看看我们为什么要重写这个app而不是直接上代码。智能手表使用的是一个修改版的android1.6的系统，所以它的架构很像一个运行android1.6的手机，所以我们的app基于一个activity，我们所有的工作都运行在这个activity上。在开始学习智能手表开发之前，我们必须很清楚地知道，我们之前的设计在android wear上并不适用，尽管它也是支持activity，但是在android wear上工作方式是不同的。在手机或者平板上，如果一个activity从sleep状态回到唤醒状态，activity会被重新唤醒，但是在wear上却不是这样。一段时间过去后wear设备会进入sleep，但是在设备唤醒后，处于sleep状态的activity却不会再被唤醒了。
首先这个问题使我非常惊讶，我一直很想知道activity有了这个限制后，还能开发实用的app吗？后来才发现这个问题完全是多虑的，我渐渐地发现，要开发一个实用的app也很简单——我们只需要转变我们的软件设计模式，使它更符合android wear的体系结构，而不是当做一个手机来看。
这里我们需要考虑的最基本的问题是，这个计时应用程序需要基于一个一直运行的服务来记录时间。但是基于长运行的服务不是一个好的方案，因为它会耗电。这里我们提到的记录时间这个关键词，也就是说，我们并不需要真的实现一个长运行的服务，只要在用户需要看的时候我们可以更新消息显示就行。在大部分的时间里，其实用户只需要了解大概过去了多长时间，只有在比赛暂停或者中场快结束的时候才需要显示更详细的信息。所以在大部分的时间里，我们只需要显示精确到分钟即可，然后在用户需要的时候才精确到秒。
我们要实现这个方法的基本方法就是使用alarmmanager每分钟触发一次更新通知事件，去更新分钟显示。这个通知事件还包括显示精确到秒的activity，但是只有在用户滑动屏幕的时候才会显示整个通知。通过这种方式我们可以在必须显示的时候才去更新消息，所以对大部分设备来说，每分钟更新一次消息显示比一直运行一个服务更加省电。
下图显示充分证明了这点，首先我们需要打开通知，这样就可以得到精确到秒的显示了。
然而，在有信息显示或者设备休眠的时候，我们只需要显示精确到分钟就可以了。
有一件事情需要说明一下，就是这个app的名字已经改变了。之前在在i'm watch的版本上叫做“footy timer”，现在改为“match timer”。因为在使用语音启动app的时候，google的声音识别对“footy”这个词很不敏感，我们用“ok google，start footy timer”这个命令不能启动应用，而使用“ok google，start match timer”就可以使用。
最后，很抱歉这篇文章没有代码，但是本系列文章会稍微有些变动。以前本人会在每篇文章末尾附上文章相关的代码段，这个请放心，之后的文章还是会这样的，因为这个是一个功能完善的app，而不是系列技术文章，所以在接下来的文章会包含一些代码示例和注释，在本系列文章完结的时候会附上整个项目的源码。
match timer 可以在google play上找到：https://play.google.com/store/apps/details?id=com.stylingandroid.matchtimer
上面我们解释了为什么要在android wear重写这个计时器app（因为之前已经在“i'm watch”里面开发过了），下面我们就来看看代码。
我们以这个app的一个核心类开始，这个类负责控制计时器的状态。这个类包含了4个long类型的变量：第一个代表计时器开始的时间；第二个代表计时器停止的时间（在运行中的话，它就是0）；第三个代表计时器停表的时间（如果当前没有停表，那它也是0），第四个代表总共停表的时长。通过这四个变量我们就可以维持计时器的状态了，还可以通过计算得到我们需要展示的其他信息。这个类的基本功能就是都是为了操作这些变量，即维持计时器的这些状态。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
public final class matchtimer {
.
.
.
public static final int minute_millis = 60000;
private long start;
private long currentstoppage;
private long totalstoppages;
private long end;
.
.
.
public long getelapsed() {
if (isrunning()) {
return system.currenttimemillis() - start;
}
if (end > 0) {
return end - start;
}
return 0;
}
public boolean isrunning() {
return start > 0 && end == 0;
}
public boolean ispaused() {
return currentstoppage > 0;
}
public int getelapsedminutes() {
return (int) ((system.currenttimemillis() - start) / minute_millis);
}
public long gettotalstoppages() {
long now = system.currenttimemillis();
if (ispaused()) {
return totalstoppages + (now - currentstoppage);
}
return totalstoppages;
}
public long getplayed() {
return getelapsed() - gettotalstoppages();
}
public long getstarttime() {
return start;
}
.
.
.
}
|
这些都是基本的java代码，就不费时间讲了。下面的函数更高级一些，可以操作计时器的状态。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
public final class matchtimer {
.
.
.
public void start() {
if (end > 0) {
start = system.currenttimemillis() - (end - start);
end = 0;
} else {
start = system.currenttimemillis();
}
save();
}
public void stop() {
if (ispaused()) {
resume();
}
end = system.currenttimemillis();
save();
}
public void pause() {
currentstoppage = system.currenttimemillis();
save();
}
public void resume() {
totalstoppages += system.currenttimemillis() - currentstoppage;
currentstoppage = 0l;
save();
}
public void reset() {
resetwithoutsave();
save();
}
private void resetwithoutsave() {
start = 0l;
currentstoppage = 0l;
totalstoppages = 0l;
end = 0l;
}
}
|
这些还是基本的java代码，也可以不用讲了。只有save()方法我们还没有见到，这是在类的最后写的，这个函数才值得的我们讲讲。
前一篇文章我们讨论了关于唤醒机制的问题，我们不需要去维持一个长连接或者后台服务，只需要维持这几个计时器的状态就可以了。我们使用sharedpreference来实现：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
public final class matchtimer implements sharedpreferences.onsharedpreferencechangelistener {
private static final string key_start = "com.stylingandroid.matchtimer.key_start";
private static final string key_current_stoppage = "com.stylingandroid.matchtimer.key_current_stoppage";
private static final string key_total_stoppages = "com.stylingandroid.matchtimer.key_total_stoppages";
private static final string key_end = "com.stylingandroid.matchtimer.key_end";
private static final string preferences = "matchtimer";
private final sharedpreferences preferences;
public static matchtimer newinstance(context context) {
sharedpreferences preferences = context.getsharedpreferences(preferences, context.mode_private);
long start = preferences.getlong(key_start, 0);
long currentstoppage = preferences.getlong(key_current_stoppage, 0);
long totalstoppages = preferences.getlong(key_total_stoppages, 0);
long end = preferences.getlong(key_end, 0);
return new matchtimer(preferences, start, currentstoppage, totalstoppages, end);
}
private matchtimer(sharedpreferences preferences, long start, long currentstoppage, long totalstoppages, long end) {
this.preferences = preferences;
this.start = start;
this.currentstoppage = currentstoppage;
this.totalstoppages = totalstoppages;
this.end = end;
}
public void save() {
preferences.edit()
.putlong(key_start, start)
.putlong(key_current_stoppage, currentstoppage)
.putlong(key_total_stoppages, totalstoppages)
.putlong(key_end, end)
.apply();
}
public void registerforupdates() {
preferences.registeronsharedpreferencechangelistener(this);
}
public void unregisterforupdates() {
preferences.unregisteronsharedpreferencechangelistener(this);
}
@override
public void onsharedpreferencechanged(sharedpreferences sharedpreferences, string key) {
long value = sharedpreferences.getlong(key, 0l);
if (key.equals(key_start)) {
start = value;
} else if (key.equals(key_end)) {
end = value;
} else if (key.equals(key_current_stoppage)) {
currentstoppage = value;
} else if (key.equals(key_total_stoppages)) {
totalstoppages = value;
}
}
.
.
.
}
|
我们需要的就是newinstance()方法从sharedpreference中构造一个matchtimer实例，我们还需要save()方法，可以帮我们把当前的计时器状态保存到sharedpreference中。
最后我们要说明的是，如果某一部分持有matchtimer对象的引用，但是其他对象已经改变了计时器的状态，就可能会发生异常（见下一篇文章）。所以我们还需要提供一些方法去注册和注销matchtimer的实例，在sharedpreference的值改变时去接收计时器状态的变化。
现在我们已经定义了一个基本的计时器了，下一篇文章我们会介绍怎么保持计时器的状态以及在需要的时候去唤醒这些状态。
match timer 可以在google play上下载：match timer.
在本系列前几篇文章中，我们介绍了android wear计时器app，对设计思路和app的结构进行了分析。本文将讲解如何定时唤醒程序提醒用户。
对于为什么不用后台服务的方式一直运行，我们已经进行了解释——这种方式非常耗电。因此，我们必须要有一个定时唤醒机制。我们可以使用alarmmanager来实现这个机制，定时执行一个intent，然后通知broadcastreceiver。之所以选择broadcastreceiver而不用intentservice，是因为我们要运行的任务是轻量级的而且生命周期非常短暂。使用broadcastreceiver可以避免每次执行任务的时候都经历service的整个生命周期。因此，对于我们这种轻量级的任务来说非常合适——我们执行的任务都在毫秒级。
broadcastreceiver的核心在于onreceiver方法，我们需要在这里安排各种事件响应。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
public class matchtimerreceiver extends broadcastreceiver {
public static final int minute_millis = 60000;
private static final long duration = 45 * minute_millis;
private static final intent update_intent = new intent(action_update);
private static final intent elapsed_alarm = new intent(action_elapsed_alarm);
private static final intent full_time_alarm = new intent(action_full_time_alarm);
private static final int request_update = 1;
private static final int request_elapsed = 2;
private static final int request_full_time = 3;
public static void setupdate(context context) {
context.sendbroadcast(update_intent);
}
.
.
.
private void reset(matchtimer timer) {
timer.reset();
}
private void resume(context context, matchtimer timer) {
timer.resume();
long playedend = timer.getstarttime() + timer.gettotalstoppages() + duration;
if (playedend > system.currenttimemillis()) {
setalarm(context, request_full_time, full_time_alarm, playedend);
}
}
private void pause(context context, matchtimer timer) {
timer.pause();
cancelalarm(context, request_full_time, full_time_alarm);
long elapsedend = timer.getstarttime() + duration;
if (!isalarmset(context, request_elapsed, elapsed_alarm) && elapsedend > system.currenttimemillis()) {
setalarm(context, request_elapsed, elapsed_alarm, elapsedend);
}
}
private void stop(context context, matchtimer timer) {
timer.stop();
cancelalarm(context, request_update, update_intent);
cancelalarm(context, request_elapsed, elapsed_alarm);
cancelalarm(context, request_full_time, full_time_alarm);
}
private void start(context context, matchtimer timer) {
timer.start();
long elapsedend = timer.getstarttime() + duration;
setrepeatingalarm(context, request_update, update_intent);
if (timer.gettotalstoppages() > 0 && !timer.ispaused()) {
long playedend = timer.getstarttime() + timer.gettotalstoppages() + duration;
if (playedend > system.currenttimemillis()) {
setalarm(context, request_full_time, full_time_alarm, playedend);
}
if (elapsedend > system.currenttimemillis()) {
setalarm(context, request_elapsed, elapsed_alarm, elapsedend);
}
} else {
if (elapsedend > system.currenttimemillis()) {
setalarm(context, request_full_time, full_time_alarm, elapsedend);
}
}
}
.
.
.
}
|
代码还是非常直观易于理解的。首先实例化一个matchtimer对象（从sharedpreference中读取数据），然后分别传给对应的事件处理handler。之后等待动作发生，最后更新notification。
这里会处理8个事件动作，其中5个负责控制计时器的状态（start、stop、pause、resume、reset）；一个负责更新notification，剩下两个负责到45分钟唤醒后震动提示。
我们先从这几个控制状态开始：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
public class matchtimerreceiver extends broadcastreceiver {
public static final int minute_millis = 60000;
private static final long duration = 45 * minute_millis;
private static final intent update_intent = new intent(action_update);
private static final intent elapsed_alarm = new intent(action_elapsed_alarm);
private static final intent full_time_alarm = new intent(action_full_time_alarm);
private static final int request_update = 1;
private static final int request_elapsed = 2;
private static final int request_full_time = 3;
public static void setupdate(context context) {
context.sendbroadcast(update_intent);
}
.
.
.
private void reset(matchtimer timer) {
timer.reset();
}
private void resume(context context, matchtimer timer) {
timer.resume();
long playedend = timer.getstarttime() + timer.gettotalstoppages() + duration;
if (playedend > system.currenttimemillis()) {
setalarm(context, request_full_time, full_time_alarm, playedend);
}
}
private void pause(context context, matchtimer timer) {
timer.pause();
cancelalarm(context, request_full_time, full_time_alarm);
long elapsedend = timer.getstarttime() + duration;
if (!isalarmset(context, request_elapsed, elapsed_alarm) && elapsedend > system.currenttimemillis()) {
setalarm(context, request_elapsed, elapsed_alarm, elapsedend);
}
}
private void stop(context context, matchtimer timer) {
timer.stop();
cancelalarm(context, request_update, update_intent);
cancelalarm(context, request_elapsed, elapsed_alarm);
cancelalarm(context, request_full_time, full_time_alarm);
}
private void start(context context, matchtimer timer) {
timer.start();
long elapsedend = timer.getstarttime() + duration;
setrepeatingalarm(context, request_update, update_intent);
if (timer.gettotalstoppages() > 0 && !timer.ispaused()) {
long playedend = timer.getstarttime() + timer.gettotalstoppages() + duration;
if (playedend > system.currenttimemillis()) {
setalarm(context, request_full_time, full_time_alarm, playedend);
}
if (elapsedend > system.currenttimemillis()) {
setalarm(context, request_elapsed, elapsed_alarm, elapsedend);
}
} else {
if (elapsedend > system.currenttimemillis()) {
setalarm(context, request_full_time, full_time_alarm, elapsedend);
}
}
}
.
.
.
}
|
这些方法主要有两个功能：首先设置matchtimer的状态，然后设置时间提醒的闹铃，改变参数就可以播放闹铃。这个功能还可以封装成一个工具方法，叫setupdate()。这样外部也可以触发计时器的更新。
我们使用标准alarmmanager的方法来设置闹铃：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
public class matchtimerreceiver extends broadcastreceiver {
.
.
.
public static final int minute_millis = 60000;
.
.
.
private void setrepeatingalarm(context context, int requestcode, intent intent) {
alarmmanager alarmmanager = (alarmmanager) context.getsystemservice(context.alarm_service);
pendingintent pendingintent = pendingintent.getbroadcast(context, requestcode, intent, pendingintent.flag_update_current);
alarmmanager.setrepeating(alarmmanager.rtc_wakeup, system.currenttimemillis(), minute_millis, pendingintent);
}
private boolean isalarmset(context context, int requestcode, intent intent) {
return pendingintent.getbroadcast(context, requestcode, intent, pendingintent.flag_no_create) != null;
}
private void setalarm(context context, int requestcode, intent intent, long time) {
alarmmanager alarmmanager = (alarmmanager) context.getsystemservice(context.alarm_service);
pendingintent pendingintent = pendingintent.getbroadcast(context, requestcode, intent, pendingintent.flag_update_current);
alarmmanager.setexact(alarmmanager.rtc_wakeup, time, pendingintent);
}
private void cancelalarm(context context, int requestcode, intent intent) {
pendingintent pendingintent = pendingintent.getbroadcast(context, requestcode, intent, pendingintent.flag_no_create);
if (pendingintent != null) {
alarmmanager alarmmanager = (alarmmanager) context.getsystemservice(context.alarm_service);
alarmmanager.cancel(pendingintent);
pendingintent.cancel();
}
}
.
.
.
}
|
这里值得讨论的是setrepeatingalarm()这个方法。因为在wear在实现方式上有点不一样。我们会在start事件中每秒钟触发一次闹铃更新notification动作，所以这里需要记录具体已经过去了多少分钟。正常来说我们会每隔60秒触发一次这个动作，但是在wear上不能这么做。原因是——当设备在唤醒着的时候可以这样做，但是如果设备进入睡眠状态就需要重新计算下一分钟的边界值。这就需要异步更新部件，然后设备只需要每分钟唤醒一次。一分钟结束后在计时器需要更新状态的时候触发操作。
对于我们的计时器应用来说，显示的分钟数会比实际时间少1分钟。但是显示分钟并不要求非常实时（但显示秒数时需要非常精确），所以我们可以这样操作：
完整的alarm handler是这样使用振动服务的：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public class matchtimerreceiver extends broadcastreceiver {
.
.
.
private static final long[] elapsed_pattern = {0, 500, 250, 500, 250, 500};
private static final long[] full_time_pattern = {0, 1000, 500, 1000, 500, 1000};
private void elapsedalarm(context context) {
vibrator vibrator = (vibrator) context.getsystemservice(context.vibrator_service);
vibrator.vibrate(elapsed_pattern, -1);
}
private void fulltimealarm(context context) {
vibrator vibrator = (vibrator) context.getsystemservice(context.vibrator_service);
vibrator.vibrate(full_time_pattern, -1);
}
.
.
.
}
|
最后，我们通过这个方法来构造notification然后呈现给用户：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class matchtimerreceiver extends broadcastreceiver {
public static final int notification_id = 1;
.
.
.
private void updatenotification(context context, matchtimer timer) {
notificationbuilder builder = new notificationbuilder(context, timer);
notification notification = builder.buildnotification();
notificationmanagercompat notificationmanager = notificationmanagercompat.from(context);
notificationmanager.notify(notification_id, notification);
}
}
|
notification是wear计时器的一个重要的部分，这里还需要一个自定义类来构造这些notification通知。下一篇文章我们会讲如何在计时器app中使用notification。
match timer可以在google play上下载：match timer。