综述

　　IPC(interprocess communication)是指进程间通信，也就是在两个进程间进行数据交互。不同的操作系统都有他们自己的一套IPC机制。例如在Linux操作系统中可以通过管道、信号量、消息队列、内存共享、套接字等进行进程间通信。那么在Android系统中我们可以通过Binder来进行进程间的通信。当然除了Binder我们还可以使用Socket来进行进程间的通信。 
　　既然需要进程通信，那么就必须有多个进程。当然，在两个应用交互中必然出现多进程的情况。若是在一个应用中呢？我们可以通过给四大组件在AndroidMenifest中为他们指定android:process属性来实现不同的组件在不同进程中运行。下面就来介绍一下Android中进程间通信的实现方式。

AIDL简介

　　AIDL是 Android Interface Definition Language的缩写。AIDL 是一种IDL 语言，用于生成可以在Android设备上两个进程之间进行 IPC的代码。如果在一个进程中（例如Activity）要调用另一个进程中（例如Service）对象的操作，就可以使用AIDL生成可序列化的参数。 
　　AIDL IPC机制是面向接口的，像COM或Corba一样，但是更加轻量级。它是使用代理类在客户端和实现端传递数据。

AIDL用法

　　首先我们创建一个AIDL文件，在AndroidStudio中当我们创建一个AIDL文件时会自动为我们创件一个AILD文件夹，用于存放AIDL文件。创建完之后重新rebuild会自动生成aidl实现类。 
　　 
　　在下面的例子当中，我们将Service单独作为一个应用在系统中运行，在另一个用于访问Service的client也单独作为一个应用运行在系统中。这样保证了两个程序分别运行在两个进程中。并且使用了butterknife进行控件绑定。

AIDL简单用法

演示

　　在Service中我们对客户端传来的两个整数做了一次加法运算并返回到客户端中。 
 
　　

AIDL代码

  1. // ICalculate.aidl
  2. package com.ljd.aidl;
  4. // Declare any non-default types here with import statements
  6. interface ICalculate {
  7.     /**
  8.      * Demonstrates some basic types that you can use as parameters
  9.      * and return values in AIDL.
  10.      */
  11.     int add(int first, int second);
  12. }

服务端代码

  1. package com.ljd.aidl.service;
  3. import android.app.Service;
  4. import android.content.Intent;
  5. import android.os.Binder;
  6. import android.os.IBinder;
  7. import android.os.RemoteException;
  9. import com.ljd.aidl.ICalculate;
  11. public class CalculateService extends Service {
  12.     public CalculateService() {
  13.     }
  15.     private Binder mBinder = new ICalculate.Stub(){
  17.         @Override
  18.         public int add(int first, int second) throws RemoteException {
  19.             return first + second;
  20.         }
  21.     };
  23.     @Override
  24.     public IBinder onBind(Intent intent) {
  25.         return mBinder;
  26.     }
  27. }

