Android Service更多的技巧

服务的更多技巧

使用前台服务

服务几乎都是在后台运行的，一直以来它都是默默地做着辛苦的工作。但是服务的系统优先级还是比较低的，当系统出现内存不足的情况时，就有可能会回收掉正在后台运行的服务。如果你希望服务可以一直保持运行状态，而不会由于系统内存不足的原因导致被回收，就可以考虑使用前台服务。前台服务和普通服务最大的区别就在于，它会一直有一个正在运行的图标在系统的状态栏显示，下拉状态栏后可以看到更加详细的信息，非常类似于通知的效果。当然有时候你也可能不仅仅是为了防止服务被回收掉才使用前台服务的，有些项目由于特殊的需求会要求必须使用前台服务，比如说墨迹天气，它的服务在后台更新天气数据的同时，还会在系统状态栏一直显示当前的天气信息，如图所示。

那么我们就来看一下如何才能创建一个前台服务吧，其实并不复杂，修改MyService中的代码，如下所示：

public class MyService extends Service {

……

@Override

public void onCreate() {

super.onCreate();

Notification notification = new Notification(R.drawable.ic_launcher,

"Notification comes", System. currentTimeMillis());

Intent notificationIntent = new Intent(this, MainActivity.class);

PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);

notification.setLatestEventInfo(this, "This is title", "This is content", pendingIntent);

startForeground(1, notification);

Log.d("MyService", "onCreate executed");

}

……

}

可以看到，这里只是修改了onCreate()方法中的代码，相信这部分的代码你会非常眼熟。没错！这就是我们在上一章中学习的创建通知的方法。只不过这次在构建出Notification对象后并没有使用NotificationManager来将通知显示出来，而是调用了startForeground()方法。这个方法接收两个参数，第一个参数是通知的id，类似于notify()方法的第一个参数，第二个参数则是构建出的Notification对象。调用startForeground()方法后就会让MyService变成一个前台服务，并在系统状态栏显示出来。

现在重新运行一下程序，并点击Start Service或Bind Service按钮，MyService就会以前台服务的模式启动了，并且在系统状态栏会显示一个通知图标，下拉状态栏后可以看到该通知的详细内容，如图所示。

前台服务的用法就这么简单，只要你在上一章中将通知的用法掌握好了，学习本节的知识一定会特别轻松。

9.5.2　使用IntentService

话说回来，在本章一开始的时候我们就已经知道，服务中的代码都是默认运行在主线程当中的，如果直接在服务里去处理一些耗时的逻辑，就很容易出现ANR（Application Not Responding）的情况。

所以这个时候就需要用到Android多线程编程的技术了，我们应该在服务的每个具体的方法里开启一个子线程，然后在这里去处理那些耗时的逻辑。因此，一个比较标准的服务就可以写成如下形式：

public class MyService extends Service {

@Override

public IBinder onBind(Intent intent) {

return null;

}

@Override

public int onStartCommand(Intent intent, int flags, int startId) {

new Thread(new Runnable() {  

        @Override  

        public void run() {  

            // 处理具体的逻辑

        }  

    }).start();

return super.onStartCommand(intent, flags, startId);

}

}

但是，这种服务一旦启动之后，就会一直处于运行状态，必须调用stopService()或者stopSelf()方法才能让服务停止下来。所以，如果想要实现让一个服务在执行完毕后自动停止的功能，就可以这样写：

public class MyService extends Service {

@Override

public IBinder onBind(Intent intent) {

return null;

}

@Override

public int onStartCommand(Intent intent, int flags, int startId) {

new Thread(new Runnable() {  

        @Override  

        public void run() {  

            // 处理具体的逻辑

        stopSelf();

        }  

    }).start();

return super.onStartCommand(intent, flags, startId);

}

}

