Android开发——Service的学习（下）

Bound Service 是客户端-服务器模式的服务，它允许允许组件（比如activity）对其进行绑定、发送请求、接收响应、甚至进行进程间通信（IPC）。为了提供绑定，开发人员必须实现onBind()毁掉方法，该方法返回IBinder对象，它定义了客户端用来与服务交互的程序接口。

客户端通过bindService()方法绑定到服务。此时，客户端必须提供ServiceConnection接口的实现类，它监视客户端和服务之间的连接。多个客户端能够同时连接服务器。然而仅当第一个客户端绑定时，系统调用服务的onBind()方法来获取IBinder对象。然后，系统会向后续请求绑定的客户端传送这同一个 IBinder ，而不再调用 onBind() 。

当最后一个客户端解除绑定后，系统会销毁服务（除非服务同时是通过 startService() 启动的）。

一：创建Bound服务

当你实现自己的bound服务时，最重要的工作就是定义 onBind() 回调方法所返回的接口。有一下三种方式：

（1）继承Binder类

如果服务是你的应用程序所私有的，并且与客户端运行于同一个进程中（通常都是如此），你应该通过j继承 Binder 类来创建你的接口,并从 onBind() 返回一个它的实例。客户端接收该 Binder 对象并用它来直接访问 Binder 实现类或者 Service 中可用的公共（public）方法。

如果服务只应用于私有应用程序，那这就是首选的技术方案。如果服务要被其它应用程序使用或者访问独立进程时，则不能使用该技术。

仅当客户端与服务位于同一个应用程序和进程时，才可以。例如音乐播放我绑定activity到自己的服务来在后台播放音乐。

实现步骤如下：

在你的服务中，创建一个 Binder 的实例，实现以下三者之一：

（1）包含客户端能调用的公共方法

（2）返回当前service实例，其中包含客户端能够调用的公共方法

（3）返回服务管理的其他类的实例，其中包含客户端能够调用的公共方法

从回调方法 onBind() 中返回 Binder 类的实例。
在客户端中，在回调方法 onServiceConnected() 中接收 Binder 类实例并用所提供的方法对绑定的服务进行调用。

以下是一个服务的示例，它通过实现一个 Binder 来为客户端访问它内部的方法提供支持：

public class LocalService extends Service {
    // 给客户端的Binder
    private final IBinder mBinder = new LocalBinder();
    // 产生随机数
    private final Random mGenerator = new Random();


    public class LocalBinder extends Binder {
        LocalService getService() {
            // 返回LocalService 的实例，其中包含客户端可以调用的方法
            return LocalService.this;
        }
    }

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

    /**客户端可以调用的方法 */
    public int getRandomNumber() {
      return mGenerator.nextInt(100);
    }
}

LocalBinder为客户端提供了getService()方法，用于返回当前LocalService的实例。这就让客户端可以调用服务中的公共方法。比如，客户端可以调用服务中的getRandomNumber()。

以下是一个绑定到LocalService的activity，当点击按钮时，它会调用getRandomNumber()：

public class BindingActivity extends Activity {
    LocalService mService;
    boolean mBound = false;

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

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

    @Override
    protected void onStop() {
        super.onStop();
        // 解除绑定的服务
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }

    /** 点击Button时，调用此方法 */
    public void onButtonClick(View v) {
        if (mBound) {
            // 调用LocalService中的方法。
            // 不过，如果该调用会导致某些操作的挂起，那么调用应该放入单独的线程中进行，
            // 以免降低activity的性能。
            int num = mService.getRandomNumber();
            Toast.makeText(this, "number: " + num, Toast.LENGTH_SHORT).show();
        }
    }

    /** 定义服务绑定的回调方法，将其传给bindService（） */
    private ServiceConnection mConnection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName className,
                IBinder service) {
            // 我们已经绑定了服务, 将IBinder转型获得LocalService实例
            LocalBinder binder = (LocalBinder) service;
            mService = binder.getService();
            mBound = true;
        }

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

上述例子展示了客户端如何利用 ServiceConnection 和 onServiceConnected() 回调方法绑定到服务。

（2）使用Messenger类

如果你的服务需要与远程进程进行通信，那你可以使用一个 Messenger 来提供服务的接口。这种技术能让你无需使用AIDL就能进行进程间通信（IPC），这是执行进程间通信（IPC）最为简便的方式。

以下是使用方法：

服务实现一个 Handler ，用于客户端每次调用时接收回调。
此 Handler 用于创建一个 Messenger 对象（它是一个对 Handler 的引用)。
此 Messenger 对象创建一个 IBinder ，服务在 onBind() 中把它返回给客户端。
客户端用 IBinder 将 Messenger （引用服务的 Handler ）实例化，客户端用它向服务发送消息对象 Message 。
服务接收 Handler 中的每个消息 Message ——确切的说，是在 handleMessage() 方法中接收。