客户端代码

  1. package com.ljd.aidl.activity;
  3. import android.content.ComponentName;
  4. import android.content.Context;
  5. import android.content.Intent;
  6. import android.content.ServiceConnection;
  7. import android.os.Bundle;
  8. import android.os.IBinder;
  9. import android.os.RemoteException;
  10. import android.support.v7.app.AppCompatActivity;
  11. import android.util.Log;
  12. import android.view.View;
  13. import android.widget.Toast;
  15. import com.ljd.aidl.ICalculate;
  16. import com.ljd.aidl.client.R;
  18. import butterknife.ButterKnife;
  19. import butterknife.OnClick;
  21. public class Demo1Activity extends AppCompatActivity {
  23.     private final String TAG = "DEMO1";
  24.     //是否已经绑定service
  25.     private boolean mIsBindService;
  26.     private ICalculate mCalculate;
  27.     private ServiceConnection mConnection = new ServiceConnection() {
  28.         @Override
  29.         public void onServiceConnected(ComponentName name, IBinder service) {
  30.             Log.d(TAG,"bind success");
  31.             Toast.makeText(Demo1Activity.this,"bind service success",Toast.LENGTH_SHORT).show();
  32.             mCalculate = ICalculate.Stub.asInterface(service);
  33.         }
  35.         @Override
  36.         public void onServiceDisconnected(ComponentName name) {
  37.         //重新绑定Service防止系统将服务进程杀死而产生的调用错误。
  38.             bindService();
  39.         }
  40.     };
  42.     @Override
  43.     protected void onCreate(Bundle savedInstanceState) {
  44.         super.onCreate(savedInstanceState);
  45.         setContentView(R.layout.activity_demo1);
  46.         ButterKnife.bind(this);
  47.         mIsBindService = false;
  48.     }
  50.     @Override
  51.     protected void onDestroy() {
  52.         unbindService();
  53.         ButterKnife.unbind(this);
  54.         super.onDestroy();
  55.     }
  57.     @OnClick({ R.id.bind_demo1_btn,R.id.unbind_demo1_btn,R.id.calculate_btn})
  58.     public void onClickButton(View v) {
  59.         switch (v.getId()){
  60.             case R.id.bind_demo1_btn:
  61.                 bindService();
  62.                 break;
  63.             case R.id.unbind_demo1_btn:
  64.                 Toast.makeText(this,"unbind service success",Toast.LENGTH_SHORT).show();
  65.                 unbindService();
  66.                 break;
  67.             case R.id.calculate_btn:
  68.                 if (mIsBindService && mCalculate != null ){
  69.                     try {
  70.                         int result = mCalculate.add(2,4);
  71.                         Log.d(TAG,String.valueOf(result));
  72.                         Toast.makeText(this,String.valueOf(result),Toast.LENGTH_SHORT).show();
  73.                     } catch (RemoteException e) {
  74.                         e.printStackTrace();
  75.                     }
  76.                 } else {
  77.                     Toast.makeText(this,"not bind service",Toast.LENGTH_SHORT).show();
  78.                 }
  79.                 break;
  80.         }
  81.     }
  83.     private void bindService(){
  84.         Intent intent = new Intent();
  85.         intent.setAction("com.ljd.aidl.action.CALCULATE_SERVICE");
  86.         bindService(intent,mConnection, Context.BIND_AUTO_CREATE);
  87.         mIsBindService = true;
  88.     }
  90.     private void unbindService(){
  91.         if(mIsBindService){
  92.             mIsBindService = false;
  93.             unbindService(mConnection);
  94.         }
  95.     }
  96. }

AIDL高级用法

　　对于上面的例子，在AIDL接口中只是使用了一些Java的基本类型，对于AIDL文件并不是所有的类型都是可用的，那么在AIDL中究竟有哪些类型可以使用呢？

AIDL语法规则

默认情况下AIDL支持以下数据类型：

  • 所有Java的基本数据类型（例如： int, long,double, char, boolean等）
  • String和CharSequence
  • List：AIDL实际接收到的是ArrayList，并且List里面所有元素都必须被AIDL支持
  • Map: AIDL实际接收到的是HashMap，并且Map里面所有元素都必须被AIDL支持

如果不是上面所述类型，我们必须要显示import进来，即使他们在同一个包中。当我们使用自定义的对象时必须实现Parcelable接口，Parcelable为对象序列化接口，效率比实现Serializable接口高。并且新建一个与该类同名的AIDL文件，声明他为Parcelable类型。

我们定义AIDL接口还需要注意以下几点：

  • 方法可以有多个或没有参数，可以有返回值也可以为void
  • 在参数中，除了基本类型以外，我们必须为参数标上方向in, out, 或者 inout
  • 在AIDL文件中只支持方法，不支持静态常量

演示

　　在计算机商店中需要采购笔记本进行销售，在服务端中我们添加两台笔记本，在客户端中我们为商店加购一台dell笔记本。 
 
　　

实体类代码

　　我们首先构建一个计算机实体类，包含笔记本的id，品牌，型号，并且实现Parcelable接口，在AndroidStudio中会为我们自动构造代码。 
　　

  1. package com.ljd.aidl.entity;
  3. import android.os.Parcel;
  4. import android.os.Parcelable;
  6. public class ComputerEntity implements Parcelable{
  8.     public int computerId;     //id
  9.     public String brand;       //品牌
  10.     public String model;       //型号
  12.     public ComputerEntity(int computerId, String brand, String model) {
  13.         this.brand = brand;
  14.         this.computerId = computerId;
  15.         this.model = model;
  16.     }
  18.     protected ComputerEntity(Parcel in) {
  19.         computerId = in.readInt();
  20.         brand = in.readString();
  21.         model = in.readString();
  22.     }
  24.     public static final Creator<ComputerEntity> CREATOR = new Creator<ComputerEntity>() {
  25.         @Override
  26.         public ComputerEntity createFromParcel(Parcel in) {
  27.             return new ComputerEntity(in);
  28.         }
  30.         @Override
  31.         public ComputerEntity[] newArray(int size) {
  32.             return new ComputerEntity[size];
  33.         }
  34.     };
  36.     @Override
  37.     public int describeContents() {
  38.         return 0;
  39.     }
  41.     @Override
  42.     public void writeToParcel(Parcel dest, int flags) {
  43.         dest.writeInt(computerId);
  44.         dest.writeString(brand);
  45.         dest.writeString(model);
  46.     }
  47. }