虽说这种写法并不复杂，但是总会有一些程序员忘记开启线程，或者忘记调用stopSelf()方法。为了可以简单地创建一个异步的、会自动停止的服务，Android专门提供了一个IntentService类，这个类就很好地解决了前面所提到的两种尴尬，下面我们就来看一下它的用法。

新建一个MyIntentService类继承自IntentService，代码如下所示：

public class MyIntentService extends IntentService {

public MyIntentService() {

super("MyIntentService"); //调用父类的有参构造函数

}

@Override

protected void onHandleIntent(Intent intent) {

// 打印当前线程的id

Log.d("MyIntentService", "Thread id is " + Thread.currentThread(). getId());

}

@Override

public void onDestroy() {

super.onDestroy();

Log.d("MyIntentService", "onDestroy executed");

}

}

这里首先是要提供一个无参的构造函数，并且必须在其内部调用父类的有参构造函数。然后要在子类中去实现onHandleIntent()这个抽象方法，在这个方法中可以去处理一些具体的逻辑，而且不用担心ANR的问题，因为这个方法已经是在子线程中运行的了。这里为了证实一下，我们在onHandleIntent()方法中打印了当前线程的id。另外根据IntentService的特性，这个服务在运行结束后应该是会自动停止的，所以我们又重写了onDestroy()方法，在这里也打印了一行日志，以证实服务是不是停止掉了。

接下来修改activity_main.xml中的代码，加入一个用于启动MyIntentService这个服务的按钮，如下所示：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical" >

    ……

    <Button

        android:id="@+id/start_intent_service"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:text="Start IntentService" />

</LinearLayout>

然后修改MainActivity中的代码，如下所示：

public class MainActivity extends Activity implements OnClickListener {

……

private Button startIntentService;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

……

startIntentService = (Button) findViewById(R.id.start_intent_service);

startIntentService.setOnClickListener(this);

}

@Override

public void onClick(View v) {

switch (v.getId()) {

……

case R.id.start_intent_service:

// 打印主线程的id

Log.d("MainActivity", "Thread id is " + Thread.currentThread(). getId());

Intent intentService = new Intent(this, MyIntentService.class);

startService(intentService);

break;

default:

break;

}

}

}

可以看到，我们在Start IntentService按钮的点击事件里面去启动MyIntentService这个服务，并在这里打印了一下主线程的id，稍后用于和IntentService进行比对。你会发现，其实IntentService的用法和普通的服务没什么两样。

最后仍然不要忘记，服务都是需要在AndroidManifest.xml里注册的，如下所示：

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

    package="com.example.servicetest"

    android:versionCode="1"

    android:versionName="1.0" >

    ……

    <application

        android:allowBackup="true"

        android:icon="@drawable/ic_launcher"

        android:label="@string/app_name"

        android:theme="@style/AppTheme" >

        ……

        <service android:name=".MyIntentService"></service>

    </application>

</manifest>

现在重新运行一下程序，界面如图所示。

点击Start IntentService按钮后，观察LogCat中的打印日志，如图所示。

可以看到，不仅MyIntentService和MainActivity所在的线程id不一样，而且onDestroy()方法也得到了执行，说明MyIntentService在运行完毕后确实自动停止了。集开启线程和自动停止于一身，IntentService还是博得了不少程序员的喜爱。

好了，关于服务的知识点你已经学得够多了，下面就让我们进入到本章的最佳实践环节吧。

服务的最佳实践——后台执行的定时任务

好久已经没有来到最佳实践环节了，是不是有些想念了呢？本章中你已经掌握了关于服务非常多的使用技巧，但是当在真正的项目里需要用到服务的时候，可能还会有一些棘手的问题让你不知所措。因此，下面我们就来学习一下在服务中经常用到的技术之一，在后台执行定时任务。

