使用AIDL实现进程间的通信之复杂类型传递

标签: descriptor string android button eclipse插件
33820人阅读 评论(20) 收藏 举报
分类:

上次讲到简单的AIDL进程间通信的操作,客户端向服务端发送一个String类型的参数,服务端也返回一个String类型的结果,看似已经可以完成基本的需要了。不过在有的时候,简单的数据类型并不能满足我们的需求,我们就需要考虑怎样向服务端传递复杂的数据类型。今天就来讲一下如何向服务端传递复杂类型的问题。

首先要了解一下AIDL对Java类型的支持。

1.AIDL支持Java原始数据类型。

2.AIDL支持String和CharSequence。

3.AIDL支持传递其他AIDL接口,但你引用的每个AIDL接口都需要一个import语句,即使位于同一个包中。

4.AIDL支持传递实现了android.os.Parcelable接口的复杂类型,同样在引用这些类型时也需要import语句。(Parcelable接口告诉Android运行时在封送(marshalling)和解封送(unmarshalling)过程中实现如何序列化和反序列化对象,你可以很容易联想到java.io.Serializable接口。有些朋友可能会有疑问,两种接口功能确实类似,但为什么Android不用内置的Java序列化机制,而偏偏要搞一套新东西呢?这是因为Android团队认为Java中的序列化太慢,难以满足Android的进程间通信需求,所以他们构建了Parcelable解决方案。Parcelable要求显示序列化类的成员,但最终序列化对象的速度将快很多。另外要注意的是,Android提供了两种机制来将数据传递给另一个进程,第一种是使用Intent将数据束(Bundle)传递给活动,第二种也就是Parcelable传递给服务。这两种机制不可互换,不要混淆。也就是说,Parcelable无法传递给活动,只能用作AIDL定义的一部分)。

5.AIDL支持java.util.List和java.util.Map,但是有一些限制。集合中项的允许数据类型包括Java原始类型、String、CharSequence或是android.os.Parcelable。无需为List和Map提供import语句,但需要为Parcelable提供import语句。

6.非原始类型中,除了String和CharSequence以外,其余均需要一个方向指示符。方向指示符包括in、out、和inout。in表示由客户端设置,out表示由服务端设置,inout表示客户端和服务端都设置了该值。

接下来就演示一下具体的流程:

我们先看一下服务端的结构:

其中,Person类是我们要在服务端和客户端中间进行传递的类型,代码如下:

package com.scott.aidl;

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

public class Person implements Parcelable {

    private String name;
    private int sex;

    //必须提供一个名为CREATOR的static final属性 该属性需要实现android.os.Parcelable.Creator<T>接口
    public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() {

        @Override
        public Person createFromParcel(Parcel source) {
            return new Person(source);
        }

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

    public Person() {

    }

    private Person(Parcel source) {
        readFromParcel(source);
    }

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

    //注意写入变量和读取变量的顺序应该一致 不然得不到正确的结果
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(sex);
    }

    //注意读取变量和写入变量的顺序应该一致 不然得不到正确的结果
    public void readFromParcel(Parcel source) {
        name = source.readString();
        sex = source.readInt();
    }

    public String getName() {
        return name;
    }

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

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

}
然后我们需要在同一包下建立一个与包含复杂类型的Person.java文件匹配的Person.aidl文件,代码如下:

package com.scott.aidl;
parcelable Person;
这个Person.aidl文件很简单,就是定义了一个Parcelable类,告诉系统我们需要序列化和反序列化的类型。每一个实现了Parcelable的类型都需要对应的.aidl文件。AIDL编译器在编译AIDL文件时会自动查找此类文件。

接下来,我们需要创建一个IGreetService.aidl文件,以接收类型为Person的输入参数,以便客户端可以将Person传递给服务。

package com.scott.aidl;
import com.scott.aidl.Person;

interface IGreetService {
    String greet(in Person person);
}
注意,我们需要在参数上加入方向指示符in,代表参数由客户端设置,我们还需要为Person提供一个import语句(虽然说在同一个包下)。