AIDL代码

　　在AIDL中对实体类进行声明，包名和文件名必须与实体类一致。在AndroidStudio中新建一个与实体类同名的AIDL文件会报错，需要先用一个其它名字，然后修改与实体类名一致即可。

  1. package com.ljd.aidl.entity;
  3. //包名必须和对用实体类的包名一致
  4. // Declare any non-default types here with import statements
  5. parcelable ComputerEntity;

　　添加两个接口分别为添加一台笔记本和获取全部笔记本，在该文件中使用到了ComputerEntity类，显示的import进来。

  1. package com.ljd.aidl;
  3. import com.ljd.aidl.entity.ComputerEntity;
  4. // Declare any non-default types here with import statements
  6. interface IComputerManager {
  7.     /**
  8.      * Demonstrates some basic types that you can use as parameters
  9.      * and return values in AIDL.
  10.      */
  11.      void addComputer(in ComputerEntity computer);
  12.      List<ComputerEntity> getComputerList();
  13. }

服务端代码

  1. package com.ljd.aidl.service;
  3. import android.app.Service;
  4. import android.content.Intent;
  5. import android.os.IBinder;
  6. import android.os.RemoteException;
  8. import com.ljd.aidl.IComputerManager;
  9. import com.ljd.aidl.entity.ComputerEntity;
  11. import java.util.List;
  12. import java.util.concurrent.CopyOnWriteArrayList;
  14. public class ComputerService extends Service {
  15.     private CopyOnWriteArrayList<ComputerEntity> mComputerList = new CopyOnWriteArrayList<>();
  17.     public ComputerService() {
  18.     }
  20.     private final IComputerManager.Stub mBinder = new IComputerManager.Stub() {
  21.         @Override
  22.         public void addComputer(ComputerEntity computer) throws RemoteException {
  23.             mComputerList.add(computer);
  24.         }
  26.         @Override
  27.         public List<ComputerEntity> getComputerList() throws RemoteException {
  28.             return mComputerList;
  29.         }
  30.     };
  32.     @Override
  33.     public void onCreate() {
  34.         super.onCreate();
  35.         mComputerList.add(new ComputerEntity(0,"apple","macbookpro"));
  36.         mComputerList.add(new ComputerEntity(1,"microsoft","surfacebook"));
  37.         mComputerList.add(new ComputerEntity(2,"dell","XPS13"));
  38.     }
  40.     @Override
  41.     public IBinder onBind(Intent intent) {
  42.         return mBinder;
  43.     }
  44. }

　　注意：在该类中使用了CopyOnWriteArrayList，CopyOnWriteArrayList能够自动进行线程同步。可是在AIDL中接收和返回的只能是ArrayList，其实AIDL支持的是抽象的List，在Binder中会按照List访问数据并最终形成一个ArrayList，所以在AIDL中返回的还是一个ArrayList。