Android中的定时任务一般有两种实现方式，一种是使用Java API里提供的Timer类，一种是使用Android的Alarm机制。这两种方式在多数情况下都能实现类似的效果，但Timer有一个明显的短板，它并不太适用于那些需要长期在后台运行的定时任务。我们都知道，为了能让电池更加耐用，每种手机都会有自己的休眠策略，Android手机就会在长时间不操作的情况下自动让CPU进入到睡眠状态，这就有可能导致Timer中的定时任务无法正常运行。而Alarm机制则不存在这种情况，它具有唤醒CPU的功能，即可以保证每次需要执行定时任务的时候CPU都能正常工作。需要注意，这里唤醒CPU和唤醒屏幕完全不是同一个概念，千万不要产生混淆。

那么首先我们来看一下Alarm机制的用法吧，其实并不复杂，主要就是借助了AlarmManager类来实现的。这个类和NotificationManager有点类似，都是通过调用Context的getSystemService()方法来获取实例的，只是这里需要传入的参数是Context.ALARM_SERVICE。因此，获取一个AlarmManager的实例就可以写成：

AlarmManager manager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);

接下来调用AlarmManager的set()方法就可以设置一个定时任务了，比如说想要设定一个任务在10秒钟后执行，就可以写成：

long triggerAtTime = SystemClock.elapsedRealtime() + 10 * 1000;

manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pendingIntent);

上面的两行代码你不一定能看得明白，因为set()方法中需要传入的三个参数稍微有点复杂，下面我们就来仔细地分析一下。第一个参数是一个整型参数，用于指定AlarmManager的工作类型，有四种值可选，分别是ELAPSED_REALTIME、ELAPSED_REALTIME_WAKEUP、RTC和RTC_WAKEUP。其中ELAPSED_REALTIME表示让定时任务的触发时间从系统开机开始算起，但不会唤醒CPU。ELAPSED_REALTIME_WAKEUP同样表示让定时任务的触发时间从系统开机开始算起，但会唤醒CPU。RTC表示让定时任务的触发时间从1970年1月1日0点开始算起，但不会唤醒CPU。RTC_WAKEUP同样表示让定时任务的触发时间从1970年1月1日0点开始算起，但会唤醒CPU。使用SystemClock.elapsedRealtime()方法可以获取到系统开机至今所经历时间的毫秒数，使用System.currentTimeMillis()方法可以获取到1970年1月1日0点至今所经历时间的毫秒数。

然后看一下第二个参数，这个参数就好理解多了，就是定时任务触发的时间，以毫秒为单位。如果第一个参数使用的是ELAPSED_REALTIME或ELAPSED_REALTIME_WAKEUP，则这里传入开机至今的时间再加上延迟执行的时间。如果第一个参数使用的是RTC或RTC_WAKEUP，则这里传入1970年1月1日0点至今的时间再加上延迟执行的时间。

第三个参数是一个PendingIntent，对于它你应该已经不会陌生了吧。这里我们一般会调用getBroadcast()方法来获取一个能够执行广播的PendingIntent。这样当定时任务被触发的时候，广播接收器的onReceive()方法就可以得到执行。

了解了set()方法的每个参数之后，你应该能想到，设定一个任务在10秒钟后执行还可以写成：

long triggerAtTime = System.currentTimeMillis() + 10 * 1000;

manager.set(AlarmManager.RTC_WAKEUP, triggerAtTime, pendingIntent);

好了，现在你已经掌握Alarm机制的基本用法，下面我们就来创建一个可以长期在后台执行定时任务的服务。创建一个ServiceBestPractice项目，然后新增一个LongRunningService类，代码如下所示：

public class LongRunningService extends Service {

@Override

public IBinder onBind(Intent intent) {

return null;

}

@Override

public int onStartCommand(Intent intent, int flags, int startId) {

new Thread(new Runnable() {

@Override

public void run() {

Log.d("LongRunningService", "executed at " + new Date(). toString());

}

}).start();

AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);

int anHour = 60 * 60 * 1000;  //这是一小时的毫秒数

long triggerAtTime = SystemClock.elapsedRealtime() + anHour;

Intent i = new Intent(this, AlarmReceiver.class);

PendingIntent pi = PendingIntent.getBroadcast(this, 0, i, 0);

manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pi);

