Android AIDL--进程间通讯

时间  2019-11-24
标签 android aidl 进程 通讯 栏目 Android 繁體版
原文   原文链接

一 AIDL 是什么

AIDL（Android 接口定义语言） 是 Android 提供的一种进程间通讯 (IPC) 机制。java

咱们能够利用它定义客户端与服务使用进程间通讯 (IPC) 进行相互通讯时都承认的编程接口。android

在 Android 上，一个进程一般没法访问另外一个进程的内存。 尽管如此，进程须要将其对象分解成操做系统可以识别的原语，并将对象编组成跨越边界的对象。编程

编写执行这一编组操做的代码是一项繁琐的工做，所以 Android 会使用 AIDL 来处理。app

经过这种机制，咱们只须要写好 aidl 接口文件，编译时系统会帮咱们生成 Binder 接口。dom

 

二 AIDL 支持的数据类型

共 4 种：ide

    1. Java 的基本数据类型
    2. List 和 Map 
      • 元素必须是 AIDL 支持的数据类型
      • Server 端具体的类里则必须是 ArrayList 或者 HashMap
    3. 其余 AIDL 生成的接口
    4. 实现 Parcelable 的实体

三 AIDL 编写步骤

AIDL 的编写主要为如下三部分：this

    1. 建立 AIDL 
      • 建立要操做的实体类，实现 Parcelable 接口，以便序列化/反序列化
      • 新建 aidl 文件夹，在其中建立接口 aidl 文件以及实体类的映射 aidl 文件
      • Make project ，生成 Binder 的 Java 文件
    2. 服务端 
      • 建立 Service，在其中建立上面生成的 Binder 对象实例，实现接口定义的方法
      • 在 onBind() 中返回
    3. 客户端 
      • 实现 ServiceConnection 接口，在其中拿到 AIDL 类
      • bindService()
      • 调用 AIDL 类中定义好的操做请求

四 案例

项目结构图：spa

 

1.建立AIDL

1.1建立要操做的实体类，实现 Parcelable 接口，以便序列化/反序列化

package net.shunzhi.aidldemo1.bean;

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

/**
 * Created by Administrator on 2018/3/9 0009.
 */

public class Person implements Parcelable {
    private String mName;

    public Person (String name){
        this.mName=name;
    }
    protected Person(Parcel source){
        this.mName=source.readString();
    }


    public static final Creator<Person> CREATOR=new Creator<Person>() {
        @Override
        public Person createFromParcel(Parcel source) {
            return new Person(source);
        }

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

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

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

    @Override
    public String toString() {
        return "Person{" +
                "mName='" + mName + '\'' +
                '}';
    }
}

 

 

1.2新建 aidl 文件夹，在其中建立接口 aidl 文件以及实体类的映射 aidl 文件

 1.鼠标移到项目上面去，点击右键，而后 new->AIDL->AIDL File，按下鼠标左键就会弹出一个框提示生成AIDL文件（IMyAIdlInterface）了操作系统

 自动生成如图：代理

2.编写接口IMyAdilInterface.aidl

// IMyAidlInterface.aidl
//第二类AIDL文件
//做用是定义方法接口
package net.shunzhi.aidldemo1;

////导入所须要使用的非默认支持数据类型的包
import net.shunzhi.aidldemo1.bean.Person;

interface IMyAidlInterface {

   //传参时除了Java基本类型以及String，CharSequence以外的类型
   //都须要在前面加上定向tag，具体加什么量需而定：in(输入), out(输出), inout(输入输出)
   void addPerson(in Person person);

   //全部的返回值前都不须要加任何东西，无论是什么数据类型
   List<Person> getAllPersons();
}

在接口 aidl 文件中定义未来要在跨进程进行的操做，上面的接口中定义了两个操做：

  • addPerson: 添加 Person
  • getPersonList：获取 Person 列表

须要注意的是：