客户端代码

  1. package com.ljd.aidl.activity;
  3. import android.content.ComponentName;
  4. import android.content.Context;
  5. import android.content.Intent;
  6. import android.content.ServiceConnection;
  7. import android.os.IBinder;
  8. import android.os.RemoteException;
  9. import android.support.v7.app.AppCompatActivity;
  10. import android.os.Bundle;
  11. import android.util.Log;
  12. import android.view.View;
  13. import android.widget.LinearLayout;
  14. import android.widget.TextView;
  15. import android.widget.Toast;
  17. import com.ljd.aidl.IComputerManager;
  18. import com.ljd.aidl.client.R;
  19. import com.ljd.aidl.entity.ComputerEntity;
  21. import java.util.List;
  23. import butterknife.Bind;
  24. import butterknife.ButterKnife;
  25. import butterknife.OnClick;
  27. public class Demo2Activity extends AppCompatActivity{
  29.     @Bind(R.id.show_linear)
  30.     LinearLayout mShowLinear;
  32.     private boolean mIsBindService;
  33.     private IComputerManager mRemoteComputerManager;
  34.     private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
  35.         @Override
  36.         public void binderDied() {
  37.             if(mRemoteComputerManager != null){
  38.                 mRemoteComputerManager.asBinder().unlinkToDeath(mDeathRecipient,0);
  39.                 mRemoteComputerManager = null;
  40.                 bindService();
  41.             }
  42.         }
  43.     };
  44.     private ServiceConnection mConnection = new ServiceConnection() {
  45.         @Override
  46.         public void onServiceConnected(ComponentName name, IBinder service) {
  47.             mIsBindService = true;
  48.             Toast.makeText(Demo2Activity.this,"bind service success",Toast.LENGTH_SHORT).show();
  49.             mRemoteComputerManager = IComputerManager.Stub.asInterface(service);
  50.             try {
  51.                 mRemoteComputerManager.asBinder().linkToDeath(mDeathRecipient,0);
  52.             } catch (RemoteException e) {
  53.                 e.printStackTrace();
  54.             }
  55.         }
  57.         @Override
  58.         public void onServiceDisconnected(ComponentName name) {
  59.             mRemoteComputerManager = null;
  60.         }
  61.     };
  62.     @Override
  63.     protected void onCreate(Bundle savedInstanceState) {
  64.         super.onCreate(savedInstanceState);
  65.         setContentView(R.layout.activity_demo2);
  66.         ButterKnife.bind(this);
  67.         mIsBindService = false;
  68.     }
  70.     @Override
  71.     protected void onDestroy() {
  72.         unbindService();
  73.         ButterKnife.unbind(this);
  74.         super.onDestroy();
  75.     }
  77.     @OnClick({R.id.bind_demo2_btn,R.id.unbind_demo2_btn,R.id.test_demo2_btn,R.id.clear_demo2_btn})
  78.     public void onClickButton(View v) {
  79.         switch (v.getId()){
  80.             case R.id.bind_demo2_btn:
  81.                 bindService();
  82.                 break;
  83.             case R.id.unbind_demo2_btn:
  84.                 Toast.makeText(this,"unbind service success",Toast.LENGTH_SHORT).show();
  85.                 unbindService();
  86.                 break;
  87.             case R.id.test_demo2_btn:
  88.                 if (!mIsBindService || mRemoteComputerManager == null){
  89.                     Toast.makeText(this,"not bind service",Toast.LENGTH_SHORT).show();
  90.                     return;
  91.                 }
  92.                 try {
  93.                     List<ComputerEntity> computerList = mRemoteComputerManager.getComputerList();
  94.                     for (int i =0;i<computerList.size();i++){
  95.                         String str = "computerId:" + String.valueOf(computerList.get(i).computerId) +
  96.                                 " brand:" + computerList.get(i).brand +
  97.                                 " model:" + computerList.get(i).model ;
  98.                         TextView textView = new TextView(this);
  99.                         textView.setText(str);
  100.                         mShowLinear.addView(textView);
  101.                     }
  102.                 } catch (RemoteException e) {
  103.                     e.printStackTrace();
  104.                 }
  105.                 break;
  106.             case R.id.clear_demo2_btn:
  107.                 mShowLinear.removeAllViews();
  108.                 break;
  109.         }
  110.     }
  112.     private void bindService(){
  113.         Intent intent = new Intent();
  114.         intent.setAction("com.ljd.aidl.action.COMPUTER_SERVICE");
  115.         mIsBindService = bindService(intent,mConnection, Context.BIND_AUTO_CREATE);
  116.     }
  118.     private void unbindService(){
  119.         if(!mIsBindService){
  120.             return;
  121.         }
  122.         mIsBindService = false;
  123.         unbindService(mConnection);
  124.     }
  125. }

　　由于Binder是有可能会意外死亡的，也就是Service所在进程被系统杀死，这时候我们调用Service的方法就会失败。在第一个例子中我们通过onServiceDisconnected方法中重新绑定服务。在这个例子中我们采用了另外一种方法，由于在Binder中提供了两个配对的方法linkToDeath和unlinkToDeath，通过linkToDeath可以给Binder设置一个死亡代理，Binder死亡时回调binderDied方法，在binderDied方法中我们重新绑定服务即可。

