Android中的Service

什么是Service

Service是一个可以在后台长时间执行的应用组件。

Service的启动方式

startService

• 启动方式
  在其他组件中调用startService()方法；
• 停止方式
  在Service中调用stopSelf()方法；0
  在其他组件中调用stopService()方法；
• Service与其他组件之间的通信方式
  没有提供默认的通信。

bindService

• 启动方式
  在其他组件中调用bindService()方法；
• 停止方式
  所有与Service绑定的组件都被销毁；
  与Service绑定的组件调用unbindService()方法；
• Service与其他组件之间的通信方式
  可以通过ServiceConnection进行通信，发送请求、获取结果；
  可以通过IPC跨进程完成通信。

注意：

• startService()和bindService()并不冲突，同一个Service可以即被组件调用startService()启动，又被另一个组件调用bindService()绑定启动。
  当同一个Service与其他组件同时存在这两种调用联系的时候，必须从两种方法的角度看该Service均停止，该Service才能真正停止。
• Service并不是运行在一个独立的进程当中，而是依赖于创建Service时所在的应用程序进程。
  当某个应用程序进程被杀掉后，所有依赖于该进程的Service也会停止运行。

Service的创建

• public void onCreate()
  只有在Service创建的时候调用一次。
• public int onStartCommand(Intent intent,int flags,int startId)
  当组件调用startService()方法时，此方法被执行，在这里进行Service的主要操作。
• public IBinder onBind(Intent intent)
  当组件调用bindService()方法的时候调用，此时该Service将与组件绑定。
• public void onDestroy()
  Service停止的时候调用该方法。

启动Service

startService()

当组件调用startService()方法的时候，就可以启动指定的Service了，同时这将导致Service中的onStartCommande()方法被调用。

Intent intent = new Intent(getContext(),Service.class);
startService(intent);

在调用startService()方法时候，传入的Intent参数可以携带数据，该数据将在Service执行onStartCommand()方法中接收：

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

bindService()

当组件调用bindService()方法的时候，将启动指定的Service，并且将该组件与该Service进行绑定。
通常，将绑定它的组件称为客户端，将被绑定的Service称为服务器。
要完成客户端与服务器端的绑定，需要完成以下两件事情：

• 在客户端完成bindService()的调用以及相关配置；
• 在服务器端完成onBind()方法的重写，返回一个IBinder接口给客户端。

客户端的配置

public boolean bindService(Intent service,ServiceConnection connection,int flags) {}

在bindService()方法中，需要三个参数：

• Intent：用来指定启动哪一个Service，同时可以传递一些数据；
• ServiceConnection：用以实现客户端与服务器端的关键类，此时我们需要重写该类的两个回调方法
  1.onServiceConneced()
  2.onServiceDisconnected()
  而我们可以通过这两个回调方法得到服务端的IBinder对象，从而通过该IBinder对象实现客户端与服务端的通信。

Service mService;
Service.Binder mBinder;
private ServiceConnection mConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name,IBinder service) {
        mBinder = (Service.Binder) service;
        mService = mBinder.gerService();
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {}
}

• int：用于指定绑定选项的标志，一般是BIND_AUTO_CREATE。

服务端的配置

如果要创建一个支持绑定的Service，我们必须要重写它的onBind()方法。
这个方法返回一个IBinder对象，它是服务端对客户端暴露的交互接口。
而要得到IBinder接口，通常有三种方式：

• 继承Binder类
• 使用Messenger类
• 使用AIDL

继承Binder类

Binder类实现了IBinder接口，通过实现Binder类，客户端可以直接通过这个类调用服务端的公有方法。
具体实现步骤：

• 在Service类中，创建一个继承Binder类的内部类；
• 在onBind()方法中返回这个Binder内部类的实例；
• 在客户端中通过绑定Service获得Binder内部类的实例，通过它提供的方法进行后续的通信操作。
  服务端示例代码：

public class LocalService extends Service {
    private final IBinder mBinder = new LocalBinder();
    private final Random mGenerator = new Random();
    public class LocalBinder extends Binder {
        public LocalService gerService() {
              return LocalService.this;
        }
    }

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

    public int getRandomNumber() {
        return mGenerator.netInt(100);
    }
}

