1. 廣播交互
提到Activity與Service的交互,可能狠多人首先想到的就是BroadCast——廣播。在Android中,廣播是系統提供的一種很好的交互方式。比如:在電池電量過低,開機完成等情況下,系統都會發出相應的系統廣播,我們的應用程序只需要註冊相應的廣播接收器,就可以接收到這些系統的廣播。同時,我們也可以定義自己的廣播,這樣在不同的Activity、Service以及應用程序之間,就可以通過廣播來實現交互。我們通過模擬應用程序後臺下載的情況來分析Service與Activity的交互方式。實現效果如圖1.1:
圖1.1
當我們點擊StartService按鈕之後,界面上的進度條將會每隔一秒加1。因爲是模擬下載,因此下載動作我們在Service中通過一個Timer定時器來實現,在Timer中對一個整型數據i進行自加(i++),然後Client端獲取Server端的i值並顯示在界面上,從而達到模擬的目的。
1.1. 實現原理
Server端將目前的下載進度,通過廣播的方式發送出來,Client端註冊此廣播的監聽器,當獲取到該廣播後,將廣播中當前的下載進度解析出來並更新到界面上。
1.2. 實現步驟
1.2.1 在Client端中通過startService()啟動Service。
- if(v == startBtn){
- Log.i(TAG, "start button clicked...pid: "+Process.myPid());
- mIntent.setClass(BroadCastService.this, DownLoadService.class);
- startService(mIntent);
- }
1.2.2 DownLoadService接到啓動的命令之後,執行onCreate()方法,並在其中開啓timer計數模擬下載。
- @Override
- public void onCreate() {
- super.onCreate();
- Log.i(TAG, "DownLoadService.onCreate()...pid: "+Process.myPid());
- intent = new Intent("com.seven.broadcast");
- mTimer = new Timer();
- mTimer.schedule(new MyTimerTask(), 0 , TIME * 1000);
- }
1.2.3 在Server端的timer計數其中發送廣播,告知Client端目前下載進度。
- class MyTimerTask extends TimerTask{
- @Override
- public void run() {
- if(i==100){
- i=0;
- }
- intent.putExtra("CurrentLoading", i);
- sendBroadcast(intent);
- i++;
- Log.e(TAG, "i= "+i);
- }
- }
1.2.4 在Client端通過匿名內部類的方式實例化BroadcastReceiver並覆寫其中的onReceive()方法。
- BroadcastReceiver receiver = new BroadcastReceiver() {
- @Override
- public void onReceive(Context context, Intent intent) {
- if(MYACTION.equals(intent.getAction())){
- Log.i(TAG, "get the broadcast from DownLoadService...");
- curLoad = intent.getIntExtra("CurrentLoading", ERROR);
- mHandler.sendMessage(mHandler.obtainMessage());
- }
- }
- };
1.2.5 更新主介面下載進度。
- Handler mHandler = new Handler(){
- @Override
- public void handleMessage(Message msg) {
- super.handleMessage(msg);
- Log.i(TAG, "current loading: "+curLoad);
- if(curLoad<0||curLoad>100){
- Log.e(TAG, "ERROR: "+curLoad);
- return;
- }
- mProgressBar.setProgress(curLoad);
- mTextView.setText(curLoad+"%");
- }
- };
1.2.6 一定要對Broadcast進行註冊和取消註冊。只有註冊之後相應的broadcast之後才能接收到廣播註冊方法有兩種。
動態註冊/取消註冊:
- @Override
- protected void onResume() {
- super.onResume();
- Log.i(TAG, "register the broadcast receiver...");
- IntentFilter filter = new IntentFilter();
- filter.addAction(MYACTION);
- registerReceiver(receiver, filter);
- }
- @Override
- protected void onDestroy() {
- super.onDestroy();
- Log.i(TAG, "unregister the broadcast receiver...");
- unregisterReceiver(receiver);
- }
靜態註冊:
- <receiver android:name="MyBroadcastReceiver">
- <intent-filter>
- <action android:name="com.seven.broadcast" />
- </intent-filter>
- </receiver>
最後貼出整個AndroidManifest.xml文件
- <application android:icon="@drawable/icon" android:label="@string/app_name">
- <activity android:name=".BroadCastService"
- android:label="@string/app_name">
- <intent-filter>
- <action android:name="android.intent.action.MAIN" />
- <category android:name="android.intent.category.LAUNCHER" />
- </intent-filter>
- </activity>
- <service android:name="DownLoadService" android:process=":remote"/>
- </application>
1.3 小結
通過廣播的方式實現Activity與Service的交互操作簡單且容易實現,可以勝任簡單級的應用。但缺點也十分明顯,發送廣播受到系統制約。系統會優先發送系統級廣播,在某些特定的情況下,我們自定義的廣播可能會延遲。同時在廣播接收器中不能處理長耗時操作,否則系統會出現ANR即應用程序無響應。
2. 共享文件交互
這裏提到的共享文件指的是Activity和Service使用同一個文件來達到傳遞數據的目的。我們使用SharedPreferences來實現共享,當然也可以使用其它IO方法實現,通過這種方式實現交互時需要注意,對於文件的讀寫的時候,同一時間只能一方讀一方寫,不能兩方同時寫。實現效果如圖2.1:
圖2.1
2.1 實現原理
Server端將當前下載進度寫入共享文件中,Client端通過讀取共享文件中的下載進度,並更新到主界面上。
2.2 實現步驟
2.2.1 在Client端通過startService()啟動Service。
- if(startSerBtn==v){
- Log.i(TAG, "Start Button Clicked.");
- if(intent!=null){
- startService(intent);
- timer.schedule(new MyTimerTask(), 0, TIME * 1000);
- }
- }
2.2.2 Server端收到啓動intent之後執行onCreate()方法,並開啓timer,模擬下載,以及初始化SharedPreferences對象preferences。
- @Override
- public void onCreate() {
- super.onCreate();
- Log.i(TAG, "DownLoadService.onCreate()...");
- preferences = getSharedPreferences("CurrentLoading_SharedPs", 0);
- timer = new Timer();
- timer.schedule(new MyTimerTask(), 0, TIME*1000);
- }
2.2.3 開始計數並將下載進度寫入shared_prefs文件夾下的xml文件中,內容以鍵值對的方式保存。
- class MyTimerTask extends TimerTask{
- @Override
- public void run() {
- setCurrentLoading();
- if(100==i){
- i=0;
- }
- i++;
- }
- }
- private void setCurrentLoading() {
- preferences.edit().putInt("CurrentLoading", i).commit();
- }
首先,使用sharedPreferences前需要獲取文件引用。
preferences = getSharedPreferences("CurrentLoading_SharedPs", 0);
其次,使用sharedpreferences寫數據方式。
preferences.edit().putInt("CurrentLoading", i).commit();
最後,讀取數據的方式。
int couLoad = preferences.getInt("CurrentLoading", 0);
2.2.4 Client端通過讀取/data/data/com.seven.servicetestdemo/shared_prefs文件夾下的xml文件,並取得裏面的鍵值對,從而獲取到當前的下載進度,並更新到主界面上。
- Handler mHandler = new Handler(){
- @Override
- public void handleMessage(Message msg) {
- super.handleMessage(msg);
- int couLoad = preferences.getInt("CurrentLoading", 0);
- mProgressBar.setProgress(couLoad);
- currentTv.setText(couLoad+"%");
- }
- };
2.3 小結
因為方法簡單,因此就不貼出AndroidManifest.xml文件了。對於這種方式實現Activity與Service的交互,可以說很方便,就像使用管道,一個往裡寫,一個往外讀。但這種方式也有缺陷,寫入數據較爲複雜以及數據量較大時,就有可能導致寫入與讀數據出不一致的錯誤。同時因爲經過了一箇中轉站,這種操作將更耗時。
3. Messenger交互(信使交互)
Messenger翻譯過來指的是信使,它引用了一個Handler對象,別人能夠向它發送消息(使用mMessenger.send(Message msg)方法)。該類允許跨進程間基於Message通信,在服務端使用Handler創建一個 Messenger,客戶端只要獲得這個服務端的Messenger對象就可以與服務端通信了。也就是說我們可以把Messenger當做Client端與Server端的傳話筒,這樣就可以溝通交流了。實現效果如圖3.1:
圖3.1
3.1 實現原理
在Server端與Client端之間通過一個Messenger對象來傳遞消息,該對象類似於信息中轉站,所有信息通過該對象攜帶。
3.2 Messenger的一般用法
(1). 在Server端創建信使對象。
mMessenger = new Messenger(mHandler)
(2). Client端使用bindService()綁定Server端。
(3). Server端的onBind()方法返回一個binder對象。
return mMessenger.getBinder();
(4). Client端使用返回的binder對象得到Server端信使。
- public void onServiceConnected(ComponentName name, IBinder service) {
- rMessenger = new Messenger(service);
- ......
- }
- public Messenger(IBinder target) { mTarget = IMessenger.Stub.asInterface(target); }
(5). Client端可以使用這個Server端的信使對象向Server端發送消息。
rMessenger.send(msg);
這樣Server端的Handler對象就能收到消息了,然後可以在其handlerMessage(Message msg)方法中進行處理。經過這5個步驟之後只有Client端向Server端發送消息,這樣的消息傳遞是單向的,那麼如何實現消息的雙向傳遞呢?
首先需要在第5步做修改,在send(msg)前通過msm.replyTo = mMessenger將Client端自己的信使設置到消息中,這樣Server端接收到消息時同時也得到了Client端的信使對象,然後Server端也可以通過使用得到的Client端的信使對象來項Client端發送消息 cMessenger = msg.replyTo2 cMessenger.send(message);
這樣即完成了從Server端向Client端發送消息的功能,這樣Client端可以在自己的Handler對象的handlerMessage()方法中接收服務端發送來的message進行處理。
3.3 實現步驟
3.3.1 創建並初始化Server端的信使對象。
- private Handler mHandler = new Handler(){
- @Override
- public void handleMessage(Message msg) {
- super.handleMessage(msg);
- switch (msg.what) {
- case TEST:
- Log.e(TAG, "Get Message from MainActivity.");
- cMessenger = msg.replyTo;
- mTimer.schedule(new MyTimerTask(), 1000,TIME * 1000);
- break;
- default:
- break;
- }
- }
- };
- //It's the messenger of server
- private Messenger mMessenger = new Messenger(mHandler);
3.3.2 在Client端使用bindService()方法綁定Server端。
- private void doBindService(){
- Log.i(TAG, "doBindService()...");
- mIsBind = bindService(intent, serConn, BIND_AUTO_CREATE);//if bind success return true
- Log.e(TAG, "Is bind: "+mIsBind);
- }
3.3.3 在Server端的onBind()方法中返回一個binder對象。
- @Override
- public IBinder onBind(Intent intent) {
- Log.i(TAG, "MessengerService.onBind()...");
- return mMessenger.getBinder();
- }
3.3.4 Client端使用ServiceConnected()方法來獲取Server端的信使對象。
- private ServiceConnection serConn = new ServiceConnection() {
- @Override
- public void onServiceDisconnected(ComponentName name) {
- Log.i(TAG, "onServiceDisconnected()...");
- rMessenger = null;
- }
- @Override
- public void onServiceConnected(ComponentName name, IBinder service) {
- Log.i(TAG, "onServiceConnected()...");
- rMessenger = new Messenger(service);//get the object of remote service
- mMessenger = new Messenger(mHandler);//initial the object of local service
- sendMessage();
- }
- };
3.3.5 Client端使用獲取到的rMessenger來發送消息給Server端,同時將Client端的信使封裝到消息中,一併發送給Server端。
- private void sendMessage() {
- Message msg = Message.obtain(null, MessengerService.TEST);//MessengerService.TEST=0
- msg.replyTo = mMessenger;
- try {
- rMessenger.send(msg);
- } catch (RemoteException e) {
- e.printStackTrace();
- }
- }
3.3.6 Server端獲取Client端發送的消息並得到Client端的信使對象。
- private Handler mHandler = new Handler(){
- @Override
- public void handleMessage(Message msg) {
- super.handleMessage(msg);
- switch (msg.what) {
- case TEST:
- Log.e(TAG, "Get Message from MainActivity.");
- cMessenger = msg.replyTo;//get the messenger of client
- mTimer.schedule(new MyTimerTask(), 1000,TIME * 1000);
- break;
- default:
- break;
- }
- }
- };
3.3.7 Server端向Client端發送數據。
- class MyTimerTask extends TimerTask {
- @Override
- public void run() {
- if (i == 100) {
- i = 0;
- }
- try {
- //send the message to the client
- Message message = Message.obtain(null, MessengerService.TEST,i, 0);
- cMessenger.send(message);
- } catch (RemoteException e) {
- e.printStackTrace();
- }
- i++;
- }
- }
3.3.8 Client端接收來自Server端的數據。
- private Handler mHandler = new Handler(){
- @Override
- public void handleMessage(Message msg) {
- super.handleMessage(msg);
- switch (msg.what) {
- case MessengerService.TEST:
- Log.e(TAG, "Get Message From MessengerService. i= "+msg.arg1);
- int curLoad = msg.arg1;
- mTextView.setText(curLoad+"%");
- mProgressBar.setProgress(curLoad);
- break;
- default:
- break;
- }
- }
- };
以下是AndroidManifest.xml文件:
- <?xml version="1.0" encoding="utf-8"?>
- <manifest xmlns:android="http://schemas.android.com/apk/res/android"
- package="com.seven.messengerservicedemo"
- android:versionCode="1"
- android:versionName="1.0">
- <uses-sdk android:minSdkVersion="10" />
- <application android:icon="@drawable/icon" android:label="@string/app_name">
- <activity android:name=".MainActivity"
- android:label="@string/app_name">
- <intent-filter>
- <action android:name="android.intent.action.MAIN" />
- <category android:name="android.intent.category.LAUNCHER" />
- </intent-filter>
- </activity>
- <service android:name="MessengerService">
- <intent-filter>
- <action ndroid:name="com.seven.messagerservice.MessengerService" />
- </intent-filter>
- </service>
- </application>
- </manifest>
3.4 小結
通過Messenger來實現Activity和Service的交互,稍微深入一點我們就可以知道,其實Messenger也是通過AIDL來實現的。對於前兩種實現方式,Messenger方式總體上來講也是比較容易理解的,這就和平時使用Handler和Thread通信一個道理。
4. 自定義接口交互
何謂自定義接口呢,其實就是我們自己通過接口的實現來達到Activity與Service交互的目的,我們通過在Activity和Service之間架設一座橋樑,從而達到數據交互的目的,而這種實現方式和AIDL非常類似(後文會說到)。實現效果如圖4.1:
圖4.1
4.1 實現原理
自定義一個接口,該接口中有一個獲取當前下載進度的空方法。Server端用一個類繼承自Binder並實現該接口,覆寫了其中獲取當前下載進度的方法。Client端通過ServiceConnection獲取到該類的對象,從而能夠使用該獲取當前下載進度的方法,最終實現實時交互。
4.2 實現步驟
4.2.1 新建一個Interface,並在其中創建一個用於獲取當前下載進度的的空方法getCurrentLoad()。
- package com.seven.servicetestdemo;
- public interface ICountService {
- public int getCurrentLoad();
- }
4.2.2 新建Server端DownService實現ICountService並在其中通過一個內部類ServiceBinder繼承自Binder並實現ICoutService接口。
- public class DownLoadService extends Service implements ICountService{
- private ServiceBinder serviceBinder = new ServiceBinder();
- public class ServiceBinder extends Binder implements ICountService{
- @Override
- public int getCurrentLoad() {
- Log.i(TAG, "ServiceBinder getCurrentLoad()... i=:"+i);
- return i;
- }
- }
- @Override
- public int getCurrentLoad() {
- return 0;
- }
- }
4.2.3 Client端使用bindService()綁定Server端。
- if (startSerBtn == v) {
- Log.i(TAG, "Start Button Clicked.");
- bindService(intent, serConn, BIND_AUTO_CREATE);
- timer.schedule(new MyTimerTask(), 1000, TIME * 1000);//這裏一定要延遲一下再開始獲取數據,不然會報空指針異常
- }
4.2.4 Server端返回binder對象。
- @Override
- public IBinder onBind(Intent intent) {
- Log.i(TAG, "DownLoadService.onBind()...");
- return serviceBinder;
- }
4.2.5 Client端通過ServiceConnection來獲取Server端的binder對象。
- private ServiceConnection serConn = new ServiceConnection() {
- @Override
- public void onServiceDisconnected(ComponentName name) {
- iCountService = null;
- }
- @Override
- public void onServiceConnected(ComponentName name, IBinder service) {
- Log.i(TAG, "onServiceConnected()...");
- iCountService = (ICountService)service;
- }
- };
4.2.6 在綁定完成之後,Server端會開啓下載,在實際情況中Server端會開啓獨立線程用於下載,這裏用i++來代替。
- @Override
- public void onCreate() {
- super.onCreate();
- Log.i(TAG, "DownLoadService.onCreate()...");
- timer = new Timer();
- timer.schedule(new MyTimerTask(), 0, TIME*1000);
- }
- class MyTimerTask extends TimerTask{
- @Override
- public void run() {
- if(100==i){
- i=0;
- }
- i++;
- }
- }
4.2.7 Server端已經開啓了下載,那麼Client端需要及時獲取下載進度並在主界面上更新。
- Handler mHandler = new Handler(){
- @Override
- public void handleMessage(Message msg) {
- super.handleMessage(msg);
- Log.i(TAG, "handleMessage...");
- int curLoad = iCountService.getCurrentLoad();
- mProgressBar.setProgress(curLoad);
- currentTv.setText(curLoad+"%");
- }
- };
- class MyTimerTask extends TimerTask{
- @Override
- public void run() {
- mHandler.sendMessage(mHandler.obtainMessage());
- }
- }
4.3 小結
通過上面的例子可以知道,這種方法簡單實用,擴展性強,但其也有一些缺點,比如需要延遲一些再開始獲取Server端的數據,從而無法完全實現從零開始同步更新。綜其所述,通過自定義接口實現Activity與Service交互的方法還是比較實用的。適用於同進程中通信,不能進行跨進程通信。
5. AIDL交互
什麼是AIDL?
AIDL是Android Interface Definition Language的首字母縮寫, 也就是Android接口定義語言。提及AIDL就不得不說下Android的服務,Android 支持兩種服務類型的服務即本地服務和遠程服務。
本地服務無法供在設備上運行的其他應用程序訪問,也就是說只能該應用程序內部調用,比如某些應用程序中的下載類服務,這些服務只能由內部調用。而對於遠程服務,除了可以由本應用程序調用,還可以允許其他應用程序訪問。遠程服務一般通過AIDL來實現,可以進行進程間通信,這種服務也就是遠程服務。
本地服務與遠程服務還是有一些重要的區別。具體來講,如果服務完全只供同一進程中的組件使用(運行後臺任務),客戶端一邊通過調用 Context.startService()來啓動該服務。這種類型的服務爲本地服務,它的一般用途是後臺執行長耗時操作。而遠程服務一般通過bindService()方法啓動,主要爲不同進程間通信。我們也將遠程服務稱爲AIDL支持服務,因爲客戶端使用 AIDL 與服務通信。Android中對於遠程服務有多種叫法:遠程服務、AIDL服務、外部服務和RPC服務。
5.1 AIDL實現流程圖
圖5.1
這屬於代理/存根結構,通過這張AIDL的流程圖,很容易發現Android實現IPC其實是在原來的C/S框架上加入了代理/存根結構。
比如,你到自動取款機上去取款。那麼你就是客戶(Client),取款機就是你的代理(Proxy);你不會在乎錢具體放在那裏,你只想將你的錢從取款機中取出來。你同銀行之間的操作完全是取款機代理實現。你的取款請求通過取款機傳到另一邊,即銀行的服務器(Server)。它也沒有必要知道你在哪兒取錢,它所關心的是你的身份和你取款多少。當它確認你的權限,就進行相應的操作,返回操作結果給取款機,取款機根據服務器返回結果,從保險櫃裏取出相應數量的錢給你。你取出卡後,操作完成。取款機不是直接同服務器連接的,他們之間還有一個“存根(Stub)”,取款機與存根通信,服務器與存根通信,從某種意義上說存根就是服務器的代理。實現效果如圖5.2:
圖5.2
5.3 實現原理
AIDL屬於Android的IPC機制,常用於跨進程通信,主要實現原理基於底層Binder機制。
5.4 實現步驟
5.4.1 建立工程。按照圖5.3和圖5.4建立AIDLServer端以及AIDLClient端。在AIDLServer端中只有一個服務程序,沒有主界面,其主要功能就是負責下載。AIDLClient端從AIDLServer端獲取當前下載進度(注:AIDLServer端和AIDLClient端是不同的兩個APK,在模擬本例的時候,需要先在模擬器上安裝AIDLServer編譯出來的APK,安裝方法可以直接在模擬器上運行一次,可以通過adb install your.apk 來安裝)。
圖5.3
AIDLServer端中新建了一個ICountService.aidl的文件,該文件內容如下:
- package com.seven.aidlserver;
- interface ICountService{
- int getCount();
- }
aidl文件的書寫規範如下:
(1). Android支持String和CharSequence(以及Java的基本數據類型);
(2). 如果需要在aidl中使用其它aidl接口類型,需要import,即使是在相同包結構下;
(3). Android允許傳遞實現Parcelable接口的類,需要import;
(4). Android支持集合接口類型List和Map,但是有一些限制,元素必須是基本型或者前面三種情況,不需要import集合接口類,但是需要對元素涉及到的類型import;
(5). 非基本數據類型,也不是String和CharSequence類型的,需要有方向指示,包括in、out和inout,in表示由客戶端設置,out表示由服務端設置,inout是兩者均可設置。
圖5.4
AIDLClient端需要將AIDLServer端的ICountService.aidl文件復製過去,這裡爲了方便,新建了一個和Server端同名的包,並將ICountService.aidl放與其中。
5.4.2 我們在Server端建立好ICoutService.aidl文件之後,Eclipse會在/gen/com.seven.aidlserver/目錄下自動生成ICountService.java文件。該文件由Eclipse自動生成,請勿隨便修改,後文我們需引用到的內容如下:
- public static com.seven.aidlserver.ICountService asInterface(android.os.IBinder obj) {
- if ((obj == null)) {
- return null;
- }
- android.os.IInterface iin = (android.os.IInterface) obj.queryLocalInterface(DESCRIPTOR);
- if (((iin != null) && (iin instanceof com.seven.aidlserver.ICountService))) {
- return ((com.seven.aidlserver.ICountService) iin);
- }
- return new com.seven.aidlserver.ICountService.Stub.Proxy(obj);
- }
5.4.3 在Server端新建一個內部類繼承自ICountService.Stub並覆寫其中的getCount()方法,以及實例化該類的一個對象serviceBinder。
- private AIDLServerBinder serviceBinder = new AIDLServerBinder();
- class AIDLServerBinder extends ICountService.Stub{
- @Override
- public int getCount() throws RemoteException {
- return i;
- }
- }
5.4.4 在Server端的onBind()方法中,返回前面的serviceBinder對象。
- @Override
- public IBinder onBind(Intent intent) {
- Log.i(TAG, "AIDLServer.onBind()...");
- return serviceBinder;
- }
5.4.5 在Server端的onCreate()方法中,開啓timer,模擬下載。在Client端通過bindService()綁定Server端的時候,會首先執行Server端的onCreate()方法。
- @Override
- public void onCreate() {
- super.onCreate();
- Log.i(TAG, "AIDLServer.onCreate()...");
- mTimer = new Timer();
- mTimer.schedule(new MyTimerTask(), 0,TIME * 1000);
- }
- class MyTimerTask extends TimerTask{
- @Override
- public void run() {
- if(i==100){
- i=0;
- }
- i++;
- }
- }
5.4.6 Client端通過bindService()綁定Server端。
- if(startBtn==v){
- Log.i(TAG, "start button click.");
- mIsBind = bindService(intent, serConn, BIND_AUTO_CREATE);
- mTimer.schedule(new MyTimerTask(), 1000 ,TIME * 1000);
- }
5.4.7 Client端通過ServiceConnection來獲取Server端的binder對象。
- private ServiceConnection serConn = new ServiceConnection() {
- @Override
- public void onServiceDisconnected(ComponentName name) {
- iCountService = null;
- }
- @Override
- public void onServiceConnected(ComponentName name, IBinder service) {
- Log.i(TAG, "AIDLClient.onServiceConnected()...");
- iCountService = ICountService.Stub.asInterface(service);
- }
- };
5.4.8 獲取當前下載進度並更新到界面上。
- Handler mHandler = new Handler(){
- @Override
- public void handleMessage(Message msg) {
- super.handleMessage(msg);
- try {
- int count = iCountService.getCount();
- mTextView.setText(count+"%");
- mProgressBar.setProgress(count);
- } catch (RemoteException e) {
- e.printStackTrace();
- }
- }
- };
5.5 小結
AIDL在Android中是進程間通信常用的方式,可能使用較為複雜,但效率高,擴展性好。同時很多系統服務就是以這種方式完成與應用程序通信的。
本文通過五個例子,分別介紹了五種與Service交互的方法,這些方法有的簡單,有的可能要複雜一些。在這裏只是做爲對Servie的一些總結。後文附上源碼下載鏈接,不需要積分的哦。:D