初涉IPC，了解AIDL的工作原理及使用方法

今天来讲讲AIDL，这个神秘的AIDL，也是最近在学习的，看了某课大神的讲解写下的blog，希望结合自己的看法给各位同价通俗易懂的讲解

官方文档:http://developer.android.com/guide/components/aidl.html

一.What is AIDL?（什么是AIDL）

AIDL:Android Interface Definition Language （Android接口定义语言）

首先，我们要知道，进程1和进程2，我们要如何让他通讯？

在Android系统的虚拟机中，每一个app运行都是在一个独立的沙箱里面的，这样的话，一个应用崩溃也不会影响到其他应用，这样我们就提出了一个问题，跨进程如如何进行通讯？如何传递数据？其实两个进程是不能直接通讯的，他需要Android系统底层的帮助来进行通讯！那就是我们每个人都知道的四大组件

我们首先还是先进Google的API看看

他大概的意思是他允许你去定义一个自己的标准，使用的是IPC（进程间通讯）进制，跨进程通讯，有兴趣的可以去翻译一下，不过值得注意的是他的第二段标记

这里提到了两个东西

Binder
Messenger

我们继续往下看话就知道

Binder
Messenger

翻译：如果您不需要执行并发IPC在不同的应用程序中你就用Binder ，或者如果你想执行IPC,但不需要处理多线程,实现你的接口Messenger，无论如何,确保你了解实现AIDL之前绑定服务。

所以我们就能理清楚AIDL的概念了

AIDL //IPC 多应用多线程

二.Defining an AIDL Interface(语法)

文档中强调。你必须定义一个.aidl的文件，那我们怎样去创建尼？

1. Create the .aidl file（创建一个.aidl文件）

官方提供的语法

// IRemoteService.aidl
package 包名（com.lgl.android）;
// Declare any non-default types here with import statements
/** Example service interface  接口*/
interface IRemoteService {
    /** Request the process ID of this service, to do evil things with it.  方法*/
    int getPid();
    /** Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
}

我们来做一个简单的演示

我们要使用的编译工具在我们的SDK/buidl-tools/android版本/aidl.bat，不过实际开发中也不需要手动编译，我们新建一个项目ForAIDL,这里我们使用的开发工具是Android Studio，其实Eclipse可能更加让人熟悉，不过用AS也是大势所趋了，而且AS的目录结构我也很喜欢

我们直接java-new - folder - AIDL folder

然后你就会发现多了一个aidl的文件夹

我们继续新建一个包名，新建一个文件文件new - AIDL - file

大致的内容

// IMyAidlInterface.aidl
package com.lgl.foraidl;
// Declare any non-default types here with import statements
interface IMyAidlInterface {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
}

AS默认是不会去重新构建Gradle,我们点击一下构建按钮

然后我们就可以在MainActivity中调用了

三.AIDL Client And Service(客户端和服务端)

现在就好玩了，我们先来理理思路，一般是这样的，我们一个软件有某个功能，也就是服务端，然后客户端通过AIDL去访问

这里可以看到服务端只是处理一些操作，我们客户端去请求，这样的话，那我创建一个AIDLService,同样的，我们需要去创建AIDL文件，命名-ServiceAidlInterface

ServiceAidlInterface

// ServiceAidlInterface.aidl
package com.lgl.aidlservice;
// Declare any non-default types here with import statements
interface ServiceAidlInterface {
   /*
    *计算两数之和
    */
    int add(int num1,int num2);
}

现在我们处理的就不是默认的东西了，AIDL的原理就是你自定义语言接口，对的，我们也来

2. Implement the interface（实现一个AIDL）

根据我们的Google文档，第一步Create the .aidl file已经完成了，现在就来进行第二步了，我们这里需要使用到Service,看文档

这样的话我们新建一个IRemoteService继承service,我们实现计算的逻辑处理

package com.lgl.aidlservice;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
/**
 *
 * 监听服务
 * Created by lgl on 16/3/13.
 */
