大家好,我叫石头.

近眼看世界

前言

这个时间点快接近大家最激动(涨薪),最担忧(能涨多少呢)的时间了~~~.
所以我在这里为大家好好总结总结Android中的Service(祝大家能找到最好的,最喜欢的工作),好了不废话了,下面正式开始.

什么是服务(Service)

官方定义:

Service
是一个可以在后台执行长时间运行操作而不提供用户界面的应用组件。服务可由其他应用组件启动，而且即使用户切换到其他应用，服务仍将在后台继续运行。 此外，组件可以绑定到服务，以与之进行交互，甚至是执行进程间通信 (IPC)。 例如，服务可以处理网络事务、播放音乐，执行文件 I/O 或与内容提供程序交互，而所有这一切均可在后台进行。

注意：Service默认在主线程中运行，它既不创建自己的线程，也不在单独的进程中运行（除非另行指定）。 所以建议大家在CPU 密集型工作(如:播放音乐)或阻止性操作(联网:需要等待)的操作,则应在服务内创建新线程来完成这项工作。这样可以降低发生“应用无响应”(ANR) 错误的风险。

Service的生命周期

Service生命周期

Service的使用

当我们开始使用Service的时候当然是启动一个Service了，启动Service的方法和启动Activity很类似，都需要借助Intent来实现，下面我们就通过一个具体的例子来看一下.

public class MyService extends Service {  
  
    public static final String TAG = "MyService";  
  
    @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, "onDestroy() executed");  
    }  
  
    @Override  
    public IBinder onBind(Intent intent) {  
        return null;  
    }  
  
}  

注意:每个Service必须在manifest中 通过<service>来声明

<service android:name="com.example.servicetest.MyService" > 
  ... 
</service>

现在我们通过继承Service的方式定义了我们自己的MyService类,并且在manifest中声明了我们的MyService,接下来我们应该启动我们自己的服务.

启动

我们是通过一个Intent对象，并调用startService()方法来启动MyService

Intent startIntent = new Intent(this, MyService.class);  
startService(startIntent); 

注意,假如我们是通过点击Button执行上面的代码,那么第一次点击的时候回执行其中的onCreate()跟onStartCommand()方法,但是当我们第二次点击的时候就只会执行onStartCommand()方法了.

为什么会这样呢？
这是由于onCreate()方法只会在Service第一次被创建的时候调用，如果当前Service已经被创建过了(第一次点击创建了MyService)，不管怎样调用startService()方法，onCreate()方法都不会再执行。

启动了之后,当我们想停止服务的时候该怎么做呢?

停止

我们也是通过一个Intent对象，并调用stopService()方法来启动MyService

Intent stopIntent = new Intent(this, MyService.class);
stopService(stopIntent); 

Service和Activity通信

在上面我们高高兴兴的启动了Service了,但是细心的你可能发现了,貌似我们仅仅只是启动了而已,Activity跟Service并没有多少"交流",下面我们就让Activity跟Service交流下吧.

public class MyService extends Service {

    public static final String TAG = "MyService";

    private MyBinder mBinder = new MyBinder();

    @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, "onDestroy() executed");
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    class MyBinder extends Binder {

        public void startDownload() {
            Log.d("TAG", "startDownload() executed");
            // 执行具体的下载任务
        }

    }

}

接下来我们在MainActivity中通过Button来绑定Service和解除绑定.

public class MainActivity extends Activity implements OnClickListener {
        
    private Button bindService;

    private Button unbindService;

    private MyService.MyBinder myBinder;

    private ServiceConnection connection = new ServiceConnection() {

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            myBinder = (MyService.MyBinder) service;
            myBinder.startDownload();
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        bindService = (Button) findViewById(R.id.bind_service);
        unbindService = (Button) findViewById(R.id.unbind_service);
        bindService.setOnClickListener(this);
        unbindService.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.bind_service:
            Intent bindIntent = new Intent(this, MyService.class);
            bindService(bindIntent, connection, BIND_AUTO_CREATE);
            break;
        case R.id.unbind_service:
            unbindService(connection);
            break;
        default:
            break;
        }
    }

}

可以看到，这里我们首先创建了一个ServiceConnection的匿名类，在里面重写了onServiceConnected()方法和onServiceDisconnected()方法，这两个方法分别会在Activity与Service建立关联和解除关联的时候调用。在onServiceConnected()方法中，我们又通过 向下转型 得到了MyBinder的实例，有了这个实例，Activity和Service之间的关系就变得非常紧密了。现在我们可以在Activity中根据具体的场景来调用MyBinder中的任何public方法，即实现了Activity指挥Service干什么Service就去干什么的功能。

当然，现在Activity和Service其实还没关联起来了呢，这个功能是在Bind Service按钮的点击事件里完成的。可以看到，这里我们仍然是构建出了一个Intent对象，然后调用bindService()方法将Activity和Service进行绑定。bindService()方法接收三个参数，第一个参数就是刚刚构建出的Intent对象，第二个参数是前面创建出的ServiceConnection的实例，第三个参数是一个标志位，这里传入BIND_AUTO_CREATE表示在Activity和Service建立关联后自动创建Service，这会使得MyService中的onCreate()方法得到执行，但onStartCommand()方法不会执行(只有当我们通过 startService()方法请求启动服务时，调用此方法)。

