Android:Service总结

---

前言

这篇笔记是笔者在复习Android Service期间的总结

一、Service概念

Service是一个在后台执行长时间运行操作而不用提供用户界面的应用组件，可由其他组件启动，即使用户切换到其他应用程序，Service 仍然在后台继续运行。

二、Service的启动方式

Service 和Activity 一样同为Android 的四大组件之一，并且他们都有各自的生命周期，要想掌握Service 的用法，那就要了解Service 的生命周期有哪些方法，并且生命周期中各个方法回调的时机和作用。有一点比较重要，Service 有两种启动方式，并且它的两种启动方式的生命周期是不一样的。接下来分别看一下两种启动方式各自的生命周期方法。

StartService

当应用组件通过startService方法来启动Service 时，Service 则会处于启动状态，一旦服务启动，它就会在后台无限期的运行，生命周期独立于启动它的组件，即使启动它的组件已经销毁了也不受任何影响，由于启动的服务长期运行在后台，这会大量消耗手机的电量，因此，我们应该在任务执行完成之后调用stopSelf()来停止服务，或者通过其他应用组件调用stopService 来停止服务。

startService 启动服务后，会执行如下生命周期：onCreate() －> onStartCommand() －> onStart()(现在已经废弃) －> onDestroy() 。具体看一下它的几个生命周期方法：

• onCreate() :首次启动服务的时候，系统会调用这个方法，在onStartCommand 和 onBind 方法之前，如果服务已经启动起来了，再次启动时，则不会调用此方法，因此可以在onCreate 方法中做一些初始化的操作，比如要执行耗时的操作，可以在这里创建线程，要播放音乐，可以在这里初始化音乐播放器。

• onStartCommand(): 当通过startService 方法来启动服务的时候，在onCreate 方法之后就会回调这个方法，此方法调用后，服务就启动起来了，将会在后台无限期的运行，直到通过stopService 或者 stopSelf 方法来停止服务。

• onDestroy():当服务不再使用且将被销毁时，系统将调用此方法。服务应该实现此方法来清理所有资源，如线程、注册的侦听器、接收器等。 这是服务接收的最后一个调用。

注：通过startService 方式启动的服务，服务会无限期的在后台运行，直到通过stopService 或 stopSelf来终止服务。服务独立于启动它的组件，也就是说，当组件启动服务后，组件和服务就在也没有关系了，就算启动它的组件被销毁了，服务照样在后台运行。通过这种方式启动的服务不好与组件之间通信。

BindService

除了startService 来启动服务之外，另外一种启动服务的方式就是通过bindService 方法了，也就是绑定服务，其实通过它的名字就容易理解，绑定即将启动组件和服务绑定在一起。前面讲的通过startService 方式启动的服务是与组件相独立的，即使启动服务的组件被销毁了，服务仍然在后台运行不受干扰。但是通过bindSerivce 方式绑定的服务就不一样了，它与绑定组件的生命周期是有关的。
如下：
多个组件可以绑定到同一个服务上，如果只有一个组件绑定服务，当绑定的组件被销毁时，服务也就会停止了。如果是多个组件绑定到一个服务上，当绑定到该服务的所有组件都被销毁时，服务才会停止。

bindService 绑定服务 和startService 的生命周期是不一样，bindServie 的生命周期如下：onCreate －> onBind －> onUnbind －>onDestroy。其中重要的就是onBind 和onUnbind 方法。

onBind(): 当其他组件想通过bindService 与服务绑定时，系统将会回调这个方法，在实现中，你必须返回一个IBinder接口，供客户端与服务进行通信，必须实现此方法，这个方法是Service 的一个抽象方法，但是如果你不允许绑定的话，返回null 就可以了。

onUnbind(): 当所有与服务绑定的组件都解除绑定时，就会调用此方法。

了解了这2个方法后，我们来看一下怎么绑定一个服务。

1，首先，添加一个类 继承 Binder ,在Binder 类中添加其他组件要与服务交互的方法，并在onBind() 方法中返回IBinder 实例对象：
如下为例