public class IRemoteService extends Service{
    /**
     * 当客户端绑定到该服务的时候启动onBind
     * @param intent
     * @return
     */
    @Override
    public IBinder onBind(Intent intent) {
        //绑定之后就计算
        return iBinder;
    }
    /**
     * 开始处理结果
     */
    private IBinder iBinder = new ServiceAidlInterface.Stub(){
        @Override
        public int add(int num1, int num2) throws RemoteException {
            Log.i("AIDL","收到了请求,參數1"+num1+"參數2"+num2);
            return num1+num2;
        }
    };
}

3. Expose the interface to clients（客户端的实现）

OK,写完了服务端就可以写客户端了，我们直接new一个Module-AIDLClients

我們先按剛才的逻辑，把界面写了

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:gravity="center"
    android:padding="15dp">
    <TextView
        android:text="AIDL"
        android:textSize="50sp"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
   <EditText
       android:hint="请输入数字1"
       android:id="@+id/et_num1"
       android:layout_width="match_parent"
       android:layout_height="wrap_content" />
    <TextView
        android:layout_marginBottom="15dp"
        android:layout_marginTop="15dp"
        android:textSize="20sp"
        android:text="+"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
    <EditText
        android:hint="请输入数字2"
        android:id="@+id/et_num2"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
    <TextView
        android:layout_marginBottom="15dp"
        android:layout_marginTop="15dp"
        android:textSize="20sp"
        android:text="="
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
    <TextView
        android:id="@+id/tv_result"
        android:text="结果："
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
    <Button
        android:textColor="#fff"
        android:background="@android:color/holo_blue_light"
        android:layout_marginTop="30dp"
        android:id="@+id/btn_ok"
        android:text="计算"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
</LinearLayout>

我们要想客户端调用服务端的内容，那么就一定要定义标准的语言，所以客户端的aidl和服务端必须一致

记住，每次不通过的时候先编译一遍

MainActivity(客户端)

package com.lgl.aidlclients;
import android.content.ComponentName;
import android.content.Context;
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.EditText;
import android.widget.TextView;
import com.lgl.aidlservice.ServiceAidlInterface;
/**
 * AIDL 客户端
 * @author lgl
 */
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    //输入
    private EditText et_num1,et_num2;
    //结果
    private TextView tv_result;
    //AIDL远程访问
    private Button btn_ok;
    private ServiceAidlInterface aidl;
    private ServiceConnection conn = new ServiceConnection() {
        //连接上
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            //拿到远程服务
            aidl = ServiceAidlInterface.Stub.asInterface(iBinder);
        }
        //断开时
        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            //回收
            aidl = null;
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        bindServices();
    }
    private void initView() {
        et_num1 = (EditText) findViewById(R.id.et_num1);
        et_num2 = (EditText) findViewById(R.id.et_num2);
        tv_result = (TextView) findViewById(R.id.tv_result);
        btn_ok = (Button) findViewById(R.id.btn_ok);
        btn_ok.setOnClickListener(this);
    }
    @Override
    public void onClick(View view) {
        switch (view.getId()){
            case R.id.btn_ok:
                int num1 = Integer.parseInt(et_num1.getText().toString());
                int num2 = Integer.parseInt(et_num2.getText().toString());
                try {
                    //结果
                    int res = aidl.add(num1,num2);
                    tv_result.setText("结果："+res);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
        }
    }
    /**
     * 开启服务
     */
    private void bindServices() {
        //获取服务端
        Intent intent = new Intent();
        //5.0之后的改变
        intent.setComponent(new ComponentName("com.lgl.aidlservice","com.lgl.aidlservice.IRemoteService"));
        //绑定服务
        bindService(intent,conn, Context.BIND_AUTO_CREATE);
    }
    /**
     * 销毁服务
     */
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(conn);
    }
}

这里逻辑也是十分的清晰，你创建了之后启动服务，我调用方法来计算，我们来演示一下，我们先启动服务端，再启动客户端

记得注册

 <service android:name=".IRemoteService"
            android:process=":remote"
            android:exported="true" >
            <intent-filter>
                <category android:name="android.intent.category.DEFAULT" />
                <action android:name="com.lgl.aidlservice.IRemoteService" />
            </intent-filter>
        </service>

写到这里才看到玉刚也写了相关的信息，这边android:exported=”true”为权限问题，具体可以看下:

android跨进程通信（IPC）：使用AIDL