然后如何我们想解除Activity和Service之间的关联怎么办呢？
调用:

unbindService(connection);  

另外需要注意，任何一个Service在整个应用程序范围内都是通用的，即MyService不仅可以和MainActivity建立关联，还可以和任何一个Activity建立关联，而且在建立关联时它们都可以获取到相同的MyBinder实例(例如音乐播放,我们能在几个Activity通过MyService执行播放,暂停,下一曲等操作)。

如何销毁Service

在之前我们提到了一种方式:
点击Start Service按钮启动Service，再点击Stop Service按钮停止Service，这样MyService就被销毁了

注意:其实也可以在MyService的内部通过stopSelf()方法来销毁的.

那么如果我们不是通过Start Service按钮,而是通过点击的Bind Service按钮来开启服务的呢(由于在绑定Service的时候指定的标志位是BIND_AUTO_CREATE，说明点击Bind Service按钮的同时Service也会被创建),那么我们应该怎么销毁呢?

其实也很简单，点击一下Unbind Service按钮，将Activity和Service的关联解除就可以了,但是我们会问为什么会这样呢?
原因是:服务只会在该组件与其绑定时运行。一旦该服务与所有客户端之间的绑定全部取消，系统便会销毁它。这里我们只有一个MainActivity绑定了Service,所以当我们点击一下Unbind Service按钮，这时Activity和Service的关联解除了,这时就没有其他组件绑定Service了,所以系统就销毁了它.

以上这三种销毁的方式都很好理解。那么如果我们既点击了Start Service按钮，又点击了Bind Service按钮会怎么样呢？这个时候你会发现，不管你是单独点击Stop Service按钮还是Unbind Service按钮，Service都不会被销毁，必要将两个按钮都点击一下，Service才会被销毁。
也就是说，点击Stop Service按钮只会让Service停止，点击Unbind Service按钮只会让Service和Activity解除关联，

一个Service必须要在既没有和任何Activity关联又处理停止状态的时候才会被销毁。

我们应该始终记得在Service的onDestroy()方法里去清理掉那些不再使用的资源，防止在Service被销毁后还会有一些不再使用的对象仍占用着内存。

Service和Thread的关系

当我们开始学习Android的时候,都会问自己,Service和Thread到底有什么关系呢？什么时候应该用Service，什么时候又应该用Thread？

答案可能会有点让你吃惊，因为Service和Thread之间没有任何关系！

之所以有不少人会把它们联系起来，主要就是因为Service的后台概念.
Thread我们大家都知道，是用于开启一个子线程，在这里去执行一些耗时操作就不会阻塞主线程的运行。而Service我们最初理解的时候，总会觉得它是用来处理一些后台任务的，一些比较耗时的操作也可以放在这里运行，这就会让人产生混淆了。但是，如果我告诉你Service其实是运行在主线程里的，你还会觉得它和Thread有什么关系吗？
Service默认是运行在主线程中的,下面让我们来看看.

在MainActivity的onCreate()方法里加入一行打印当前线程id的语句：

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

然后在MyService的onCreate()方法里也加入一行打印当前线程id的语句：

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

现在重新运行一下程序，并点击Start Service按钮，会看到如下打印日志：

MainActivity thread id is 1
MyService thread id is 1

它们的线程id完全是一样的，由此证实了Service确实是运行在主线程里的，也就是说如果你在Service里编写了非常耗时的代码，程序必定会出现ANR的()。

各个组件ANR时间:
Activity----->5秒
Broadcast----->10秒
Service----->20秒
会报ANR，都是在主线程中运行的

你可能会惊呼，这不是坑爹么！？那我要Service又有何用呢？其实大家不要把后台和子线程联系在一起就行了，这是两个完全不同的概念。Android的后台就是指，它的运行是完全不依赖UI的。即使Activity被销毁，或者程序被关闭，只要进程还在，Service就可以继续运行。比如说一些应用程序，始终需要与服务器之间始终保持着心跳连接，就可以使用Service来实现。你可能又会问，前面不是刚刚验证过Service是运行在主线程里的么？在这里一直执行着心跳连接，难道就不会阻塞主线程的运行吗？当然会，但是我们可以在Service中再创建一个子线程，然后在这里去处理耗时逻辑就没问题了。

额，既然在Service里也要创建一个子线程，那为什么不直接在Activity里创建呢？这是因为Activity很难对Thread进行控制，当Activity被销毁之后，就没有任何其它的办法可以再重新获取到之前创建的子线程的实例。而且在一个Activity中创建的子线程，另一个Activity无法对其进行操作。但是Service就不同了，所有的Activity都可以与Service进行关联(通过绑定)，然后可以很方便地操作其中的方法，即使Activity被销毁了，之后只要重新与Service建立关联，就又能够获取到原有的Service中Binder的实例。因此，使用Service来处理后台任务，Activity就可以放心地finish，完全不需要担心无法对后台任务进行控制的情况。