通过这种方式，客户端不需要调用服务中的“方法”。取而代之的是，客户端发送“消息”（ Message 对象），服务则接收位于 Handler 中的这个消息。

public class MessengerService extends Service {
   
    static final int MSG_SAY_HELLO = 1;

    /**
     * 服务处理客户端发来的消息
     * 服务实现了一个Handler
     */
    class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_SAY_HELLO:
                    Toast.makeText(getApplicationContext(), "hello!", Toast.LENGTH_SHORT).show();
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    /**
     * 给客户端使用的用来发送消息给 IncomingHandler.即为，第二步。
     */
    final Messenger mMessenger = new Messenger(new IncomingHandler());

    /**
     * 返回一个接口用来给服务发送消息，即为，第三步
     */
    @Override
    public IBinder onBind(Intent intent) {
        Toast.makeText(getApplicationContext(), "binding", Toast.LENGTH_SHORT).show();
        return mMessenger.getBinder();
    }
}

客户端要做的全部工作就是根据服务返回的 IBinder 创建一个 Messenger ，并用 send() 方法发送一个消息。例如，以下是一个activity示例，它绑定到上述服务，并向服务发送 MSG_SAY_HELLO消息：

public class ActivityMessenger extends Activity {
    /** 和service沟通的Messenger. */
    Messenger mService = null;

    /** 是否已经绑定 */
    boolean mBound;

    /**
     * 与服务进行交互
     */
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            // 与服务建立联接后将会调用本方法，
            // 给出用于和服务交互的对象。
            // 我们将用一个Messenger来与服务进行通信，
            // 因此这里我们获取到一个原始IBinder对象的客户端实例。
            mService = new Messenger(service);
            mBound = true;
        }

        public void onServiceDisconnected(ComponentName className) {
            // 当与服务的联接被意外中断时——也就是说服务的进程崩溃了，
            // 将会调用本方法。
            mService = null;
            mBound = false;
        }
    };

    public void sayHello(View v) {
        if (!mBound) return;
        //  创建并向服务发送一个消息，用到了已约定的'what'值
        Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO, 0, 0);
        try {
            mService.send(msg);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

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

    @Override
    protected void onStart() {
        super.onStart();
        //绑定到服务
        bindService(new Intent(this, MessengerService.class), mConnection,
            Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // 解除绑定
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }
}

二：绑定到服务

应用程序组件（客户端）可以通过调用 bindService() 来绑定服务。然后Android系统会调用服务的 onBind() 方法，返回一个用于和服务进行交互的 IBinder 。

绑定是异步进行的。 bindService() 将立即返回，并不会向客户端返回 IBinder 。为了接收 IBinder ，客户端必须创建一个 ServiceConnection 的实例，并把它传给 bindService() 。 ServiceConnection 包含了一个回调方法，系统将会调用该方法来传递客户端所需的那个 IBinder 。

注意：只有activity、service和content provider才可以绑定到服务上——broadcast receiver不能绑定服务。

因此，要把客户端绑定到服务上，你必须：

实现 ServiceConnection 。你的实现代码必须重写两个回调方法：onServiceConnected()系统调用该方法来传递服务的 onBind() 方法所返回的 IBinder 。onServiceDisconnected()当与服务的联接发生意外中断时，比如服务崩溃或者被杀死时，Android系统将会调用该方法。客户端解除绑定时，不会调用该方法。
调用 bindService() ，传入已实现的 ServiceConnection 。
当系统调用你的 onServiceConnected() 回调方法时，你可以利用接口中定义的方法开始对服务的调用。
要断开与服务的联接，请调用 unbindService() 。

当客户端被销毁时，与服务的绑定也将解除。但与服务交互完毕后，或者你的activity进入pause状态时，你都应该确保解除绑定，以便服务能够在用完后及时关闭。

LocalService mService;
private ServiceConnection mConnection = new ServiceConnection() {
    // 与服务的联接建立之后将会调用
    public void onServiceConnected(ComponentName className, IBinder service) {
        // 因为我们已经与明显是运行于同一进程中的服务建立了联接，
        // 我们就可以把它的IBinder转换为一个实体类并直接访问它。
      LocalBinder binder = (LocalBinder) service;
        mService = binder.getService();
        mBound = true;
    }

    // 与服务的联接意外中断时将会调用
    public void onServiceDisconnected(ComponentName className) {
        Log.e(TAG, "onServiceDisconnected");
        mBound = false;
    }
};

利用这个 ServiceConnection ，客户端就能够把它传入 bindService() 完成与服务的绑定。

Intent intent = new Intent(this, LocalService.class);
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);

Android开发——Service的学习（下）

猜你喜欢