不过这终究也只是一些小菜，我们项目中也不可能用到这么low的方法，毕竟AIDL还是很强大的，既然这样，那我们来玩玩高级一点的

四.AIDL数据传递

我们不能传递很大的数据这是总所周知的，那AIDL默认支持什么类型的尼？我们可不可以自定义尼？当然可以

1.默认数据类型

我们可以看一下官方文档

1.基本数据类型
2.String
3.CharSequence
4.List
5.Map
6.Parcelable(序列化)

我们新建一个aidl文件，他都会自己生成一个方法

void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);

意指的就是基础类型

然而在我们的实际测试中，你会发现他是不支持short的，我们做这样的小测试

 void basicTypes(byte b,short s, int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);

然后编译

/Users/lgl/Documents/Android/ASCode/AIDLService/app/src/main/aidl/com/lgl/aidlservice/IMyAidlInterface.aidl:11 parameter s (2) unknown type short

他报的错误就是不支持short

再比如说，你想写一个List< String>list的数据，你必须指定他是in还是out类型的

in List< String>list

2.自定义类型

这里我们先在服务端新建一个aidl文件-IMyAidlInterface，然后写入我们的方法

     //我们返回的数据是一个List集合
   List<Person>add(in Person person);

这里报错是毋庸置疑的，因为他不识别我们的Person，但是就算我们新建一个Person类也是无用的，因为aidl不支持这个类型，上面也说了，他只支持基本类型和其他有限的几种数据类型，这样的话，我们就需要自定义了，怎么来呢？让他implements Parcelable就可以

package com.lgl.aidlservice;
import android.os.Parcel;
import android.os.Parcelable;
/**
 * 序列化实体类
 * Created by lgl on 16/3/15.
 */
public class Person implements Parcelable{
    private String name;
    private int age;
    //构造方法
    public Person(String name,int age){
        this.name =name;
        this.age = age;
    }
    protected Person(Parcel in) {
        name = in.readString();
        age = in.readInt();
    }
    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;
    }
    @Override
    public int describeContents() {
        return 0;
    }
    @Override
    public void writeToParcel(Parcel parcel, int i) {
        parcel.writeString(name);
        parcel.writeInt(age);
    }
    public static final Creator<Person> CREATOR = new Creator<Person>() {
        @Override
        public Person createFromParcel(Parcel in) {
            return new Person(in);
        }
        @Override
        public Person[] newArray(int size) {
            return new Person[size];
        }
    };
}

这里值得注意的就是读写部分了，你是怎么写的就得怎么读，顺序错了就没用了，那我们编译一下，你会发现他还是提示错误，依然是位置的List数据类型

/Users/lgl/Documents/Android/ASCode/AIDLService/app/src/main/aidl/com/lgl/aidlservice/IMyAidlInterface.aidl:9 unknown return type List<Person>

这里就需要我们手动导入这个Person了不然人家也不认识啊！那要怎么做？还是需要创建一个Person的AIDL文件，内容十分的简单，说明文件

// IMyAidlInterface.aidl
package com.lgl.aidlservice;
parcelable Person;

可以看到，里面就一句话，好的，现在编译通过了，那我们重新来修改一下IRemoteService了，这次就不是返回计算数据的和了

package com.lgl.aidlservice;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import java.util.ArrayList;
import java.util.List;
/**
 *
 * 监听服务
 * Created by lgl on 16/3/13.
 */
public class IRemoteService extends Service{
    private ArrayList<Person>persons;
    /**
     * 当客户端绑定到该服务的时候启动onBind
     * @param intent
     * @return
     */
    @Override
    public IBinder onBind(Intent intent) {
        persons = new ArrayList<Person>();
        //绑定之后就计算
        return iBinder;
    }
    /**
     * 开始处理结果
     */
//    private IBinder iBinder = new ServiceAidlInterface.Stub(){
//
//        @Override
//        public int add(int num1, int num2) throws RemoteException {
//            Log.i("AIDL","收到了请求,參數1"+num1+"參數2"+num2);
//            return num1+num2;
//        }
//    };
    /**
     * 序列化
     */
    private IBinder iBinder = new IMyAidlInterface.Stub(){
        @Override
        public List<Person> add(Person person) throws RemoteException {
            //每增加一个人都能得到返回
            persons.add(person);
            return persons;
        }
    };
}