AIDL用法拓展

　　当我们需要一种笔记本的时候，由于商店缺货，这时候我们会给卖家说一声，我所需要的这款笔记本到货后通知我。也就成了所谓的观察者模式。 
　　在Android系统中为我们提供了一个RemoteCallbackList,RemoteCallbackList是系统专门用来删除跨进程的listener接口，并且在RemoteCallbackList中自动实现了线程同步功能，下面看一下它的用法。

演示

　　客户端注册服务以后，服务端每隔三秒会添加一台笔记本，并通知给客户端显示。 

AIDL代码

　　到货后的AIDL监听接口 
　　

  1. package com.ljd.aidl;
  3. import com.ljd.aidl.entity.ComputerEntity;
  4. // Declare any non-default types here with import statements
  6. interface IOnComputerArrivedListener {
  7.     /**
  8.      * Demonstrates some basic types that you can use as parameters
  9.      * and return values in AIDL.
  10.      */
  11.     void onComputerArrived(in ComputerEntity computer);
  12. }

　　在IComputerManager接口中添加两个方法。显示importIOnComputerArrivedListener ,即使在同一个包下面。 
　　

  1. // IComputerManagerObserver.aidl
  2. package com.ljd.aidl;
  4. import com.ljd.aidl.entity.ComputerEntity;
  5. import com.ljd.aidl.IOnComputerArrivedListener;
  6. // Declare any non-default types here with import statements
  8. interface IComputerManagerObserver {
  9.     /**
  10.      * Demonstrates some basic types that you can use as parameters
  11.      * and return values in AIDL.
  12.      */
  13.      void addComputer(in ComputerEntity computer);
  14.      List<ComputerEntity> getComputerList();
  15.      void registerUser(IOnComputerArrivedListener listener);
  16.      void unRegisterUser(IOnComputerArrivedListener listener);
  17. }

服务端代码

  1. import android.app.Service;
  2. import android.content.Intent;
  3. import android.os.Binder;
  4. import android.os.IBinder;
  5. import android.os.RemoteCallbackList;
  6. import android.os.RemoteException;
  8. import com.ljd.aidl.IComputerManagerObserver;
  9. import com.ljd.aidl.IOnComputerArrivedListener;
  10. import com.ljd.aidl.entity.ComputerEntity;
  12. import java.util.List;
  13. import java.util.concurrent.CopyOnWriteArrayList;
  14. import java.util.concurrent.atomic.AtomicBoolean;
  16. public class ComputerObserverService extends Service{
  17.     public ComputerObserverService() {
  18.     }
  20.     private CopyOnWriteArrayList<ComputerEntity> mComputerList = new CopyOnWriteArrayList<>();
  21.     private RemoteCallbackList<IOnComputerArrivedListener> mComputerArrivedListenerList = new RemoteCallbackList<>();
  22.     private AtomicBoolean mIsServiceDestroy = new AtomicBoolean(false);
  24.     private Binder mBinder = new IComputerManagerObserver.Stub(){
  26.         @Override
  27.         public void addComputer(ComputerEntity computer) throws RemoteException {
  28.             mComputerList.add(computer);
  29.         }
  31.         @Override
  32.         public List<ComputerEntity> getComputerList() throws RemoteException {
  33.             return mComputerList;
  34.         }
  36.         @Override
  37.         public void registerUser(IOnComputerArrivedListener listener) throws RemoteException {
  38.             mComputerArrivedListenerList.register(listener);
  39.         }
  41.         @Override
  42.         public void unRegisterUser(IOnComputerArrivedListener listener) throws RemoteException {
  43.             mComputerArrivedListenerList.unregister(listener);
  44.         }
  45.     };
  47.     @Override
  48.     public void onCreate() {
  49.         super.onCreate();
  50.         mComputerList.add(new ComputerEntity(0,"apple","macbookpro"));
  51.         mComputerList.add(new ComputerEntity(1,"microsoft","surfacebook"));
  52.         mComputerList.add(new ComputerEntity(2,"dell","XPS13"));
  53.         new Thread(new Runnable() {
  54.             @Override
  55.             public void run() {
  56.                 while (!mIsServiceDestroy.get()){
  57.                     try {
  58.                         Thread.currentThread().sleep(3000);
  59.                         ComputerEntity computer = new ComputerEntity(mComputerList.size(),"******","******");
  60.                         mComputerList.add(computer);
  61.                         final int COUNT = mComputerArrivedListenerList.beginBroadcast();
  62.                         //通知所有注册过的用户
  63.                         for (int i=0;i<COUNT;i++){
  64.                             IOnComputerArrivedListener listener = mComputerArrivedListenerList.getBroadcastItem(i);
  65.                             if (listener != null){
  66.                                 listener.onComputerArrived(computer);
  67.                             }
  68.                         }
  69.                         mComputerArrivedListenerList.finishBroadcast();
  70.                     } catch (InterruptedException e) {
  71.                         e.printStackTrace();
  72.                     } catch (RemoteException e) {
  73.                         e.printStackTrace();
  74.                     }
  75.                 }
  76.             }
  77.         }).start();
  78.     }
  80.     @Override
  81.     public IBinder onBind(Intent intent) {
  82.         return mBinder;
  83.     }
  85.     @Override
  86.     public void onDestroy() {
  87.         super.onDestroy();
  88.         mIsServiceDestroy.set(true);
  89.     }
  90. }