public class SimpleService extends Service {
    public static final String TAG = "SimpleService";
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG,"call onBind...");
        //返回IBinder 接口对象
        return new MyBinder();
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.i(TAG,"call onUnbind...");
        return super.onUnbind(intent);
    }

    @Override
    public void onCreate() {
        Log.i(TAG,"call onCreate...");
    }

    @Override
    public void onStart(Intent intent, int startId) {
        Log.i(TAG,"call onStart...");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i(TAG,"call onStartCommand...");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        Log.i(TAG,"call onDestroy...");
    }

    // 添加一个类继承Binder
    public  class MyBinder extends Binder{
        // 添加要与外界交互的方法
        public String  getStringInfo(){
          return "调用了服务中的方法";
        }
    }

}

2.绑定服务的时候，需要提供一个ServiceConnection 接口，在接口回调中获取Binder 对象，与服务进行通信。

 private SimpleService.MyBinder mMyBinder;
    // 绑定/解除绑定 Service 回调接口
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // 绑定成功后回调
            //1 ,获取Binder接口对象
            mMyBinder = (SimpleService.MyBinder) service;
            //2, 从服务获取数据
            String content = mMyBinder.getStringInfo();
            // 3,界面提示
            Toast.makeText(ServiceSimpleActivity.this,content,Toast.LENGTH_LONG).show();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
           // 解除绑定后回调
            mMyBinder = null;
        }
    };

3.绑定和解除绑定服务

		case R.id.bind_service:
            Intent intent = new Intent(this,SimpleService.class);
            // 绑定服务
            bindService(intent,mConnection, Context.BIND_AUTO_CREATE);
            break;
        case R.id.unbind_service:
            // 解除绑定服务
            unbindService(mConnection);
            break;

点击绑定按钮，即绑定服务，并且在onServiceConnected 中得到MyBinder 对象，就可以通过这个对象和服务通信了
注：Service 的生命周期方法不同于Activity ，不需要调用超类的生命周期方法，如：不用调用 super.onCreate（）

多个组件绑定一个Service

多个组件绑定同一服务
Service 是支持多个组件绑定在同一个服务的，第一个组件绑定是会回调 onCreate 生命周期方法，后续的绑定只会调用onBind方法，返回IBinder给客户端。当绑定在服务上的组件都调用unbindService 解除服务或者组件本身就已经被系统回收，那么服务也就会被停止回收了，会回调onUnbind 和 onDestroy 方法。

三、Service与其他组件的通信方式

1.BroadcastReceiver

这种做法一般适用于startServcie的方式
通过前文我们知道，startService方式启动的服务在后台，无限期地运行，并且与启动它的组件是独立的，启动Service 之后也就与启动它的组件没有任何关系了。因此它是不能与启动它的组件之间相互通信的。虽然Service 没有提供这种启动方式的通信方法，我们还是可以通过其他方式来解决的，这就用到了BroadcastReceiver。

代码样例

	public class DownloadService extends Service {
    public static final String IMAGE = "iamge_url";
    public static final String RECEIVER_ACTION = "com.zhouwei.simpleservice";
    private static final String TAG = "DownloadService";
    public static final String ACTION_START_SERVICER = "com.zhouwei.startservice";
    public static final String ACTION_DOWNLOAD = "com.zhouwei.startdownload";
    private Looper mServiceLooper;
    private ServiceHandler mServiceHandler;
    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper){
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            // 工作线程做耗时下载
            String url = (String) msg.obj;
            Bitmap bitmap = null;
            try {
                bitmap = Picasso.with(getApplicationContext()).load(url).get();
                Intent intent = new Intent();
                intent.putExtra("bitmap",bitmap);
                intent.setAction(RECEIVER_ACTION);
                // 通知显示
                LocalBroadcastManager.getInstance(getApplicationContext()).sendBroadcast(intent);
            } catch (IOException e) {
                e.printStackTrace();
            }


            //工作完成之后，停止服务
            stopSelf();
        }
    }
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
    @Override
    public void onCreate() {
        // 开启一个工作线程做耗时工作
        HandlerThread thread = new HandlerThread("ServiceHandlerThread", Process.THREAD_PRIORITY_BACKGROUND);
        thread.start();
        // 获取工作线程的Looper
        mServiceLooper = thread.getLooper();
        // 创建工作线程的Handler
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i(TAG,"call onStartCommand...");
        if(intent.getAction().equals(ACTION_DOWNLOAD)){
            handleCommand(intent);
        }else if(intent.getAction().equals(ACTION_START_SERVICER)){
            //do nothing
        }

        return START_STICKY;
    }

    private void handleCommand(Intent intent){
        String url = intent.getStringExtra(IMAGE);
        // 发送消息下载
        Message message = mServiceHandler.obtainMessage();
        message.obj = url;
        mServiceHandler.sendMessage(message);
    }
	}

	private ImageView mImageView;
    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            // 显示图片
            Bitmap bitmap = intent.getParcelableExtra("bitmap");
            mImageView.setImageBitmap(bitmap);
        }
    };
	
    /**
     * 启动下载
     */
    private void startDownload(){
        Intent intent = new Intent(this,DownloadService.class);
        // 启动服务
        intent.putExtra(DownloadService.IMAGE,"http://www.8kmm.com/UploadFiles/2012/8/201208140920132659.jpg");
        intent.setAction(DownloadService.ACTION_DOWNLOAD);
        startService(intent);
    }

