Android跨进程通信-AIDL的使用

最新推荐文章于 2024-09-11 16:45:45 发布

「已注销」

最新推荐文章于 2024-09-11 16:45:45 发布

阅读量851

点赞数 1

文章标签： Android基础知识

本文链接：https://blog.csdn.net/wu371894545/article/details/52753748

版权

转载请注明出处：http://blog.csdn.net/wu371894545/article/details/52753748

1、为什么要有AIDL？

为什么要有AIDL呢，官方文档介绍AIDL中有这么一句话：

1

 
        Note: Using AIDL is necessary only  
        if 
        you allow clients from different applications to access your service  
        for 
        IPC and want to handle multithreading in your service. If you  
        do 
        not need to perform concurrent IPC across different applications, you should create your 
        interface 
        by implementing a Binder or,  
        if 
        you want to perform IPC, but  
        do 
        not need to handle multithreading, implement your  
        interface 
        using a Messenger. Regardless, be sure that you understand Bound Services before implementing an AIDL. 
       

第一句最重要，“只有当你允许来自不同的客户端访问你的服务并且需要处理多线程问题时你才必须使用AIDL”，其他情况下你都可以选择其他方法，如使用Messager，也能跨进程通讯。可见AIDL是处理多线程、多客户端并发访问的。而Messager是单线程处理。还是官方文档说的明白，一句话就可以理解为什么要有AIDL。那么是不是这样的写个AIDL试试。

2、AIDL的使用？

服务端：

服务端创建一个Service用来监听客户端的连接请求，然后创建一个AIDL文件，将暴露给客户端的接口在这个AIDL文件中申明，最后在Service中实现这个AIDL接口即可。

客户端：

首先需要绑定服务端的Service，绑定成功后，将服务端返回的Binder对象转成AIDL接口所需要的类型，接着就可以调用AIDL中的方法了。

1.先建立一个android工程，用作服务端

创建一个android工程，用来充当跨进程通信的服务端。

2.创建一个包名用来存放aidl文件

创建一个包名用来存放aidl文件,比如com.ryg.sayhi.aidl，在里面新建IMyService.aidl文件，如果需要访问自定义对象，还需要建立对象的aidl文件，这里我们由于使用了自定义对象Student，所以，还需要创建Student.aidl和Student.java。注意，这三个文件，需要都放在com.ryg.sayhi.aidl包里。下面描述如何写这三个文件。

IMyService.aidl代码如下：

[java]view plaincopy 
      
 package com.ryg.sayhi.aidl;  
   
 import com.ryg.sayhi.aidl.Student;  
   
 interface IMyService {  
   
     List<Student> getStudent();  
     void addStudent(in Student student);  
 }  

说明：

aidl中支持的参数类型为：基本类型（int,long,char,boolean等）,String,CharSequence,List,Map，其他类型必须使用import导入，即使它们可能在同一个包里，比如上面的Student，尽管它和IMyService在同一个包中，但是还是需要显示的import进来。
另外，接口中的参数除了aidl支持的类型，其他类型必须标识其方向：到底是输入还是输出抑或两者兼之，用in，out或者inout来表示，上面的代码我们用in标记，因为它是输入型参数。

在gen下面可以看到，eclipse为我们自动生成了一个代理类

public static abstract class Stub extends android.os.Binder implements com.ryg.sayhi.aidl.IMyService

可见这个Stub类就是一个普通的Binder，只不过它实现了我们定义的aidl接口。它还有一个静态方法

public static com.ryg.sayhi.aidl.IMyService asInterface(android.os.IBinder obj)

这个方法很有用，通过它，我们就可以在客户端中得到IMyService的实例，进而通过实例来调用其方法。

Student.aidl代码如下：

[java]view plaincopy 
      
 package com.ryg.sayhi.aidl;  
   
 parcelable Student;  

说明：这里parcelable是个类型，首字母是小写的，和Parcelable接口不是一个东西，要注意。

Student.java代码如下：

