一天一Android之Service

在Android系统中，知道为什么有些软件杀不死么？很大的原因就是Service。那Service是什么？

Service是Android四大组件之一，开发中会经常用到它，例如当检测到App有新版本的时候，这时候我们一般会开启一个Service去后台下载新包，这时候，无论用户是否清除我们的App，都不会影响下载进度。

Service

生命周期

Service和Activity一样，都有各自的生命周期，不同的是，由于Service有两种启动方式，其生命周期也不同。

startService

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

startService启动服务后，会执行如下生命周期：onCreate()->onStart()(已经废弃)->onStartCommand()->onDestroy。

onCreate():首次启动服务的时候，系统会调用这个方法，在onStartCommand和onBind方法之前，如果服务已经启动了，再次启动时，则不会调用此方法，因此可以在onCreate方法中做一些初始化的操作。比如要执行耗时的操作，可以在这里创建线程。
onStartCommand():当通过startService()方法来启动服务的时候，在onCreate方法之后就会调用这个方法，此方法调用后，服务就启动了，将会在后台无限期的运行，直到通过stopService或者stopSelf方法来停止服务。
onDestroy:当服务不再使用且将被销毁是，系统将调用此方法，服务应该事先此方法来清理所有资源，如线程等。

了解完这几个生命周期方法后，我们来写一个简单的Service：

要使用Service就要通过继承Service类来实现，如下：

public class SimpleService extends Service {
    public static final String TAG = "SimpleService";
    
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG,"call onBind...");
        return null;
    }
    @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...");
    }
}

切记，Service类写好后，需要在AndroidManifest.xml文件中注册：

<service
    android:name=".SimpleService"
    android:enabled="true"
    android:exported="true">
</service>

然后，我们在Activity中放置两个按钮，一个启动Service，一个停止Service：

@Override
public void onClick(View v) {
    switch (v.getId()){
        case R.id.start_service:
            Intent intent = new Intent(this,SimpleService.class);
            // 启动服务
            startService(intent);
            break;
        case R.id.stop_service:
            Intent service = new Intent(this,SimpleService.class);
            // 停止服务
            stopService(service);
            break;
    }
}

可以看到如下打印日志：

小结：通过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 对象，与服务进行通信。

public class ServiceDemoActivity extends AppCompatActivity {
    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;
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_service_demo);
    }
    //绑定服务
    public void bindServer(View view) {
        Intent intent = new Intent(this,SimpleService.class);
        bindService(intent,mConnection, Context.BIND_AUTO_CREATE);
    }
    //解除绑定
    public void unBindServer(View view) {
        unbindService(mConnection);
    }
}

点击绑定按钮，即绑定服务，并且在onServiceConnected中得到MyBinder对象，就可以通过这个对象和服务通信了，生命周期方法调用如下：

可以看到，绑定服务的生命周期内依此调用了onCreate,onBind,onUnbind和 onDestroy方法，只有中间两个生命周期方法与startService启动服务是不同的。一张图就能看清两种方式的生命周期的异同：

tips: Service 的生命周期方法不同与Activity ，不需要调用超类的生命周期方法，如：不用调用 super.onCreate（）

注意，当使用startService方式启动Service的时候，可以通过手机的设置查看到启动的服务，而通过bindService方式启动的则不能。这很好理解，前者跟我们的应用程序的存活周期没有关系，有时候需要手动杀掉Service。

Service通信

BroadcastReceiver

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

场景描述：通过startService启动一个长期在后台运行的下载图片服务，然后在界面上点击下载按钮，通过intent传递一个下载链接给Service，在下载完成后，通过BroadcastReceiver通过Activity界面显示图片。看一下代码实现：

Service:

public class DownloadService extends Service {
    public static final String IMAGE = "iamge_url";
    public static final String RECEIVER_ACTION = "simpleservice";
    private static final String TAG = "DownloadService";
    public static final String ACTION_START_SERVICER = "startservice";
    public static final String ACTION_DOWNLOAD = "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);
    }
}

新建了一个DownloadService，在里面启动了一个工作线程，在线程里下载图片，然后通过BroadcastReceiver通知Activity显示。

Activity的代码很简单，注册BroadcastReceiver，在onReceiver中显示图片就好了，代码如下：