　　注意：RemoteCallbackList并不是一个List，所以我们不能像操作List一样操作RemoteCallbackList。并且遍历RemoteCallbackList时，beginBroadcast和finishBroadcast是配对使用的。

客户端代码


  2. import android.content.ComponentName;
  3. import android.content.Context;
  4. import android.content.Intent;
  5. import android.content.ServiceConnection;
  6. import android.os.Handler;
  7. import android.os.IBinder;
  8. import android.os.Message;
  9. import android.os.RemoteException;
  10. import android.support.v7.app.AppCompatActivity;
  11. import android.os.Bundle;
  12. import android.view.View;
  13. import android.widget.LinearLayout;
  14. import android.widget.TextView;
  15. import android.widget.Toast;
  17. import com.ljd.aidl.IComputerManagerObserver;
  18. import com.ljd.aidl.IOnComputerArrivedListener;
  19. import com.ljd.aidl.client.R;
  20. import com.ljd.aidl.entity.ComputerEntity;
  22. import java.util.List;
  24. import butterknife.Bind;
  25. import butterknife.ButterKnife;
  26. import butterknife.OnClick;
  28. public class Demo3Activity extends AppCompatActivity {
  30.     @Bind(R.id.show_demo3_linear)
  31.     LinearLayout mShowLinear;
  33.     private boolean mIsBindService;
  34.     private static final int MESSAGE_COMPUTER_ARRIVED = 1;
  36.     private IComputerManagerObserver mRemoteComputerManager;
  37.     private Handler mHandler = new Handler() {
  38.         @Override
  39.         public void handleMessage(Message msg) {
  40.             switch (msg.what){
  41.                 case MESSAGE_COMPUTER_ARRIVED:
  42.                     ComputerEntity computer = (ComputerEntity)msg.obj;
  43.                     String str = "computerId:" + String.valueOf(computer.computerId) +
  44.                             " brand:" + computer.brand +
  45.                             " model:" + computer.model ;
  46.                     TextView textView = new TextView(Demo3Activity.this);
  47.                     textView.setText(str);
  48.                     mShowLinear.addView(textView);
  49.                     break;
  50.                 default:
  51.                     super.handleMessage(msg);
  52.                     break;
  53.             }
  55.         }
  56.     };
  58.     private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
  59.         @Override
  60.         public void binderDied() {
  61.             if(mRemoteComputerManager != null){
  62.                 mRemoteComputerManager.asBinder().unlinkToDeath(mDeathRecipient,0);
  63.                 mRemoteComputerManager = null;
  64.                 bindService();
  65.             }
  66.         }
  67.     };
  69.     private ServiceConnection mConnection = new ServiceConnection() {
  70.         @Override
  71.         public void onServiceConnected(ComponentName name, IBinder service) {
  72.             mIsBindService = true;
  73.             Toast.makeText(Demo3Activity.this,"bind service success",Toast.LENGTH_SHORT).show();
  74.             mRemoteComputerManager = IComputerManagerObserver.Stub.asInterface(service);
  75.             try {
  76.                 mRemoteComputerManager.asBinder().linkToDeath(mDeathRecipient,0);
  77.             } catch (RemoteException e) {
  78.                 e.printStackTrace();
  79.             }
  80.         }
  82.         @Override
  83.         public void onServiceDisconnected(ComponentName name) {
  84.             mRemoteComputerManager = null;
  85.         }
  86.     };
  88.     private IOnComputerArrivedListener mOnComputerArrivedListener = new IOnComputerArrivedListener.Stub(){
  90.         @Override
  91.         public void onComputerArrived(ComputerEntity computer) throws RemoteException {
  92.             mHandler.obtainMessage(MESSAGE_COMPUTER_ARRIVED,computer).sendToTarget();
  93.         }
  94.     };
  96.     @Override
  97.     protected void onCreate(Bundle savedInstanceState) {
  98.         super.onCreate(savedInstanceState);
  99.         setContentView(R.layout.activity_demo3);
  100.         ButterKnife.bind(this);
  101.         mIsBindService = false;
  102.     }
  104.     @Override
  105.     protected void onDestroy() {
  106.         unbindService();
  107.         ButterKnife.unbind(this);
  108.         super.onDestroy();
  109.     }
  111.     @OnClick({R.id.bind_demo3_btn,R.id.unbind_demo3_btn,R.id.test_demo3_btn,R.id.clear_demo3_btn})
  112.     public void onClickButton(View v){
  113.         switch (v.getId()){
  114.             case R.id.bind_demo3_btn:
  115.                 bindService();
  116.                 break;
  117.             case R.id.unbind_demo3_btn:
  118.                 Toast.makeText(this,"unbind service success",Toast.LENGTH_SHORT).show();
  119.                 unbindService();
  120.                 break;
  121.             case R.id.test_demo3_btn:
  122.                 if (!mIsBindService || mRemoteComputerManager == null){
  123.                     Toast.makeText(this,"not bind service",Toast.LENGTH_SHORT).show();
  124.                     return;
  125.                 }
  127.                 try {
  128.                     ComputerEntity computer = new ComputerEntity(3,"hp","envy13");
  129.                     mRemoteComputerManager.addComputer(computer);
  130.                     List<ComputerEntity> computerList = mRemoteComputerManager.getComputerList();
  131.                     for (int i =0;i<computerList.size();i++){
  132.                         String str = "computerId:" + String.valueOf(computerList.get(i).computerId) +
  133.                                 " brand:" + computerList.get(i).brand +
  134.                                 " model:" + computerList.get(i).model ;
  135.                         TextView textView = new TextView(this);
  136.                         textView.setText(str);
  137.                         mShowLinear.addView(textView);
  138.                     }
  139.                     mRemoteComputerManager.registerUser(mOnComputerArrivedListener);
  140.                 } catch (RemoteException e) {
  141.                     e.printStackTrace();
  142.                 }
  143.                 break;
  144.             case R.id.clear_demo3_btn:
  145.                 mShowLinear.removeAllViews();
  146.                 break;
  147.         }
  148.     }
  150.     private void bindService(){
  151.         Intent intent = new Intent();
  152.         intent.setAction("com.ljd.aidl.action.COMPUTER_OBSERVER_SERVICE");
  153.         mIsBindService = bindService(intent,mConnection, Context.BIND_AUTO_CREATE);
  154.     }
  156.     private void unbindService(){
  157.         if(!mIsBindService){
  158.             return;
  159.         }
  160.         if (mRemoteComputerManager != null && mRemoteComputerManager.asBinder().isBinderAlive()){
  161.             try {
  162.                 mRemoteComputerManager.unRegisterUser(mOnComputerArrivedListener);
  163.             } catch (RemoteException e) {
  164.                 e.printStackTrace();
  165.             }
  166.         }
  167.         unbindService(mConnection);
  168.         mIsBindService = false;
  169.     }
  170. }