一个比较标准的Service就可以写成：

@Override  
public int onStartCommand(Intent intent, int flags, int startId) {  
    new Thread(new Runnable() {  
        @Override  
        public void run() {  
            //onStartCommand方法在我们调用starService开启服务时被执行
            // 开始执行后台任务  
        }  
    }).start();  
    return super.onStartCommand(intent, flags, startId);  
}  
  
class MyBinder extends Binder {  
  
    public void startDownload() {  
        new Thread(new Runnable() {  
            @Override  
            public void run() {  
                //我们能通过绑定拿到这个类的实例
                // 执行具体的下载任务  
            }  
        }).start();  
    }  
  
}

Service的种类

按运行地点分类：

|类别| 区别| 优点| 缺点 | 应用|
|:-------------: |:-------------:| -----|
|本地服务(Local)| 该服务依附在主进程上，| 服务依附在主进程上而不是独立的进程，这样在一定程度上节约了资源，另外Local服务因为是在同一进程因此不需要IPC，也不需要AIDL。相应bindService会方便很多。| 主进程被Kill后，服务便会终止。| 非常常见的应用如：HTC的音乐播放服务，天天动听音乐播放服务。|
|远程服务(Remote)| 该服务是独立的进程，| 服务为独立的进程，对应进程名格式为所在包名加上你指定的android:process字符串。由于是独立的进程，因此在Activity所在进程被Kill的时候，该服务依然在运行，不受其他进程影响，有利于为多个进程提供服务具有较高的灵活性。| 该服务是独立的进程，会占用一定资源，并且使用AIDL进行IPC稍微麻烦一点。| 一些提供系统服务的Service，这种Service是常驻的。|

其实remote服务还是很少见的，并且一般都是系统服务。

按运行类型分类

有同学可能会问，后台服务我们可以自己创建ONGOING的 Notification 这样就成为前台服务吗？答案是否定的，前台服务是在做了上述工作之后需要调用 startForeground（ android 2.0 及其以后版本 ）或 setForeground（android 2.0 以前的版本）使服务成为 前台服务。这样做的好处在于，当服务被外部强制终止掉的时候，ONGOING 的 Notification任然会移除掉。

按使用方式分类：

|类别|区别|
| ------------- |:-------------:| -----|
|startService 启动的服务| 主要用于启动一个服务执行后台任务，不进行通信。停止服务使用stopService|
|bindService 启动的服务| 该方法启动的服务要进行通信。停止服务使用unbindService|
|startService 同时也 bindService 启动的服务| 停止服务应同时使用stepService与unbindService|

特别注意:
1、你应当知道在调用 bindService 绑定到Service的时候，你就应当保证在某处调用 unbindService 解除绑定（尽管 Activity被 finish 的时候绑定会自动解除，并且Service会自动停止）；
2、你应当注意 使用startService启动服务之后，一定要使用 stopService停止服务，不管你是否使用bindService；
3、同时使用 startService 与 bindService 要注意到，Service 的终止，需要unbindService与stopService同时调用，才能终止 Service，不管 startService 与 bindService 的调用顺序，如果先调用 unbindService 此时服务不会自动终止，再调用 stopService 之后服务才会停止，如果先调用stopService 此时服务也不会终止，而再调用 unbindService 或者 之前调用 bindService 的 Context不存在了（如Activity 被finish 的时候）之后服务才会自动停止；
4、当在旋转手机屏幕的时候，当手机屏幕在“横”“竖”变换时，此时如果你的 Activity 如果会自动旋转的话，旋转其实是 Activity 的重新创建，因此旋转之前的使用 bindService 建立的连接便会断开（Context不存在了），对应服务的生命周期与上述相同。
5、在 sdk 2.0 及其以后的版本中，对应的 onStart 已经被否决变为了 onStartCommand，不过之前的 onStart 任然有效。这意味着，如果你开发的应用程序用的 sdk 为 2.0 及其以后的版本，那么你应当使用onStartCommand而不是 onStart。

创建前台Service

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

现在我们来修改下MyService来让其变成前台服务吧~~

public class MyService extends Service {  
  
    public static final String TAG = "MyService";  
  
    private MyBinder mBinder = new MyBinder();  
  
    @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);  
        Log.d(TAG, "onCreate() executed");  
    }  
  
    .........  
  
}  

这里只是修改了MyService中onCreate()方法的代码。可以看到，我们首先创建了一个Notification对象，然后调用了它的setLatestEventInfo()方法来为通知初始化布局和数据，并在这里设置了点击通知后就打开MainActivity。然后调用startForeground()方法就可以让MyService变成一个前台Service，并会将通知的图片显示出来。
如果我们要从前台移除服务，请调用stopForeground()方法，这个方法接受个布尔参数，表示是否同时移除状态栏通知。此方法不会终止服务。不过，如果服务在前台运行时被你终止了，那么通知也会同时被移除。

到这里差不多Service的内容就介绍完了,但是我们好像还有一个问题还没说到,就是远程Service,我会在之后的文章中结合AIDL来讲述的.

每日箴言

人所缺乏的不是才干而是志向，不是成功的能力而是勤劳的意志。