LocalBinder为客户端提供了getService()方法，用以获得LocalService的当前实例。这样，客户端绑定服务端后，就可以调用服务中的公有方法（例如getRandomNumber()）。
客户端示例代码：

public class BindingActivity extends Activity {
    LocalService mService;
    boolean mBound = false;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    @Override
    protected void onStart() {
        super.onStart();
        Intent intent = new Intent(this,LocalService.class);
        bindService(intent,mConnection,Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        if (mBond) {
            unbindService(mConnection);
        }
    }

    public void onButtonClick(View v) {
        if  (mBound) {
            int num = mService.getRandomNumber();
        }
    }

    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(CompondName name,IBinder service) {
            LocalBinder binder = (LocalBinder) service;
            mService = binder.getService();
            mBound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            mBound = false;
        }
    }
}

使用Messenger

Messenger的核心就是Message以及Handler来进行线程间的通信。
具体实现步骤：

• 服务端实现一个Handler，由其接受来自客户端的每一个调用的回调；
• 使用实现的Handler创建一个Messenger对象；
• 通过Messenger得到一个IBinder对象，并将其通过onBind()返回给客户端；
• 客户端使用IBinder将Messenger（引用服务的Handler）实例化，然后使用后者将Messag对象发送给服务；
• 服务端在Handler中接收每个Message。
  使用该方法，客户端通过传递Message来与服务端进行交互。
  服务端示例代码：

public class MessengerService extends Service {
    static final int MSG_SAY_HELLO = 1;
    class ServiceHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch(msg.what) {
                case MSG_SAY_HELLO:
                    Toast.maktText(getApplicationContext(),"Hello",Toast.LENGTH_SHORT).show();
                    break;
            }
        }

        final Messenger mMessenger = new Messenger(new ServiceHandler());

        @Override
        public IBinder onBind(Intent intent) {
              return mMessenger.getBinder();//返回给客户端一个IBinder实例，用于给客户端构造Messenger
        }
    }
}

服务端主要是返回给客户端一个IBinder实例，以供客户端构造Messenger，并且处理客户端发送过来的Message。
此时，我们需要在Manifests.xml中完成对Messenger的注册。

客户端示例代码：

public class ActivityMessenger extends Activity {
    static final int MSG_SAY_HELLO = 1;
    Messenger mService = null;
    boolean mBound;
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName name,IBinder service) {
            mService = new Messenger(service);//利用服务端返回的IBinder实例，构造Messenger
            mBound = true;
        }

        public void onServiceDisconneted(ComponentName name) {
            mService = null;
            mBound = false;
        }

        public void sayHello() {
            if (mBound) {
                Message msg = new Message();
                msg.what = MSG_SAY_HELLO;
                try {
                    mService.send(msg);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }

    @Override
    protected void onCreate(Bundle sacedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }

    @Override
    protected void onStart() {
            super.onStart();

            Intent intent = new Intent("com.mglee.messenger");
            intent.setPackage("com.mglee");//包名是一定要设置的，不然会报错
            bindService(intent,mConnection,BIND_AUTO_CREATE);
        }

    @Override
    protected void onStop() {
            super.onStop();

            if (mBound) {
                unbindService(mConnection);
                mBound = false;
            }
        }
    }
}

客户端通过绑定服务获取服务端返回的IBinder实例，借此构造Messenger，从而用Messenger发送Message的方式与服务端进行交互。
上面的示例中，只是演示了客户端向服务端的单方面数据通信，而要让服务端向客户端实现数据通信，只需要客户端也创建一个Handler实例，让它接受来自服务端的信息，同时让服务端在客户端给他发送的请求完成之后再给客户端发送一条信息即可。

AIDL

AIDL，Android接口自定义语言。
既然是接口自定义语言，其实就是系统根据它完成IInterface实例的代码，其实就是一种代码模板。
使用AIDL实现服务端和客户端通信的基本步骤：

• 服务端创建一个AIDL文件，将需要暴露给客户端的接口在里面声明；
• 在Service中实现这些接口；
• 客户端绑定服务端，并将onServiceConnected()得到的IBinder转换为AIDL生成的IInterface实例；
• 同构得到的实例调用暴露的方法，完成与服务端的数据通信。