好的，服务端部分写完了，刚开始可能是有点混乱的，不过当你确实已经理解之后你会发现，也就这么点东西的逻辑，那我们继续来写客户端，看他是怎么进行序列化的处理的。

还是一样，我们把Person.aidl和IMyAidlInterface.aidl复制过去，顺便把Person类拷贝过来，这里要注意的事就是包名要一致

然后我们就开启服务了

package com.lgl.aidlclients;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import com.lgl.aidlservice.IMyAidlInterface;
import com.lgl.aidlservice.Person;
import com.lgl.aidlservice.ServiceAidlInterface;
import java.util.ArrayList;
/**
 * AIDL 客户端
 * @author lgl
 */
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    //输入
    private EditText et_num1,et_num2;
    //结果
    private TextView tv_result;
    //AIDL远程访问
    private Button btn_ok;
    private ServiceAidlInterface aidl;
    private IMyAidlInterface imy;
    private ServiceConnection conn = new ServiceConnection() {
        //连接上
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            //拿到远程服务
            aidl = ServiceAidlInterface.Stub.asInterface(iBinder);
            imy = IMyAidlInterface.Stub.asInterface(iBinder);
        }
        //断开时
        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            //回收
            aidl = null;
            imy = null;
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        bindServices();
        initView();
    }
    private void initView() {
        et_num1 = (EditText) findViewById(R.id.et_num1);
        et_num2 = (EditText) findViewById(R.id.et_num2);
        tv_result = (TextView) findViewById(R.id.tv_result);
        btn_ok = (Button) findViewById(R.id.btn_ok);
        btn_ok.setOnClickListener(this);
    }
    @Override
    public void onClick(View view) {
        switch (view.getId()){
            case R.id.btn_ok:
//                int n1 = Integer.parseInt(et_num1.getText().toString());
//                int n2 = Integer.parseInt(et_num2.getText().toString());
//
//                try {
//                    //结果
//                    int res = aidl.add(n1,n2);
//                    tv_result.setText("结果："+res);
//                } catch (RemoteException e) {
//                    e.printStackTrace();
//                    tv_result.setText("Error");
//                }
                try{
                    ArrayList<Person>persons = (ArrayList<Person>) imy.add(new Person("name",21));
                    Log.i("Person",persons.toString());
                }catch (RemoteException e){
                    e.printStackTrace();
                }
                break;
        }
    }
    /**
     * 开启服务
     */
    private void bindServices() {
        //获取服务端
        Intent intent = new Intent();
        //5.0之后的改变
        intent.setComponent(new ComponentName("com.lgl.aidlservice","com.lgl.aidlservice.IRemoteService"));
        //绑定服务
        bindService(intent,conn, Context.BIND_AUTO_CREATE);
    }
    /**
     * 销毁服务
     */
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(conn);
    }
}

这样的话，只要我们点击了计算按钮，Log打印一条消息，那事实是如此吗？我们运行一下

不会发现，我们每一次添加都是多增加了一行，相当于我们远程添加了一行

五.AIDL的工作原理

我们每次编译AIDL的文件的时候，都会编译成一个JAVA文件，具体是什么，我们一起研究研究，借用大神的一张图，你现在可能看不懂，等讲完原理你就懂了

编译好的JAVA文件在

/*
 * This file is auto-generated.  DO NOT MODIFY.
 * Original file: /Users/lgl/Documents/Android/ASCode/AIDLService/aidlclients/src/main/aidl/com/lgl/aidlservice/IMyAidlInterface.aidl
 */
