Android Service 完全解析
前言
在讲解Binder机制之前，我认为自己需要写一篇关于Android Service的文章，群里有位大神写了两篇关于Android Service不错的文章，这里直接转载学习了。记住，大神不是用来膜拜的，是用来追赶，鞭策自己努力的。
原文链接
1. http://blog.csdn.net/guolin_blog/article/details/11952435
2. http://blog.csdn.net/guolin_blog/article/details/9797169
Service的基本用法
从运行模式上来看，Android的服务组件没有运行在独立的进程或线程中。默认情况下，服务组件构造于应用进程中，并且和其他的Android组建一样，都在进程的主线程（即UI线程）中运行。这就意味着直接在服务组件中同步执行耗时的操作，将会导致主线程阻塞或界面假死，从而无法响应用户的操作。
关于Service最基本的用法自然就是如何启动一个Service了，启动Service和启动Activity很类似，都需要借助Intent来实现，下面我们就通过一个具体的例子来看一下。
新建一个MyService继承自Service，并重写父类的onCreate()、onStartCommand()和onDestory()方法，如下所示：
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
public class MyService extends Service {
private static final String TAG = "MyService";
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public void onCreate() {
super.onCreate();
Log.d(TAG, "onCreate() executed");
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.d(TAG, "onStartCommand() executed");
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestory() executed");
}
}
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
public class MainActivity extends Activity {
private Button startButton;
private Button stopButton;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initLayout();
}
private void initLayout() {
startButton = (Button) findViewById(R.id.start_service_button);
stopButton = (Button) findViewById(R.id.stop_service_button);
View.OnClickListener listener = new ServiceClickListener();
startButton.setOnClickListener(listener);
stopButton.setOnClickListener(listener);
}
private class ServiceClickListener implements View.OnClickListener {
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.start_service_button:
Intent startIntent = new Intent(MainActivity.this,
MyService.class);
startService(startIntent);
break;
case R.id.stop_service_button:
Intent stopIntent = new Intent(MainActivity.this,
MyService.class);
stopService(stopIntent);
break;
default:
break;
}
}
}
}
也就是说，当启动一个Service的时候，会调用该Service中的onCreate()和onStartCommand()方法。那么如果我再点击一下Start Service按钮呢？这个时候的打印日志如下：
可以看到，这次只有onStartCommand()方法执行了，onCreate方法没有执行，为什么会这样呢？这是由于onCreate()方法只会在Service第一次被创建的时候调用，如果当前Service已经被创建过了，不管怎样调用startService(),onCreate()方法都不会再执行了。因此你可以多点击几次Start Service按钮试一次，每次都只会有onStartCommand()方法中的打印日志。
我们还可以到手机的应用程序管理界面来检查一下MyService是不是真正的在运行，如下图所示：
可以看到，MyService确实是在运行的，虽然MyService内部并没有执行任何的逻辑。回到MainActivity中，点击Stop Service按钮就可以将MyService停止掉了。
Service和Activity通信
上面我们学习了Service的基本用法，启动Service之后，就可以在onCreate()或onStartCommand()方法里去执行一些具体的逻辑了。不过这样的话，Service和Activity的关系并不大，只是Acitivity通知了Service一下：“你可以启动了”。然后Service就去忙自己的事情了，那么有没有什么办法能让它俩关联更多一些呢？比如说在Activity中可以指定让Service去执行什么任务。当然可以，只需要让Activity和Service建立关联就好了。
观察MyService中的代码，你会发现一直有一个onBind()方法哦我们都没有使用到，这个方法其实就是用于和Activity建立关联的，修改MyService中的代码，如下所示：
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;
public class MyService extends Service {
private static final String TAG = "MyService";
private MyBinder mBinder = new MyBinder();
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
@Override
public void onCreate() {
super.onCreate();
Log.d(TAG, "onCreate() executed");
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.d(TAG, "onStartCommand() executed");
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestory() executed");
}
private class MyBinder extends Binder {
public void startDownload() {
Log.d(TAG, "startDownload() executed");
}
}
}
import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.view.View;
import android.widget.Button;
public class MainActivity extends Activity {
private Button startButton;
private Button stopButton;
private Button bindButton;
private Button unBindButton;
private MyService.MyBinder myBinder;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initLayout();
}
private void initLayout() {
startButton = (Button) findViewById(R.id.start_service_button);
stopButton = (Button) findViewById(R.id.stop_service_button);
View.OnClickListener listener = new ServiceClickListener();
startButton.setOnClickListener(listener);
stopButton.setOnClickListener(listener);
bindButton.setOnClickListener(listener);
unBindButton.setOnClickListener(listener);
}
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceDisconnected(ComponentName name) {
// TODO Auto-generated method stub
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
myBinder = (MyService.MyBinder) service;
myBinder.startDownload();
}
};
private class ServiceClickListener implements View.OnClickListener {
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.start_service_button:
Intent startIntent = new Intent(MainActivity.this,
MyService.class);
startService(startIntent);
break;
case R.id.stop_service_button:
Intent stopIntent = new Intent(MainActivity.this,
MyService.class);
stopService(stopIntent);
break;
case R.id.bind_service_button:
Intent bindIntent = new Intent(MainActivity.this,
MyService.class);
bindService(bindIntent, connection, BIND_AUTO_CREATE);
break;
case R.id.unbind_service_button:
unbindService(connection);
break;
default:
break;
}
}
}
}
当然，现在Activity和Service其实还没关联起来，这个功能是在Bind Service的按钮的点击事件里完成的。可以看到，这里我们仍然是构建出了一个Intent对象，然后调用bindService()方法将Activity和Service进行绑定。bindService()方法接收三个参数，第一个参数就是刚刚构建出来的Intent对象，第二个参数是前面创建出来的ServiceConnection的实例，第三个参数是一个标志位，这里传入BIND_AUTO_CREATE表示Activity和Service建立关联后自动创建Service，这会使得MyService中的Oncreate()方法得到执行，但onStartCommand()方法不会执行。然后我们想解除Activity和Service之间的关联怎么办呢？调用一下unbindService()方法就可以了，这也是Unbind Service按钮的点击事件里实现的逻辑。
现在让我们重新运行一下程序，在MainActivity里点击一下Bind Service按钮，Logcat里的打印日志如下图所示：
另外需要注意，任何一个Service在整个应用程序范围内都是通用的，即MyService不仅可以和MainActivity建立关联，还可以和任何一个Activity建立关联，而且在建立关联时它们都可以获取到相同的MyBinder实例。
如何销毁Service
在Service的基本用法这一部分，我们介绍了销毁Service最简单的一种情况，点击Start Service按钮启动Service，再点击Stop Service按钮停止Service，这样MyService就被销毁了，可以看到打印日志如下所示：
那么如果我们点击的是Bind Service按钮呢？由于绑定Service的时候指定的标志位是BIND_AUTO_CREATE，说明点击Bing Service按钮的时候Service也会被创建，这时应该怎么销毁Service呢？其实也很简单，点击一下Unbind Service按钮，将Activity和Service关联解除就可以了。先点击一下Bind Service按钮，再点击一下Unbind Service按钮，打印日志如下：
以上这两种销毁的方式都很好理解，那么如果我们既点击了Start Service按钮，又点击了Bind Service按钮会怎么样呢？这个时候你会发现，不管你是单独点击Stop Service按钮还是点击Unbind Service按钮，Service都不会被销毁，必要将两个按钮都点击一下，Service才会被销毁。也就是说，点击Stop Service按钮只会让Service停止，点击Unbind Service按钮只会让Service和Activity解除关联，一个Service必须要在既没和任何Activity关联又处于停止状态的时候才会被销毁。
为了证实一下，我们在Stop Service和Unbind Service按钮的点击事件里面加入一行打印日志：
private class ServiceClickListener implements View.OnClickListener {
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.start_service_button:
Intent startIntent = new Intent(MainActivity.this,
MyService.class);
startService(startIntent);
break;
case R.id.stop_service_button:
Log.e(MyService.TAG, "click Stop Service button");
Intent stopIntent = new Intent(MainActivity.this,
MyService.class);
stopService(stopIntent);
break;
case R.id.bind_service_button:
Intent bindIntent = new Intent(MainActivity.this,
MyService.class);
bindService(bindIntent, connection, BIND_AUTO_CREATE);
break;
case R.id.unbind_service_button:
Log.e(MyService.TAG, "click Unbind Service button");
unbindService(connection);
break;
default:
break;
}
}
}
我们应该始终记得在Service的onDestory()方法里清理掉那些不再使用的资源，防止在Service被销毁后还有一些不再使用的对象仍占用着内存。
Service和Thread的关系
不少Android初学者都可能会有这样的疑惑，Service和Thread到底有什么关系呢？什么时候应用Service，什么时候又应该用Thread？答案可能会让你有些吃惊（ps：这里我在文章开始就说过了，Service运行在主线程中），因为Service和Thread之间没有任何关系。
之所以有不少人把它们联系起来，主要是因为Service的后台概念。Thread大家都知道，是用于开启一个子线程，在这里去执行一些耗时操作就不会阻塞主线程的运行。而Service我们最初理解的时候，总会觉得它是用来处理一些后台任务的，一些比较耗时的操作也可以放在这里运行，这就会让人产生混淆了。但是，如果我告诉你Service其实是运行在主线程里的，你还会觉得它和Thread有什么关系吗？让我们看一下这个残酷的事实吧。
在MainActivity的onCreate()方法里加入一行打印当前线程id的语句：
Log.e(MyService.TAG, "MainActivity thread id is " + Thread.currentThread().getId());
Log.e(MyService.TAG, "MyService thread id is " + Thread.currentThread().getId());
可以看到，它们的线程id完全是一样的，由此证实了Service确实是运行在主线程里的，也就是说，如果你在Service里面写了非常耗时的代码，程序必定会出现ANR的。
你可能会惊呼，我擦，这不是坑爹么！那我要Service又有何用呢？其实大家不要把后台和子线程联系在一起就行了，这是两个完全不同的概念。Android的后台是指，它的运行是完全不依赖UI的。即使Acitivity被销毁，或者程序被关闭，只要进程还在，Service就可以继续运行。比如说一些应用程序，始终需要与服务器之间保持着心跳连接，就可以使用Service来实现。你可能又会问，前面不是刚刚验证过Service是运行在主线程里，这里一直保持着心跳连接，难道就不会阻塞主线程的运行吗？当然会，但是我们可以在Service中再创建一个子线程，然后在这里面去处理耗时逻辑就没问题了。
那既然在Service里也要创建一个子线程，那为什么不直接在Activity里创建呢？这是因为Activity很难对Thread进行控制，当Activity被销毁之后，就没有任何其它的办法可以再重新获取到之前创建的子线程的实例。而且在一个Activity中创建子线程，另一个Activity无法对其进行操作。但是Service就不同了，所有的Activity都可以与Service进行关联，然后可以很方便地操作其中的方法，即使Activity被销毁了，之后只要重新与Service建立关联，就又能够获取到原有的Service中的Binder的实例。因此，使用Service来处理后台任务，Activity就可以放心地finish，完全不需要担心无法对后台任务进行控制的情况。
一个比较标准的Service就可以写成：
package com.example.testlibrary;
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;
public class MyService extends Service {
public static final String TAG = "MyService";
private MyBinder mBinder = new MyBinder();
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
@Override
public void onCreate() {
super.onCreate();
Log.d(TAG, "onCreate() executed");
Log.e(MyService.TAG, "MyService thread id is " + Thread.currentThread().getId());
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
new Thread(new Runnable() {
@Override
public void run() {
// TODO : 开始执行后台任务
}
}).start();
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestory() executed");
}
class MyBinder extends Binder {
public void startDownload() {
new Thread(new Runnable() {
@Override
public void run() {
// TODO : 开始执行后台任务
}
}).start();
Log.d(TAG, "startDownload() executed");
}
}
}
创建前台Service
Service几乎都是在后台运行的，一直以来它都是默默地做着辛苦的工作。但是Service的系统优先级还是比较低的，当系统出现内存不足情况时，就可能会回收掉正在后台运行的Service。前台Service和普通Service最大的区别就在于，它会一直有一个正在运行的图标在系统的状态栏显示，下拉状态栏后可以看到更加详细的信息，非常类似于通知的效果。当然有时候你也可能不仅仅是为了防止Service被回收才使用前台Service，有些项目由于特殊的需求会要求必须使用前台Service，比如说墨迹天气，它的Service在后台更新天气数据的同时，还会在系统状态栏一直显示当前天气的信息，如下图所示：
那么我们就来看一下如何才能创建一个前台Service吧，其实并不复杂，修改MyService中的代码，如下所示：
package com.example.testlibrary;
import android.app.Notification;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;
public class MyService extends Service {
public static final String TAG = "MyService";
private MyBinder mBinder = new MyBinder();
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
@Override
public void onCreate() {
super.onCreate();
Notification notification = new Notification(R.drawable.ic_launcher, "有通知到来", System.currentTimeMillis());
Intent notificationIntent = new Intent(this, MainActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
notification.setLatestEventInfo(this, "这是标题", "这是内容", pendingIntent);
startForeground(1, notification);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
new Thread(new Runnable() {
@Override
public void run() {
// TODO : 开始执行后台任务
}
}).start();
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestory() executed");
}
class MyBinder extends Binder {
public void startDownload() {
new Thread(new Runnable() {
@Override
public void run() {
// TODO : 开始执行后台任务
}
}).start();
Log.d(TAG, "startDownload() executed");
}
}
}
现在重新运行一下程序，并点击Start Service或Bind Service按钮，MyService就会以前台Service的模式启动了，并且在系统状态栏会弹出一个通栏图标，下拉状态栏后可以看到通知的详细内容，如下图所示。
远程Service
将一个普通的Service转换成远程Service其实非常简单，只需要在注册Service的时候将它的android:process属性指定成:remote就可以了，代码如下所示：
package com.example.testlibrary;
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;
public class MyService extends Service {
public static final String TAG = "MyService";
private MyBinder mBinder = new MyBinder();
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
@Override
public void onCreate() {
super.onCreate();
Log.e(TAG, "onCreate() executed");
try {
Thread.sleep(60000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.d(TAG, "onStartCommand() executed");
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestory() executed");
}
class MyBinder extends Binder {
public void startDownload() {
Log.d(TAG, "startDownload() executed");
}
}
}
为什么将MyService转换成远程Service后就不会导致程序ANR了呢？这是由于，使用了远程Service后，MyService已经在另外一个进程当中运行了，所以只会阻塞该进程中的主线程，并不会影响到当前的应用程序。为了证实MyService现在确实已经运行在另外一个进程中了，我们分别在MainActivity的onCreate()方法和MyService的onCreate()方法里加入一行日志，打印出各自所在的进程id，如下所示：
Log.e(MyService.TAG, "MainActivity process id is " + Process.myPid());
Log.e(MyService.TAG, "MyService process id is " + Process.myPid());
可以看到，进程id确实是不同了。那既然远程Service这么好用，干脆以后我们把所有的Service都转换成远程Service吧，省得再开启线程了。其实不然，远程Service非但不好用，甚至可以称得上是较为难用。一般情况下如果可以不使用远程Service，就尽量不要使用它。
下面就来看一下它的弊端吧，首先将MyService的onCreate()方法中让线程睡眠的代码去除掉，然后重新运行程序，并点击一下Bind Service按钮，你会发现程序崩溃了！为什么点击Start Service按钮程序就不会崩溃，而点击Bind Service按钮就会崩溃呢？这是由于在Bind Service按钮的点击事件里面我们会让MainActivity和MyService建立关联，但是目前MyService已经是一个远程Service了，Activity和Service运行在两个不同的进程当中，这时就不能再使用传统的建立关联的方式，程序也就崩溃了。
下面就来看一下它的弊端吧，首先将MyService的onCreate()方法中让线程睡眠的代码去除掉，然后重新运行程序，并点击一下Bind Service按钮，你会发现程序崩溃了！为什么点击Start Service按钮程序就不会崩溃，而点击Bind Service按钮就会崩溃呢？这是由于在Bind Service按钮的点击事件里面我们会让MainActivity和MyService建立关联，但是目前MyService已经是一个远程Service了，Activity和Service运行在两个不同的进程当中，这时就不能再使用传统的建立关联的方式，程序也就崩溃了。
那么如何才能让Activity与一个远程Service建立关联呢？这就要使用AIDL来进行跨进程通信了（IPC）。AIDL（Android Interface Definition Language）是Android接口定义语言的意思，它可以用于让某个Service与多个应用程序组建之间进行跨进程通信，从而可以实现多个应用程序共享同一个Service的功能。
下面我们就来一步步地看一下AIDL的用法到底是怎么样的。首先需要新建一个AIDL文件，在这个文件中定义好Activity需要与Service进行通信的方法。新建MyAIDLService.aidl文件，代码如下：