安卓使用 AIDL 实现进程间通信 IPC

AIDL (Android Interface Definition Language) 是一种IDL 语言，用于生成可以在Android设备上两个进程之间进行进程间通信(inter process communication, IPC)的代码。如果在一个进程中（例如Activity）要调用另一个进程中（例如Service）对象的操作，就可以使用 AIDL 生成可序列化的参数。

IPC 是进程间通信的意思，其主要方式有以下几种：

Bundle
文件共享
AIDL
Messenger
ContentProvider
Socket

一、IPC 的基础和概念

1.多进程模式

a. 进程与线程

进程:一般指一个执行单元，在 PC 和移动设备上指一个程序或应用。
线程：CPU 调度的最小单元，线程是一种有限的系统资源。

两者关系：一个进程可包含多个线程，即一个应用程序上可以执行多个任务。

主线程(UI 线程)：UI 操作

有限个子线程：耗时操作

b. 开启多进程的方式：

（不常用）通过 JNI 在 native 层 fork 一个新的进程
（常用）对安卓四大组件的配置清单页面设置 android:precess，进程名的命名规则：

默认进程，即省略不写，默认是在当前进程 android:process = "com.test.applicatio”
以：开头的进程，通过使用 android:process = " :remote" 方式，全称是 android:process = "com.test.application:remote"，表示是当前应用的私有进程，其他进程的组件不能和它跑在同一进程中
以 . 开头的全局进程，android:process = " .remote" ,全称是 android:process = "com.test.application.remote"，其他应用可以通过 ShareUID 的方式和它跑在同一进程中。

UID&ShareUID：
Android系统为每个应用分配一个唯一的UID，具有相同UID的应用才能共享数据。
两个应用通过ShareUID跑在同一进程的条件：ShareUID相同且签名也相同。
满足上述条件的两个应用，无论是否跑在同一进程，它们可共享data目录，组件信息。
若跑在同一进程，它们除了可共享data目录、组件信息，还可共享内存数据。它们就像是一个应用的两个部分。

如何设置 ShareUid 相同呢，很简单：

**//第一个应用程序为的menifest文件代码如下：**

//.......
**//第二个应用程序的menifest文件代码如下：**

IPC 简介

a. IPC（Inter-Process Communication，跨进程通信）：指两个进程之间进行数据交换的过程。

b. 任何一个操作系统都有对应的IPC机制。
Windows：通过剪切板、管道、油槽等进行进程间通讯。
Linux：通过命名空间、共享内容、信号量等进行进程间通讯。
Android：没有完全继承Linux，比如，其独具特色的通讯方式有Binder、Socket等等。

c. IPC的使用场景：
由于某些原因，应用自身需要采用多进程模式来实现。可能原因有：
某些模块因特殊原因要运行在单独进程中；
为加大一个应用可使用的内存，需通过多进程来获取多份内存空间。
当前应用需要向其它应用获取数据。

d. Android的进程架构：每一个Android进程都是独立的，且都由两部分组成，一部分是用户空间，另一部分是内核空间。

e. Binder 工作原理：
服务器端：在服务端创建好了一个Binder对象后，内部就会开启一个线程用于接收Binder驱动发送的消息，收到消息后会执行onTranscat()，并按照参数执行不同的服务端代码。

Binder驱动：在服务端成功创建 Binder 对象后，Binder驱动也会创建一个mRemote对象（也是Binder类），客户端可借助它调用transcat()即可向服务端发送消息。

客户端：客户端要想访问Binder的远程服务，就必须获取远程服务的Binder对象在Binder驱动层对应的mRemote引用。当获取到mRemote对象的引用后，就可以调用相应Binder对象的暴露给客户端的方法。

如何使用 AIDL 进行 IPC(进程间通信)

先建立一个安卓工程作为跨进程通信的服务端。

新建一个包名，用来存放 aidl 文件，例如 com.example.aidl ，在里边新建一个 IMyService.aidl 接口文件，文件里定义两个方法用来返回数据和添加数据，这里的数据使用了自定义对象，所以还要建立对象的 aidl 文件和对应的 java 文件，并且要和 IMyAidlInterface.aidl 放在同一个包名下。

IMyAidlInterface.aidl 代码如下：

//IMyAidlInterface.aidl
package com.example.myapplication;
import com.example.myapplication.PersonBean;

// Declare any non-default types here with import statementsinterface 
IMyAidlInterface {
    void addPerson(in PersonBean mBean);
    List getPerson();
}

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

PersonBean.aidl 文件代码如下，比较简单就是一个当前包的路径和一个定义

package com.example.myapplication;parcelable PersonBean;

这里的 PersonBean 必须用 parcelable 定义，这里的 parcelable 和序列化的 Parcelable 不是同一个东西，这里只是标记一个类型。

然后是 PersonBean.java 类：

package com.example.myapplication;

import android.os.Parcel;
import android.os.Parcelable;

public class PersonBean implements Parcelable {
    private int age;
    private String name;