此时,在eclipse插件的帮助下,AIDL编译器会自动编译生成一个IGreetService.java文件,格式化后的代码如下:

package com.scott.aidl;

public interface IGreetService extends android.os.IInterface {
    /** Local-side IPC implementation stub class. */
    public static abstract class Stub extends android.os.Binder implements com.scott.aidl.IGreetService {
        private static final java.lang.String DESCRIPTOR = "com.scott.aidl.IGreetService";

        /** Construct the stub at attach it to the interface. */
        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }

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

        public android.os.IBinder asBinder() {
            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_greet: {
                    data.enforceInterface(DESCRIPTOR);
                    com.scott.aidl.Person _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.scott.aidl.Person.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    java.lang.String _result = this.greet(_arg0);
                    reply.writeNoException();
                    reply.writeString(_result);
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

        private static class Proxy implements com.scott.aidl.IGreetService {
            private android.os.IBinder mRemote;

            Proxy(android.os.IBinder remote) {
                mRemote = remote;
            }

            public android.os.IBinder asBinder() {
                return mRemote;
            }

            public java.lang.String getInterfaceDescriptor() {
                return DESCRIPTOR;
            }

            public java.lang.String greet(com.scott.aidl.Person person) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                java.lang.String _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    if ((person != null)) {
                        _data.writeInt(1);
                        person.writeToParcel(_data, 0);
                    } else {
                        _data.writeInt(0);
                    }
                    mRemote.transact(Stub.TRANSACTION_greet, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.readString();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }
        }

        static final int TRANSACTION_greet = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    }

    public java.lang.String greet(com.scott.aidl.Person person) throws android.os.RemoteException;
}
该文件的大纲视图如下:

接下来,就该完成我们的AIDLService逻辑部分了,AIDLService.java代码如下:

package com.scott.server;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;

import com.scott.aidl.IGreetService;
import com.scott.aidl.Person;

public class AIDLService extends Service {

    private static final String TAG = "AIDLService";

    IGreetService.Stub stub = new IGreetService.Stub() {
        @Override
        public String greet(Person person) throws RemoteException {
            Log.i(TAG, "greet(Person person) called");

            String greeting = "hello, " + person.getName();
            switch (person.getSex()) {
                case 0:
                    greeting = greeting + ", you're handsome.";
                    break;
                case 1:
                    greeting = greeting + ", you're beautiful.";
                    break;
            }
            return greeting;
        }
    };

    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG, "onBind() called");
        return stub;
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.i(TAG, "onUnbind() called");
        return true;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.i(TAG, "onDestroy() called");
    }
}
最后,在AndroidManifest.xml中配置该服务:

<service android:name=".AIDLService">
    <intent-filter>
        <action android:name="android.intent.action.AIDLService" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</service>
服务端就已经完成了。接下来我们来看一下客户端的结构:

我们需要把服务端的Person.java、Person.aidl和IGreetService.aidl拷到对应的包下。我们主要来看看MainActivity.java代码:

package com.scott.client;

import android.app.Activity;
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.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import com.scott.aidl.IGreetService;
import com.scott.aidl.Person;

public class MainActivity extends Activity {

    private Button bindBtn;
    private Button greetBtn;
    private Button unbindBtn;

    private IGreetService greetService;
    private ServiceConnection conn = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.i("ServiceConnection", "onServiceConnected() called");
            greetService = IGreetService.Stub.asInterface(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            //This is called when the connection with the service has been unexpectedly disconnected,
            //that is, its process crashed. Because it is running in our same process, we should never see this happen.
            Log.i("ServiceConnection", "onServiceDisconnected() called");
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        bindBtn = (Button) findViewById(R.id.bindBtn);
        bindBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent("android.intent.action.AIDLService");
                bindService(intent, conn, Context.BIND_AUTO_CREATE);

                bindBtn.setEnabled(false);
                greetBtn.setEnabled(true);
                unbindBtn.setEnabled(true);
            }
        });

        greetBtn = (Button) findViewById(R.id.greetBtn);
        greetBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    Person person = new Person();
                    person.setName("scott");
                    person.setSex(0);
                    String retVal = greetService.greet(person);
                    Toast.makeText(MainActivity.this, retVal, Toast.LENGTH_SHORT).show();
                } catch (RemoteException e) {
                    Toast.makeText(MainActivity.this, "error", Toast.LENGTH_SHORT).show();
                }
            }
        });

        unbindBtn = (Button) findViewById(R.id.unbindBtn);
        unbindBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                unbindService(conn);

                bindBtn.setEnabled(true);
                greetBtn.setEnabled(false);
                unbindBtn.setEnabled(false);
            }
        });
    }
}
通过这种方式,就可以将Person类型的对象传递到服务端,实现复杂类型的通信传递。