public class ServiceDemoActivity extends AppCompatActivity {
    private ImageView mImageView;
    
    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            Bitmap bitmap = intent.getParcelableExtra("bitmap");
            mImageView.setImageBitmap(bitmap);
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_service_demo);
        mImageView = (ImageView) findViewById(R.id.imageView);
        //注册广播
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(DownloadService.RECEIVER_ACTION);
        LocalBroadcastManager.getInstance(this).registerReceiver(mReceiver,intentFilter);
    }
    
    public void startDownload(View view) {
        Intent intent = new Intent(this,DownloadService.class);
        intent.putExtra("url","http://www.8kmm.com/UploadFiles/2012/8/201208140920132659.jpg");
        intent.setAction(DownloadService.ACTION_DOWNLOAD);
        startService(intent);
    }
}

LocaService 使用Binder 和服务通信

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

下面就模拟一个用服务播放音乐的例子来讲一下组件通过Binder 接口和服务之间通信。
首先定义一个通信的接口 IPlayer：

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

然后添加一个MusicService 类，继承Service 实现 Iplayer 接口：

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;
    }
}

其中比较重要的就是内部类LocalService，继承Binder,里面提供一个getService方法，返回MusicService实例，组件通过IBinder获取到Music实例后，就可以和Service之间相互通信啦！

Activity中代码如下：

public class ServiceDemoActivity extends AppCompatActivity {
    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;
        }
    };
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_service_demo);
    }
    
    public void bindServer(View view) {
        Intent intent = new Intent(this, MusicService.class);
        bindService(intent,mConnection, Context.BIND_AUTO_CREATE);
    }
}

获取到MusicService后，就可以调用接口方法了，比如：播放音乐，暂停、停止、获取进度等等。

Service 总结

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

Service是运行在主线程中的，因此不能执行耗时的活着密集型的任务，如果要执行耗时操作或者密集型计算任务，请在服务中开启工作线程，在线程中执行。或者使用下面一节将要讲的IntentService。

IntentService

IntentService是Service的子类，它使用工作线程逐一处理所有启动请求，果您不要求服务同时处理多个请求，这是最好的选择。您只需实现onHandIntent方法即可，该方法会接收每个启动请求的Intent，使您能够执行后台工作。

IntentService默认为我们开启了一个工作线程，在任务执行完毕后，自动停止服务，因此在我们大多数的工作中，使用IntentService就够了，并且IntentService比较简单，只要实现一个方法OnHandleIntent，接下来看一下示例：

public class MyIntentService extends IntentService {
    public static final String TAG ="MyIntentService";
    public MyIntentService() {
        super("MyIntentService");
    }
    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        // 这里已经是工作线程，在这里执行操作就行
        boolean isMainThread =  Thread.currentThread() == Looper.getMainLooper().getThread();
        Log.i(TAG,"is main thread:"+isMainThread);
        // 执行耗时下载操作
        mockDownload();
    }
    /**
     * 模拟执行下载
     */
    private void mockDownload(){
       try {
           Thread.sleep(5000);
           Log.i(TAG,"下载完成...");
       }catch (Exception e){
           e.printStackTrace();
       }
    }
}

然后启动服务，看一下打印的日志，如下图：

IntentService 总结

IntentService是Service的子类，默认给我们开启了一个工作线程执行耗时任务，并且执行完任务后自动停止服务。扩展IntentService比较简单，提供一个构造方法和实现onHandleIntent方法就可了，不用重写父类的其他方法。但是如果要绑定服务的话，还是要重写onBind返回一个IBinder的。使用Service可以同时执行多个请求，而使用IntentService只能同时执行一个请求。

一天一Android之Service

Service

生命周期

startService

bindService

Service通信

BroadcastReceiver

LocaService 使用Binder 和服务通信

Service 总结

IntentService

IntentService 总结

分享到微信朋友圈

分享到微信朋友圈

分享到微信朋友圈

贵永冬

一天一Android之Service

Service

生命周期

startService

bindService

Service通信

BroadcastReceiver

LocaService 使用Binder 和 服务通信

Service 总结

IntentService

IntentService 总结

分享到微信朋友圈

分享到微信朋友圈

分享到微信朋友圈

贵永冬

初识ReactiveCocoa

深入ReactiveCocoa

ReactiveCocoa和RXSwift速查表

关于RAC的一些资料

RunLoop总结

聊一聊GCD的那些事

聊一聊NSOperation的那些事

iOS动画篇之UIView动画

iOS动画篇之CoreAnimation动画

iOS动画之CATransition动画

LocaService 使用Binder 和服务通信