    public PersonBean(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


    protected PersonBean(Parcel in) {
        age = in.readInt();
        name = in.readString();
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(age);
        dest.writeString(name);
    }

    @Override
    public int describeContents() {
        return 0;
    }

    public static final Creator CREATOR = new Creator() {
        @Override
        public PersonBean createFromParcel(Parcel in) {
            return new PersonBean(in);
        }

        @Override
        public PersonBean[] newArray(int size) {
            return new PersonBean[size];
        }
    };
}

这里就是定义了一个实现 Parcelable 接口的对象，里边定义了 age 和 name 两个参数，其他字段和属性可以自动生成，使用编辑器在当前页面右键选择 generate 然后选择对应的生成内容就会帮我们全部添加进来。

此时可以同步一下工程或者 clean rebuild 一下工程，android studio 会自动生成 IMyAidlInterface.aidl 文件对应的 java 类。

查看此类的代码结构，如图

其中有一个自动生成的代理类如下所示

public static abstract class Stub extends android.os.Binder implements com.example.myapplication.IMyAidlInterface

可以看到此类就是一个普通的 Binder,并实现了我们写的

IMyAidlInterface 接口。此外还有一个静态方法，

/**
 * Cast an IBinder object into an com.example.myapplication.IMyAidlInterface interface,
 * generating a proxy if needed.
 */
public static com.example.myapplication.IMyAidlInterface asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.example.myapplication.IMyAidlInterface))) {
return ((com.example.myapplication.IMyAidlInterface)iin);
}
return new com.example.myapplication.IMyAidlInterface.Stub.Proxy(obj);
}

通过查看这里的源码可以发现，此方法会将服务端的 myService 里返回的IBinder 转换成一个代理类 proxy ，转换过程会判断当前客户端和服务端是否属于同一个进程，如果是则直接返回如果不是则转换成代理类，代理类也在这个 java 文件里。

然后创建上边提到的服务端的 myService 服务

image

其中的 onBind 方法返回一个 IMyAidlInterface.Stub 类的对象，这里的代码如下

private final IMyAidlInterface.Stub mBinder = new IMyAidlInterface.Stub(){
        @Override
        public void addPerson(PersonBean mBean) throws RemoteException {
           synchronized(mStudents){
               if(!mStudents.contains(mBean)){
                   mStudents.add(mBean);
               }
           }
        }
        @Override
        public List getPerson() throws RemoteException {
            synchronized (mStudents){
                return mStudents;
            }
        }
        @Override
        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.i(TAG,packageName);
            if(!PACKAGE_NAME.equals(packageName)){
                return false;
            }
            return super.onTransact(code, data, reply, flags);
        }
    };
    @Override
    public IBinder onBind(Intent intent) {
        Log.e(TAG, String.format("on bind,intent = %s", intent.toString()));
        displayNotificationMessage("服务已启动");
        return mBinder;
    }

IMyAidlInterface.Stub 类里返回上边 Stub 类里的两个自定义方法，然后将此类的对象 mBinder 在 onBind 里返回供客户端调用。

此外，你可能只想让你的 service 被指定的 apk 应用调用，其他应用不能调用，这时可以重写 Stub 里的 onTransact 方法，并判断当前的 uid 和调用的客户端的 uid 是否一致，如果相同返回 true,否则返回 false ,这样就可以控制特定应用调用的问题。

在 manifest 里声明当前的 service

新建一个工程充当客户端，并把服务端里的 aild 包下的所有文件包含 PersonBean.java 文件一起复制到客户端工程里，并且包名不能改变，否则运行的时候会出现 crash 。客户端绑定 service 的代码很简单

package com.example.mysocket11;

import android.app.AlertDialog;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Toast;

import com.example.myapplication.IMyAidlInterface;
import com.example.myapplication.PersonBean;


public class MainActivity extends AppCompatActivity {

   IMyAidlInterface myAidlInterface;
   private final String  ACTION_BIND_SERVICE = "com.example.myapplication.MyService";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        findViewById(R.id.text).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intentService = new Intent(ACTION_BIND_SERVICE);
                intentService.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                intentService.setPackage("com.example.myapplication");
                bindService(intentService,mServiceConnection,BIND_AUTO_CREATE);
            }
        });
    }
    ServiceConnection mServiceConnection = new ServiceConnection(){
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            myAidlInterface = IMyAidlInterface.Stub.asInterface(service);
            try {
                PersonBean toastName = myAidlInterface.getPerson().get(0);
                Toast.makeText(MainActivity.this,toastName.toString(),Toast.LENGTH_SHORT).show();
                showDialog(toastName.toString());
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println(e.toString());
                Log.e("没有获取到数据",e.toString());
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            myAidlInterface = null;
        }
    };
    public void showDialog(String message)
    {
        new AlertDialog.Builder(MainActivity.this)
                .setTitle("an")
                .setMessage(message)
                .setPositiveButton("确定", null)
                .show();
    }
    @Override
    protected void onDestroy() {
        if (myAidlInterface != null) {
            unbindService(mServiceConnection);
        }
        super.onDestroy();
    }
}

先是绑定服务然后在服务连接成功处获取对应的 IBinder 实例，根据这个对象调用服务端的接口里的方法，实现两个不同的进程间获取数据。

最终的效果图如下

安卓使用 AIDL 实现进程间通信 IPC

一 、IPC 的基础和概念

1.多进程模式

你可能感兴趣的:(安卓使用 AIDL 实现进程间通信 IPC)

一、IPC 的基础和概念