return super.onStartCommand(intent, flags, startId);

}

}

我们在onStartCommand()方法里开启了一个子线程，然后在子线程里就可以执行具体的逻辑操作了。这里简单起见，只是打印了一下当前的时间。

创建线程之后的代码就是我们刚刚讲解的Alarm机制的用法了，先是获取到了AlarmManager的实例，然后定义任务的触发时间为一小时后，再使用PendingIntent指定处理定时任务的广播接收器为AlarmReceiver，最后调用set()方法完成设定。

显然，AlarmReceiver目前还不存在呢，所以下一步就是要新建一个AlarmReceiver类，并让它继承自BroadcastReceiver，代码如下所示：

public class AlarmReceiver extends BroadcastReceiver {

@Override

public void onReceive(Context context, Intent intent) {

Intent i = new Intent(context, LongRunningService.class);

context.startService(i);

}

}

onReceive()方法里的代码非常简单，就是构建出了一个Intent对象，然后去启动LongRunningService这个服务。那么这里为什么要这样写呢？其实在不知不觉中，这就已经将一个长期在后台定时运行的服务完成了。因为一旦启动LongRunningService，就会在onStartCommand()方法里设定一个定时任务，这样一小时后AlarmReceiver的onReceive()方法就将得到执行，然后我们在这里再次启动LongRunningService，这样就形成了一个永久的循环，保证LongRunningService可以每隔一小时就会启动一次，一个长期在后台定时运行的服务自然也就完成了。

接下来的任务也很明确了，就是我们需要在打开程序的时候启动一次LongRunningService，之后LongRunningService就可以一直运行了。修改MainActivity中的代码，如下所示：

public class MainActivity extends Activity {

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

Intent intent = new Intent(this, LongRunningService.class);

startService(intent);

}

}

最后别忘了，我们所用到的服务和广播接收器都要在AndroidManifest.xml中注册才行，代码如下所示：

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

    package="com.example.servicebestpractice"

    android:versionCode="1"

    android:versionName="1.0" >

……

    <application

        android:allowBackup="true"

        android:icon="@drawable/ic_launcher"

        android:label="@string/app_name"

        android:theme="@style/AppTheme" >

        <activity

            android:name="com.example.servicebestpractice.MainActivity"

            android:label="@string/app_name" >

            <intent-filter>

                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />

            </intent-filter>

        </activity>

        <service android:name=".LongRunningService" >

        </service>

        <receiver android:name=".AlarmReceiver" >

        </receiver>

    </application>

</manifest>

现在就可以来运行一下程序了。虽然你不会在界面上看到任何有用的信息，但实际上LongRunningService已经在后台悄悄地运行起来了。为了能够验证一下运行结果，我将手机闲置了几个小时，然后观察LogCat中的打印日志，如图所示。

可以看到，LongRunningService果然如我们所愿地运行着，每隔一小时都会打印一条日志。这样，当你真正需要去执行某个定时任务的时候，只需要将打印日志替换成具体的任务逻辑就行了。

另外需要注意的是，从Android 4.4版本开始，Alarm任务的触发时间将会变得不准确，有可能会延迟一段时间后任务才能得到执行。这并不是个bug，而是系统在耗电性方面进行的优化。系统会自动检测目前有多少Alarm任务存在，然后将触发时间将近的几个任务放在一起执行，这就可以大幅度地减少CPU被唤醒的次数，从而有效延长电池的使用时间。

当然，如果你要求Alarm任务的执行时间必须准备无误，Android仍然提供了解决方案。使用AlarmManager的setExact()方法来替代set()方法，就可以保证任务准时执行了。

好了，最佳实践部分到此结束，下面我们就来回顾一下本章所学的内容吧。