当点击greetBtn时,截图如下:

然后看一下整个过程的日志信息。点击bindBtn、greetBtn、unbindBtn的整个过程日志如下:

查看评论

Android进程间通信之----Aidl传递对象

转载请注明出处 CSDN废墟的树前言有关Android进程间通信之Aidl编程的基本使用步骤已经在上一篇博客中有讲解,Android studio 下的aidl编程实现Android的夸进程间通信。上...
  • feidu804677682
  • feidu804677682
  • 2016-05-13 10:54:04
  • 10550

android之Service介绍之三 AIDL与传递对象

除了上一篇文章我们提到的通过service提供音乐播放等类似的服务之外,我们还可以通过service将对象传递回来哦,你知道怎么用吗,先看例子:当我们点击“获取”时,会从另一个线程的service中获...
  • chenzheng_java
  • chenzheng_java
  • 2011-03-18 23:27:00
  • 10733

android studio下使用aidl接口传递自定义对象

  • 2016年01月12日 13:30
  • 4.92MB
  • 下载

关于AIDL中Map参数传递的问题

aidl中map参数传递时引发的问题
  • flyfreeme
  • flyfreeme
  • 2017-12-11 10:39:05
  • 556

关于AIDL一些需要注意的地方

1、从远程客户端进程来的调用是由不同的线程发起的,运行在不同的进程。所以,服务端必须处理好在同一时刻有多个从不同线程过来的请求的情况。也就是说,一个AIDL的实现必须是完成线程安全的,必须手动处理多线...
  • liuyi1207164339
  • liuyi1207164339
  • 2016-06-19 13:53:25
  • 5167

AIDL 2 之 传递复杂数据的AIDL服务

AIDL 服务只支持有限的数据类型,如果用AIDL服务传递一些复杂的数据就需要做更一步处理,  AIDL 服务支持的数据类型如下: 1. Java 的原生类型 2. String 和CharSeque...
  • aduovip
  • aduovip
  • 2011-08-20 01:59:55
  • 5201

【Android】使用AIDL传递用户自定义类型数据--附完整示例代码

AIDL对Java类型的支持 AIDL支持Java原始数据类型 AIDL支持String和CharSequence AIDL支持传递其他AIDL接口,但你引用的每个AIDL接口都需要...
  • Sugar_Z_
  • Sugar_Z_
  • 2015-10-24 12:39:22
  • 3511

Aidl实现的一个例子

AIDL 与 Messenger的异同 对于跨进程的调用 AIDL返回值是同步的,而Messenger是异步的。Aidl调用service的方法,会等待直到service中的方...
  • time_hunter
  • time_hunter
  • 2016-11-20 18:54:27
  • 954

Android中AIDL的基本用法

转载自:http://flrito.cc/notes-androidzhong-aidlde-ji-ben-yong-fa/ 早些时候就听说过AIDL,也常在各种Android面试题、教程甚至大...
  • fwt336
  • fwt336
  • 2016-09-19 16:57:09
  • 7783

android 进程通信之aidl 自定义数据类型

android 进程通信之aidl 自定义数据类型
  • wuxintdrh
  • wuxintdrh
  • 2016-07-20 17:14:52
  • 913
    个人资料
    持之以恒
    等级:
    访问量: 332万+
    积分: 1万+
    排名: 1743
    友情提示
    博客中的Android系列文章,是在2011年左右完成的,由于近年来Android版本变化等因素,结果可能会有些出入,请大家结合实际情况作参考。
    最新评论