Activity與Service通訊

Activity與Service通訊的方式有三種：

 

繼承Binder類

  這個方式只有當你的Acitivity和Service處於同一個Application和進程時，才能夠用，好比你後臺有一個播放背景音樂的Service，這時就能夠用這種方式來進行通訊。

用例子來講明其使用方法：

  1. 來看Service的寫法：

 

public class LocalService extends Service {
    // 實例化自定義的Binder類
    private final IBinder mBinder = new LocalBinder();
    // 隨機數的生成器
    private final Random mGenerator = new Random();

    /**
     * 自定義的Binder類，這個是一個內部類，因此能夠知道其外圍類的對象，經過這個類，讓Activity知道其Service的對象
     */
    public class LocalBinder extends Binder {
        LocalService getService() {
            // 返回Activity所關聯的Service對象，這樣在Activity裏，就可調用Service裏的一些公用方法和公用屬性
            return LocalService.this;
        }
    }

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

    /** public方法，Activity能夠進行調用 */
    public int getRandomNumber() {
      return mGenerator.nextInt(100);
    }
}

 

   在Service裏定義一個內部類，Binder的子類，經過這個類，把Service的對象傳給Activity，這樣Activity就能夠調用Service裏的公用方法和公用屬性了，但這種方式，必定要在同一個進程和同一個Application裏。

   2. 再看相應Activity的代碼：

 

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();
        // 綁定Service，綁定後就會調用mConnetion裏的onServiceConnected方法
        Intent intent = new Intent(this, LocalService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // 解綁Service，這樣能夠節約內存
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }

    /** 用戶點擊button，就讀取Service裏的隨機數 */
    public void onButtonClick(View v) {
        if (mBound) {
            // 用Service的對象，去讀取隨機數
            int num = mService.getRandomNumber();
            Toast.makeText(this, "number: " + num, Toast.LENGTH_SHORT).show();
        }
    }

    /** 定交ServiceConnection，用於綁定Service的*/
    private ServiceConnection mConnection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName className,
                IBinder service) {
            // 已經綁定了LocalService，強轉IBinder對象，調用方法獲得LocalService對象
            LocalBinder binder = (LocalBinder) service;
            mService = binder.getService();
            mBound = true;
        }

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

 

   這裏就是經過IBinder來獲得LocalService對象，再去調用其Public方法。

使用Messenger

   上面的方法只能在同一個進程裏才能用，若是要與另一個進程的Service進行通訊，則能夠用Messenger。

    其實實現IPC的方式，還有AIDL，但推薦使用Messenger，有兩點好處：

      1. 使用Messenger方式比使用AIDL的方式，實現起來要簡單不少

      2. 使用Messenger時，全部從Activity傳過來的消息都會排在一個隊列裏，不會同時請求Service，因此是線程安全的。若是你的程序就是要多線程去訪問Service，就能夠用AIDL，否則最好使用Messenger的方式。

  不過，其實Messenger底層用的就是AIDL實現的，看一下實現方式，先看Service的代碼：

 

public class MessengerService extends Service {
    /** 用於Handler裏的消息類型 */
    static final int MSG_SAY_HELLO = 1;

    /**
     * 在Service處理Activity傳過來消息的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);
            }
        }
    }

    /**
     * 這個Messenger能夠關聯到Service裏的Handler，Activity用這個對象發送Message給Service，Service經過Handler進行處理。
     */
    final Messenger mMessenger = new Messenger(new IncomingHandler());

    /**
     * 當Activity綁定Service的時候，經過這個方法返回一個IBinder，Activity用這個IBinder建立出的Messenger，就能夠與Service的Handler進行通訊了
     */
    @Override
    public IBinder onBind(Intent intent) {
        Toast.makeText(getApplicationContext(), "binding", Toast.LENGTH_SHORT).show();
        return mMessenger.getBinder();
    }
}

 

 再看一下Activity的代碼：

public class ActivityMessenger extends Activity {
    /** 向Service發送Message的Messenger對象 */
    Messenger mService = null;

    /** 判斷有沒有綁定Service */
    boolean mBound;

    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            // Activity已經綁定了Service
            // 經過參數service來建立Messenger對象，這個對象能夠向Service發送Message，與Service進行通訊
            mService = new Messenger(service);
            mBound = true;
        }

        public void onServiceDisconnected(ComponentName className) {
            mService = null;
            mBound = false;
        }
    };

    public void sayHello(View v) {
        if (!mBound) return;
        // 向Service發送一個Message
        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();
        // 綁定Service
        bindService(new Intent(this, MessengerService.class), mConnection,
            Context.BIND_AUTO_CREATE);
    }

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

 注意：以上寫的代碼只能實現從Activity向Service發送消息，若是想從Service向Activity發送消息，只要把代碼反過來寫就能夠了。

 

使用AIDL

  這個方法略，若是知道上面兩種方法，這個方法基本不多會用到。