package com.lgl.aidlservice;
//他是继承系统的接口，也就是说他本身就是一个接口
public interface IMyAidlInterface extends android.os.IInterface
{
/** 存根，并且实现了自己的接口*/
public static abstract class Stub extends android.os.Binder implements com.lgl.aidlservice.IMyAidlInterface
{
private static final java.lang.String DESCRIPTOR = "com.lgl.aidlservice.IMyAidlInterface";
/**自己的构造方法*/
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
 * Cast an IBinder object into an com.lgl.aidlservice.IMyAidlInterface interface,
 * generating a proxy if needed.
 */
public static com.lgl.aidlservice.IMyAidlInterface asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.lgl.aidlservice.IMyAidlInterface))) {
return ((com.lgl.aidlservice.IMyAidlInterface)iin);
}
return new com.lgl.aidlservice.IMyAidlInterface.Stub.Proxy(obj);
}
@Override public android.os.IBinder asBinder()
{
    //返回的this是Stub
return this;
}
@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
{
switch (code)
{
case INTERFACE_TRANSACTION:
{
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_add:
{
data.enforceInterface(DESCRIPTOR);
com.lgl.aidlservice.Person _arg0;
if ((0!=data.readInt())) {
    //如果拿到传过来数值封装成一个data
_arg0 = com.lgl.aidlservice.Person.CREATOR.createFromParcel(data);
}
else {
_arg0 = null;
}
java.util.List<com.lgl.aidlservice.Person> _result = this.add(_arg0);
reply.writeNoException();
    //最后通过这个又写回去了，这样就完成了整个的通讯
reply.writeTypedList(_result);
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
    //代理，他是Stud的内部类
private static class Proxy implements com.lgl.aidlservice.IMyAidlInterface
{
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote)
{
mRemote = remote;
}
@Override public android.os.IBinder asBinder()
{
return mRemote;
}
public java.lang.String getInterfaceDescriptor()
{
return DESCRIPTOR;
}
//我们返回的数据是一个List集合
@Override public java.util.List<com.lgl.aidlservice.Person> add(com.lgl.aidlservice.Person person) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.util.List<com.lgl.aidlservice.Person> _result;
try {
    //写入了类名
_data.writeInterfaceToken(DESCRIPTOR);
if ((person!=null)) {
    //写了一个1，同时add数据，当你拿到了远程服务的时候，其实你拿到的只是远程服务的代理
_data.writeInt(1);
person.writeToParcel(_data, 0);
}
else {
_data.writeInt(0);
}
    //传入到onTransact
mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);
_reply.readException();
_result = _reply.createTypedArrayList(com.lgl.aidlservice.Person.CREATOR);
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
}
static final int TRANSACTION_add = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
}
//我们返回的数据是一个List集合
//我们创建AIDL命名的这个方法
public java.util.List<com.lgl.aidlservice.Person> add(com.lgl.aidlservice.Person person) throws android.os.RemoteException;
}

Ok,AIDL这边算是讲完了，如果有兴趣的话，可以再去深入研究一下，我这边也只是学习了大神的视频，然后做的一个小总结和小笔记

Demo下载：http://download.csdn.net/detail/qq_26787115/9462515

初涉IPC，了解AIDL的工作原理及使用方法的更多相关文章

初涉IPC，了解AIDL的工作原理及用法
初涉IPC,了解AIDL的工作原理及用法今天来讲讲AIDL.这个神奇的AIDL,也是近期在学习的,看了某课大神的解说写下的blog,希望结合自己的看法给各位同价通俗易懂的解说官方文档:http:/ ...
AIDL 的工作原理
当创建AIDL文件并Clean Project 代码后,会生成相应的Java文件: 先来一段伪代码:类整体结构 /* * This file is auto-generated. DO NOT MOD ...
linux命令管道工作原理与使用方法
一.管道定义管道是一种两个进程间进行单向通信的机制.因为管道传递数据的单向性,管道又称为半双工管道.管道的这一特点决定了器使用的局限性.管道是Linux支持的最初Unix IPC形式之一,具有以下特 ...
Docker镜像提交命令commit的工作原理和使用方法
在本地创建一个容器后,可以依据这个容器创建本地镜像,并可把这个镜像推送到Docker hub中,以便在网络上下载使用. 下面我们来动手实践. docker pull nginx:1.15.3 用命令行 ...
浅析AIDL的使用和工作原理
AIDL是一种接口定义语言,用于生成可在Android设备上两个进程之间进行进程间通信(IPC)的代码. AIDL的使用新建一个aidl文件,定义进程间通信的接口 // IStudentManage ...
100天搞定机器学习|Day56 随机森林工作原理及调参实战（信用卡欺诈预测）
本文是对100天搞定机器学习|Day33-34 随机森林的补充前文对随机森林的概念.工作原理.使用方法做了简单介绍,并提供了分类和回归的实例. 本期我们重点讲一下: 1.集成学习.Bagging和随 ...
android service 的各种用法（IPC、AIDL）
http://my.oschina.net/mopidick/blog/132325 最近在学android service,感觉终于把service的各种使用场景和用到的技术整理得比较明白了,受益颇 ...
AIDL使用以及原理分析
AIDL使用以及IPC原理分析(进程间通信) 概要为了大家能够更好的理解android的进程间通信原理,以下将会从以下几个方面讲解跨进程通讯信: 1. 必要了解的概念 2. 为什么要使用aidl进程 ...
NameNode和SecondaryNameNode工作原理剖析
NameNode和SecondaryNameNode工作原理剖析作者:尹正杰版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.NameNode中的元数据是存储在那里的? 1>.首先,我 ...

随机推荐

JVM垃圾回收总结
来自Oracle官方文档,对JVM GC知识整理的清晰易懂,查资料还是看官方的好! 1 GC步骤简述步骤1:标记 (Marking) 根据对象引用关系,将未被任何对象引用的对象实例标记出来,如下图中 ...
String、StringBuffer、StringBuilder对比
1.String 用于存放字符的数组被声明为final的,因此只能赋值一次,不可再更改.这就导致每次对String的操作都会生成新的String对象,不仅效率低下,而且大量浪费有限的内存空间. Str ...
DBoW2应用
图像对应的bag-of-words向量\(v_t\) 假设词典总共有\(W\)个单词,那么每一幅图像能够用一个\(W\)维的向量表示 \((t_1, t_2, t_3, ..., t_W)\)其中 \ ...
Android开发学习之路--RxAndroid之初体验
学了一段时间android,看了部分的项目代码,然后想想老是学基础也够枯燥乏味的,那么就来学习学习新东西吧,相信很多学java的都听说过RxJava,那么android下也有RxAndroid. Rx ...
详解EBS接口开发之销售订单导入
步骤 1. 创建一个订单导入来源. - 导航到 OM -> 设置 -> 订单 -> 导入来源 - 输入一个新的订单导入来源名称和描述 - 选择启用来激活 ...
随机采样和随机模拟：吉布斯采样Gibbs Sampling实现高斯分布参数推断
http://blog.csdn.net/pipisorry/article/details/51539739 吉布斯采样的实现问题本文主要说明如何通过吉布斯采样来采样截断多维高斯分布的参数(已知一 ...
Linux之mailx的使用
mailx是UNIX系统上用来处理邮件的工具,使用它可以发送,读取邮件.下面看看如何使用它来发送邮件. 发送格式 mailx -s subject user@xxx.com < message_ ...
Android初级教程启动定时器详解
本案例知识是:后台执行定时任务. Alarm机制: 一.创建LongRunningService类 package com.example.servicebestpractice; import ja ...
Android的TabHost组件-android的学习之旅（四十）
TabHost简介虽然,官方建议用Fagment取代TabHost,但是我们还是大概的介绍一下.TabHost是一种非常简单的组件,TabHost可以很方便的在窗口放置多个标签页,每一个标签页相当于 ...
深入分析Spring混合事务
在ORM框架的事务管理器的事务内,使用JdbcTemplate执行SQL是不会纳入事务管理的. 下面进行源码分析,看为什么必须要在DataSourceTransactionManager的事务内使用J ...

初涉IPC，了解AIDL的工作原理及使用方法

初涉IPC，了解AIDL的工作原理及使用方法

一.What is AIDL?（什么是AIDL）

二.Defining an AIDL Interface(语法)

1. Create the .aidl file（创建一个.aidl文件）

三.AIDL Client And Service(客户端和服务端)

ServiceAidlInterface

2. Implement the interface（实现一个AIDL）

3. Expose the interface to clients（客户端的实现）

MainActivity(客户端)

四.AIDL数据传递

1.默认数据类型

2.自定义类型

五.AIDL的工作原理

Demo下载：http://download.csdn.net/detail/qq_26787115/9462515

初涉IPC，了解AIDL的工作原理及使用方法的更多相关文章

随机推荐

热门专题