源码下载

 

Android的IPC机制（一）——AIDL的使用的更多相关文章

  1. [置顶] 深入理解android之IPC机制与Binder框架

    [android之IPC机制与Binder框架] [Binder框架.Parcel.Proxy-Stub以及AIDL] Abstract [每个平台都会有自己一套跨进程的IPC机制,让不同进程里的两个 ...

  2. Android IPC机制之AIDL

    什么是AIDL AIDL:Android Interface Definition Language,即Android接口定义语言. Android系统中的进程之间不能共享内存,因此,需要提供一些机制 ...

  3. Android之IPC机制

    Android IPC简介 任何一个操作系统都需要有相应的IPC机制,Linux上可以通过命名通道.共享内存.信号量等来进行进程间通信.Android系统不仅可以使用了Binder机制来实现IPC,还 ...

  4. Android 进程通信机制之 AIDL

    什么是 AIDL AIDL 全称 Android Interface Definition Language,即 安卓接口描述语言.听起来很深奥,其实它的本质就是生成进程间通信接口的辅助工具.它的存在 ...

  5. android学习-IPC机制之ACtivity绑定Service通信

    bindService获得Service的binder对象对服务进行操作 Binder通信过程类似于TCP/IP服务连接过程binder四大架构Server(服务器),Client(客户端),Serv ...

  6. Android之IPC（aidl）

    IPC(Inter-Process Conmunication) 进程间通讯 在同一进程中,各个组件进行通信是十分方便的,普通的函数调用就可以解决:但是,对于处于不同进程中的组件来说,要进行通信,就需 ...

  7. Android开发艺术探索——第二章：IPC机制（上）

    Android开发艺术探索--第二章:IPC机制(上) 本章主要讲解Android的IPC机制,首先介绍Android中的多进程概念以及多进程开发模式中常见的注意事项,接着介绍Android中的序列化 ...

  8. Android IPC机制（三）在Android Studio中使用AIDL实现跨进程方法调用

    在上一篇文章Android IPC机制(二)用Messenger进行进程间通信中我们介绍了使用Messenger来进行进程间通信的方法.可是我们能发现Messenger是以串行的方式来处理client ...

  9. 《Android开发艺术探索》读书笔记 (2) 第2章 IPC机制

    2.1 Android IPC简介 (1)任何一个操作系统都需要有相应的IPC机制,Linux上可以通过命名通道.共享内存.信号量等来进行进程间通信.Android系统不仅可以使用了Binder机制来 ...

随机推荐

  1. 浅谈Spark Kryo serialization

    原创文章,转载请注明: 转载自http://www.cnblogs.com/tovin/p/3833985.html 最近在使用spark开发过程中发现当数据量很大时,如果cache数据将消耗很多的内 ...

  2. 安卓app缓存设置

    无论大型或小型应用,灵活的缓存可以说不仅大大减轻了服务器的压力,而且因为更快速的用户体验而方便了用户. Android的apk可以说是作为小型应用,其中99%的应用并不是需要实时更新的,而且诟病于蜗牛 ...

  3. 性能测试问题_Mysql数据库服务器的CPU占用很高

    MySQl服务器CPU占用很高 1.  问题描述 一个简单的接口,根据传入的号段查询号码归属地,运行性能测试脚本,20个并发mysql的CPU就很高,监控发现只有一个select语句,且表建立了索引 ...

  4. nodejs 操作mysql

    这篇文章主要介绍了nodejs中操作mysql数据库示例,本文演示了如何在NodeJS中创建创建mysql连接.mysql数据库.插入数据.查询数据等功能,需要的朋友可以参考下  引言: 继前面的No ...

  5. 2、Spring的LocalSessionFactoryBean创建过程源码分析

    spring的LocalSessionFactoryBean生成过程与hibernate的SessionFactory生成过程是高度吻合的. 为了后面源码分析,首先讲解一个接口,一个类的功能:①.接口 ...

  6. Matlab多个Figure图合成一个Fig

    案例:之前跑过的程序 已经生成了多个matlab图,现在需要进行合并到一个图中. 解决方案,利用图像句柄把figure图像中的参数读入到内存中,然后重新subplot绘制. 程序如下: clc;cle ...

  7. PHP 对象及其三大特性

    //面向过程 //类和对象 //对象:任何东西都可以成为对象,类实例化出来的东西 //类:对所有同类的对象抽象出来的东西 //info:code,name,sex,nation,birthday // ...

  8. 加密工具类 - CryptoUtils.java

    加密工具类,包含MD5,BASE64,SHA,CRC32的加密与解密方法. 源码如下:(点击下载  - CryptoUtils.java.commons-io-2.4.jar.commons-code ...

  9. 你猜……你再猜

    『男』:你喜欢我吗? 『女』:你猜. 『男』:喜欢. 『女』:你再猜. 『男』:--

  10. 可辨别iPhone真假的网址

    在如下的网址中输入iPhone的序列号,可知道该iPhone的型号,生产日期,激活状态等. 1.http://www.app111.org/ 2.http://act.weiphone.com/wet ...