    • 非基本类型的数据须要导入，好比上面的 Person，须要导入它的全路径。 
      • 这里的 Person 我理解的是 Person.aidl，而后经过 Person.aidl 又找到真正的实体 Person 类。
    • 方法参数中，除了基本数据类型，其余类型的参数都须要标上方向类型 
      • in(输入), out(输出), inout(输入输出)

 

 

3.建立实体类Person.aidl

//第一类AIDL文件
//这个文件的做用是引入了一个序列化对象 Book 供其余的AIDL文件使用
//注意：Person.aidl与Person.java的包名应当是同样的
package net.shunzhi.aidldemo1.bean;


//parcelable 为小写
parcelable Person;

 

2.服务端

2.1建立 Service，在其中建立上面生成的 Binder 对象实例，实现接口定义的方法；而后在 onBind() 中返回

 

package net.shunzhi.aidldemo1;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.annotation.Nullable;

import net.shunzhi.aidldemo1.bean.Person;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by Administrator on 2018/3/9 0009.
 */

public class MyAidlService extends Service {

    private String TAG="MyAidlService";
    private List<Person> list;

    /**
     * 建立生成的本地 Binder 对象，实现 AIDL 制定的方法
     */
    private IBinder iBinder=new IMyAidlInterface.Stub() {
        @Override
        public void addPerson(Person person) throws RemoteException {
            list.add(person);
        }

        @Override
        public List<Person> getAllPersons() throws RemoteException {
            return list;
        }
    };


    /**
     * 客户端与服务端绑定时的回调，返回 mIBinder 后客户端就能够经过它远程调用服务端的方法，即实现了通信
     * @param intent
     * @return
     */
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        list=new ArrayList<>();
        return iBinder;
    }
}

 

2.2在 Manifest 文件中声明

 

<service android:name=".MyAidlService"
            android:enabled="true"
            android:exported="true"
            android:process=":aidl"
            />

 

3.客户端

3.1实现 ServiceConnection 接口，在其中拿到 AIDL 类

private ServiceConnection connection=new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        //链接后拿到 Binder，转换成 AIDL，在不一样进程会返回个代理
        aidl=IMyAidlInterface.Stub.asInterface(service);
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
        aidl=null;
    }
};

在 Activity 中建立一个服务链接对象，在其中调用 IMyAidl.Stub.asInterface() 方法将 Binder 转为 AIDL 类

3.2接着绑定服务

 

Intent intent=new Intent(MainActivity.this,MyAidlService.class);
bindService(intent,connection,BIND_AUTO_CREATE);

 

3.3拿到 AIDL 类后，就能够调用 AIDL 类中定义好的操做，进行跨进程请求

 

private void addPerson(){
        Random random=new Random();
        Person p=new Person("fhasdfh"+random.nextInt(10) );
        try {
            aidl.addPerson(p);
            tv.setText(aidl.getAllPersons().toString());
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

总体代码：

package net.shunzhi.aidldemo1;

import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import net.shunzhi.aidldemo1.bean.Person;

import java.util.Random;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private TextView tv;
    private Button bt1,bt2;
    private IMyAidlInterface aidl;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
    }

    private void initView() {
        tv=findViewById(R.id.tv);
        bt1=findViewById(R.id.bt1);
        bt2=findViewById(R.id.bt2);
        bt1.setOnClickListener(this);
        bt2.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.bt1://绑定服务
                Intent intent=new Intent(MainActivity.this,MyAidlService.class);
                bindService(intent,connection,BIND_AUTO_CREATE);
                break;
            case R.id.bt2:
                addPerson();
                break;
        }
    }

    //拿到 AIDL 类后，就能够调用 AIDL 类中定义好的操做，进行跨进程请求
    private void addPerson(){
        Random random=new Random();
        Person p=new Person("fhasdfh"+random.nextInt(10) );
        try {
            aidl.addPerson(p);
            tv.setText(aidl.getAllPersons().toString());
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }


    private ServiceConnection connection=new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //链接后拿到 Binder，转换成 AIDL，在不一样进程会返回个代理
            aidl=IMyAidlInterface.Stub.asInterface(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            aidl=null;
        }
    };
}

 

效果图：

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程