[java]view plaincopy 
      
 package com.ryg.sayhi.aidl;  
   
 import java.util.Locale;  
   
 import android.os.Parcel;  
 import android.os.Parcelable;  
   
 public final class Student implements Parcelable {  
   
     public static final int SEX_MALE = 1;  
     public static final int SEX_FEMALE = 2;  
   
     public int sno;  
     public String name;  
     public int sex;  
     public int age;  
   
     public Student() {  
     }  
   
     public static final Parcelable.Creator<Student> CREATOR = new  
             Parcelable.Creator<Student>() {  
   
                 public Student createFromParcel(Parcel in) {  
                     return new Student(in);  
                 }  
   
                 public Student[] newArray(int size) {  
                     return new Student[size];  
                 }  
   
             };  
   
     private Student(Parcel in) {  
         readFromParcel(in);  
     }  
   
     @Override  
     public int describeContents() {  
         return 0;  
     }  
   
     @Override  
     public void writeToParcel(Parcel dest, int flags) {  
         dest.writeInt(sno);  
         dest.writeString(name);  
         dest.writeInt(sex);  
         dest.writeInt(age);  
     }  
   
     public void readFromParcel(Parcel in) {  
         sno = in.readInt();  
         name = in.readString();  
         sex = in.readInt();  
         age = in.readInt();  
     }  
       
     @Override  
     public String toString() {  
         return String.format(Locale.ENGLISH, "Student[ %d, %s, %d, %d ]", sno, name, sex, age);  
     }  
   
 }  

说明：通过AIDL传输非基本类型的对象，被传输的对象需要序列化，序列化功能java有提供，但是android sdk提供了更轻量级更方便的方法，即实现Parcelable接口，关于android的序列化。这里只要简单理解一下就行，大意是要实现如下函数
readFromParcel : 从parcel中读取对象

writeToParcel ：将对象写入parcel

describeContents：返回0即可

Parcelable.Creator<Student> CREATOR：这个照着上面的代码抄就可以

需要注意的是，readFromParcel和writeToParcel操作数据成员的顺序要一致

3.创建服务端service

创建一个service，比如名为MyService.java，代码如下：

[java]view plaincopy 
       
 /** 
  * @author scott 
  */  
 public class MyService extends Service  
 {  
     private final static String TAG = "MyService";  
     private static final String PACKAGE_SAYHI = "com.example.test";  
   
     private NotificationManager mNotificationManager;  
     private boolean mCanRun = true;  
     private List<Student> mStudents = new ArrayList<Student>();  
       
     //这里实现了aidl中的抽象函数  
     private final IMyService.Stub mBinder = new IMyService.Stub() {  
   
         @Override  
         public List<Student> getStudent() throws RemoteException {  
             synchronized (mStudents) {  
                 return mStudents;  
             }  
         }  
   
         @Override  
         public void addStudent(Student student) throws RemoteException {  
             synchronized (mStudents) {  
                 if (!mStudents.contains(student)) {  
                     mStudents.add(student);  
                 }  
             }  
         }  
   
         //在这里可以做权限认证，return false意味着客户端的调用就会失败，比如下面，只允许包名为com.example.test的客户端通过，  
         //其他apk将无法完成调用过程  
         public boolean onTransact(int code, Parcel data, Parcel reply, int flags)  
                 throws RemoteException {  
             String packageName = null;  
             String[] packages = MyService.this.getPackageManager().  
                     getPackagesForUid(getCallingUid());  
             if (packages != null && packages.length > 0) {  
                 packageName = packages[0];  
             }  
             Log.d(TAG, "onTransact: " + packageName);  
             if (!PACKAGE_SAYHI.equals(packageName)) {  
                 return false;  
             }  
   
             return super.onTransact(code, data, reply, flags);  
         }  
   
     };  
   
     @Override  
     public void onCreate()  
     {  
         Thread thr = new Thread(null, new ServiceWorker(), "BackgroundService");  
         thr.start();  
   
         synchronized (mStudents) {  
             for (int i = 1; i < 6; i++) {  
                 Student student = new Student();  
                 student.name = "student#" + i;  
                 student.age = i * 5;  
                 mStudents.add(student);  
             }  
         }  
   
         mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);  
         super.onCreate();  
     }  
   
     @Override  
     public IBinder onBind(Intent intent)  
     {  
         Log.d(TAG, String.format("on bind,intent = %s", intent.toString()));  
         displayNotificationMessage("服务已启动");  
         return mBinder;  
     }  
   
     @Override  
     public int onStartCommand(Intent intent, int flags, int startId)  
     {  
         return super.onStartCommand(intent, flags, startId);  
     }  
   
     @Override  
     public void onDestroy()  
     {  
         mCanRun = false;  
         super.onDestroy();  
     }  
   
     private void displayNotificationMessage(String message)  
     {  
         Notification notification = new Notification(R.drawable.icon, message,  
                 System.currentTimeMillis());  
         notification.flags = Notification.FLAG_AUTO_CANCEL;  
         notification.defaults |= Notification.DEFAULT_ALL;  
         PendingIntent contentIntent = PendingIntent.getActivity(this, 0,  
                 new Intent(this, MyActivity.class), 0);  
         notification.setLatestEventInfo(this, "我的通知", message,  
                 contentIntent);  
         mNotificationManager.notify(R.id.app_notification_id + 1, notification);  
     }  
   
     class ServiceWorker implements Runnable  
     {  
         long counter = 0;  
   
         @Override  
         public void run()  
         {  
             // do background processing here.....  
             while (mCanRun)  
             {  
                 Log.d("scott", "" + counter);  
                 counter++;  
                 try  
                 {  
                     Thread.sleep(2000);  
                 } catch (InterruptedException e)  
                 {  
                     e.printStackTrace();  
                 }  
             }  
         }  
     }  
   
 }  