2.LocaService 使用Binder和服务通信

既然通过startService 启动的服务与启动它的组件是独立的。相互通信比较麻烦，那么Google也提供了两者之间的通信方法，那就是组件绑定服务，也就是上文讲的通过bindService 将组件和服务绑定到一起。组件可以获取Service 通过onBind返回的一个IBinder接口，这样两者就可以通信了，这也是Service 应用类通信比较常用的方式。

模拟一个用服务播放音乐的例子来讲一下组件通过Binder 接口和服务之间通信。

/**
 * Created by zhouwei on 17/5/11.
 */

public interface IPlayer {
    // 播放
    public void play();
    // 暂停
    public void pause();
    // 停止
    public void stop();
    // 获取播放进度
    public int getProgress();
    // 获取时长
    public int getDuration();
}

public class MusicService extends Service implements IPlayer{
    public static final String TAG = "MusicService";
    private LocalService mBinder = new LocalService();
    public class LocalService extends Binder{
        public MusicService getService(){
            return MusicService.this;
        }
    }

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

    @Override
    public void play() {
        Log.i(TAG,"music play...");
    }

    @Override
    public void pause() {
        Log.i(TAG,"music pause...");
    }

    @Override
    public void stop() {
        Log.i(TAG,"music stop...");
    }

    @Override
    public int getProgress() {
        return 100;
    }

    @Override
    public int getDuration() {
        return 10240;
    }
}

 private MusicService.LocalService mLocalService;
    private MusicService mMusicService;
    // 绑定/解除绑定 Service 回调接口
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //1 ,获取Binder接口对象
            mLocalService = (MusicService.LocalService) service;
            //2, 获取MusicService 实例
            mMusicService = mLocalService.getService();

            // 只要拿到Music Service 实例之后，就可以调用接口方法了
            // 可以通过它来播放／暂停音乐，还可以通过它来获取当前播放音乐的进度，时长等等

            mMusicService.play();

            mMusicService.pause();

            mMusicService.stop();

            int progress = mMusicService.getProgress();
            Log.i(MusicService.TAG,"progress:"+progress);

            int duration = mMusicService.getDuration();
            Log.i(MusicService.TAG,"duration:"+duration);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
           // 解除绑定后回调
            mMusicService = null;
            mLocalService = null;
        }
    };

Service总结

Service 有2种启动方式，startService 启动服务，服务启动起来后，在后台无限期运行，直到通过stopService 或者stopSelf 停止服务，服务与组件独立，通信比较困难（但还是有办法的，通过BroadcastReceiver ）。另一种方式就是bindService即绑定服务，组件和服务绑定在一起，服务的生命后期受组件影响，如果绑定到服务的组件全部被销毁了，那么服务也就会停止了。绑定服务的方式通常用于组件和服务之间需要相互通信。startService 这种 方式一般用于在后台执行任务，而不需要返回结果给组件。
这两种方式并非完全独立，也就是说，你可以绑定已经通过 startService 启动起来的服务，可以通过在Intent 中添加Action来标示要执行的动作。比如：通过Intent Action 标记要播放的音乐，调用startService来启动音乐服务播放音乐，在界面需要显示播放进度的时候，可以通过binderService来绑定服务，从而获取歌曲信息。这种情况下，Service需要实现两种方式的生命周期。这种情况下，除非所有客户端都已经取消绑定，否则通过stopService 或者 stopSelf是不能停止服务的。
Service是运行在主线程中的，因此不能执行耗时的或者密集型的任务，如果要执行耗时操作或者密集型计算任务，请在服务中开启工作线程，在线程中执行。

原文出处
添加链接描述