说明：为了表示service的确在活着，我通过打log的方式，每2s打印一次计数。上述代码的关键在于onBind函数，当客户端bind上来的时候，将IMyService.Stub mBinder返回给客户端，这个mBinder是aidl的存根，其实现了之前定义的aidl接口中的抽象函数。

问题：问题来了，有可能你的service只想让某个特定的apk使用，而不是所有apk都能使用，这个时候，你需要重写Stub中的onTransact方法，根据调用者的uid来获得其信息，然后做权限认证，如果返回true，则调用成功，否则调用会失败。对于其他apk，你只要在onTransact中返回false就可以让其无法调用IMyService中的方法，这样就可以解决这个问题了。

4. 在AndroidMenifest中声明service

[html]view plaincopy 
       
 <service  
     android:name="com.ryg.sayhi.MyService"  
     android:process=":remote"  
     android:exported="true" >  
     <intent-filter>  
         <category android:name="android.intent.category.DEFAULT" />  
         <action android:name="com.ryg.sayhi.MyService" />  
     </intent-filter>  
 </service>  

说明：上述的 <action Android:name="com.ryg.sayhi.MyService" />是为了能让其他apk隐式bindService，通过隐式调用的方式来起activity或者service，需要把category设为default，这是因为，隐式调用的时候，intent中的category默认会被设置为default。

5. 新建一个工程，充当客户端

新建一个客户端工程，将服务端工程中的com.ryg.sayhi.aidl包整个拷贝到客户端工程的src下，这个时候，客户端com.ryg.sayhi.aidl包是和服务端工程完全一样的。如果客户端工程中不采用服务端的包名，客户端将无法正常工作，比如你把客户端中com.ryg.sayhi.aidl改一下名字，你运行程序的时候将会crash，也就是说，客户端存放aidl文件的包必须和服务端一样。客户端bindService的代码就比较简单了，如下：

[java]view plaincopy 
      
 import com.ryg.sayhi.aidl.IMyService;  
 import com.ryg.sayhi.aidl.Student;  
   
 public class MainActivity extends Activity implements OnClickListener {  
   
     private static final String ACTION_BIND_SERVICE = "com.ryg.sayhi.MyService";  
     private IMyService mIMyService;  
   
     private ServiceConnection mServiceConnection = new ServiceConnection()  
     {  
         @Override  
         public void onServiceDisconnected(ComponentName name)  
         {  
             mIMyService = null;  
         }  
   
         @Override  
         public void onServiceConnected(ComponentName name, IBinder service)  
         {  
             //通过服务端onBind方法返回的binder对象得到IMyService的实例，得到实例就可以调用它的方法了  
             mIMyService = IMyService.Stub.asInterface(service);  
             try {  
                 Student student = mIMyService.getStudent().get(0);  
                 showDialog(student.toString());  
             } catch (RemoteException e) {  
                 e.printStackTrace();  
             }  
   
         }  
     };  
   
     @Override  
     protected void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.activity_main);  
         Button button1 = (Button) findViewById(R.id.button1);  
         button1.setOnClickListener(new OnClickListener() {  
   
     @Override  
     public void onClick(View view) {  
         if (view.getId() == R.id.button1) {  
             Intent intentService = new Intent(ACTION_BIND_SERVICE);  
             intentService.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
             MainActivity.this.bindService(intentService, mServiceConnection, BIND_AUTO_CREATE);  
         }  
   
     }  
   
     public void showDialog(String message)  
     {  
         new AlertDialog.Builder(MainActivity.this)  
                 .setTitle("scott")  
                 .setMessage(message)  
                 .setPositiveButton("确定", null)  
                 .show();  
     }  
       
     @Override  
     protected void onDestroy() {  
         if (mIMyService != null) {  
             unbindService(mServiceConnection);  
         }  
         super.onDestroy();  
     }  
 }  