android跨进程通信(IPC):使用AIDL

标签: android 进程 通信 | 发表时间:2013-12-01 07:20 | 作者:singwhatiwanna
出处:http://blog.csdn.net

AIDL的作用

AIDL (Android Interface Definition Language) 是一种IDL 语言,用于生成可以在Android设备上两个进程之间进行进程间通信(interprocess communication, IPC)的代码。如果在一个进程中(例如Activity)要调用另一个进程中(例如Service)对象的操作,就可以使用AIDL生成可序列化的参数。
AIDL IPC机制是面向接口的,像COM或Corba一样,但是更加轻量级。它是使用代理类在客户端和实现端传递数据。

选择AIDL的使用场合

官方文档特别提醒我们何时使用AIDL是必要的:只有你允许客户端从不同的应用程序为了进程间的通信而去访问你的service,以及想在你的service处理多线程。如果不需要进行不同应用程序间的并发通信(IPC),you should create your interface by implementing a Binder;或者你想进行IPC,但不需要处理多线程的,则implement your interface using a Messenger。无论如何,在使用AIDL前,必须要理解如何绑定service——bindService。如何绑定服务,请参考我的另一篇文章: http://blog.csdn.net/singwhatiwanna/article/details/9058143。这里先假设你已经了解如何使用bindService。

如何使用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代码如下:
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进来。
另外,接口中的参数必须标识其类型:到底是输入还是输出抑或两者兼之,用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代码如下:
package com.ryg.sayhi.aidl;

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

Student.java代码如下:
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,代码如下:
/**
 * @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(), "BackgroundSercie");
        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

        <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的代码就比较简单了,如下:
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();
    }
}

运行效果

可以看到,当点击按钮1的时候,客户端bindService到服务端apk,并且调用服务端的接口mIMyService.getStudent()来获取学生列表,并且把返回列表中第一个学生的信息显示出来,这就是整个ipc过程,需要注意的是:学生列表是另一个apk中的数据,通过aidl,我们才得到的。另外,如果你在onTransact中返回false,将会发现,获取的学生列表是空的,这意味着方法调用失败了,也就是实现了权限认证。

作者:singwhatiwanna 发表于2013-11-30 23:20:52 原文链接
阅读:92 评论:0 查看评论

相关 [android 进程 通信] 推荐:

Android 进程间通信

- - SegmentFault 最新的文章
单例居然失效了,一个地方设置值,另个地方居然取不到,这怎么可能. 排查半天,发现这两就不在一个进程里,才恍然大悟……. 按照操作系统中的描述:进程一般指一个执行单元,在 PC 和移动设备上指一个程序或者一个应用. 我们都知道,系统为 APP 每个进程分配的内存是有限的,如果想获取更多内存分配,可以使用多进程,将一些看不见的服务、比较独立而又相当占用内存的功能运行在另外一个进程当中.

android跨进程通信(IPC):使用AIDL

- - CSDN博客移动开发推荐文章
AIDL (Android Interface Definition Language) 是一种IDL 语言,用于生成可以在Android设备上两个进程之间进行进程间通信(interprocess communication, IPC)的代码. 如果在一个进程中(例如Activity)要调用另一个进程中(例如Service)对象的操作,就可以使用AIDL生成可序列化的参数.

android 进程间通信方式

- - 移动开发 - ITeye博客
由于android系统中应用程序之间不能共享内存. 因此,在不同应用程序之间交互数据(跨进程通讯)就稍微麻烦一些. 在android SDK中提供了4种用于跨进程通讯的方式. 这4种方式正好对应于android系统中4种应用程序组件:Activity、Content Provider、Broadcast和Service.

Android之网络通信

- - 博客园_首页
由于一个项目的需要,我研究了一下android的网络通信方式,大体和java平台的很相似. android平台也提供了很多的API供开发者使用,请按示例图:. 首先,介绍一下通过http包工具进行通信,分get和post两种方式,两者的区别是:. 1,post请求发送数据到服务器端,而且数据放在html header中一起发送到服务器url,数据对用户不可见,get请求是把参数值加到url的队列中,这在一定程度上,体现出post的安全性要比get高.

Android Activity与Service通信

- - CSDN博客移动开发推荐文章
一、当Acitivity和Service处于同一个Application和进程时,通过继承Binder类来实现.      当一个Activity绑定到一个Service上时,它负责维护Service实例的引用,允许你对正在运行的Service进行一些方法调用. 比如你后台有一个播放背景音乐的Service,这时就可以用这种方式来进行通信.

Android中的跨进程回调

- - CSDN博客移动开发推荐文章
在Android应用程序开发中,可能会遇到跨进程回调问题,比如,调用一个服务,但服务是异步的,服务完成后,需要给客户一个通知,这时就需要用到跨进程回调了. 跨进程回调本质上用到了Binder机制,其过程如下:. 2.Service定义如下:. 在以上代码中ITestListener为跨进程回调接口.

Android 进程回收之LowMemoryKiller原理篇

- - CSDN博客移动开发推荐文章
在前面的文章 Android进程保活一文中,对于LowMemoryKiller的概念做了简单的提及. LowMemoryKiller简称低内存杀死机制. 在讲解LowMemoryKiller之前,先看另一个概念:OOMKiller. Linux下有一种OOM KILLER 的机制,它会在系统内存耗尽的情况下,启用自己算法有选择性的kill 掉一些进程.

进程间的通信方式

- - 行业应用 - ITeye博客
管道(pipe):管道是一种半双工的通信方式,数据只能单向流动,而且只能在具有亲缘关系的进程间使用. (进程间的亲缘关系指父子进程关系). 有名管道(named pipe):有名管道也是半双工的通信方式,但是它允许无亲缘关系进程间通信. 信号量(semophore):信号量是一个计数器,可以用来控制多个进程对共享资源的访问.

进程间通信(IPC):共享内存

- - CSDN博客推荐文章
共享内存允许两个不相关的进程访问同一个逻辑内存. 第一个程序创建一个共享内存段,然后把写到它里面的数据都显示出来. 第二个程序将连接一个已有的共享内存段,并允许我们向其中输入数据. After the headers the shared memory segment (the size of our shared memory structure) is created with a call to shmget, with the IPC_CREAT bit specified.

Android之父抨击苹果Siri:手机只是通信工具

- 品味视界 - cnBeta.COM
有“Android之父”之称Google移动业务高级副总裁安迪・鲁宾(Andy Rubin)在参加Asia D大会时表示,手机应当是一个通信工具,自己并不赞同苹果Siri语音个人助理的理念. 鲁宾表示,手机是用来与真正的同伴通讯的工具,并不是用户的伴侣. 他说:“我认为手机是一种通信工具,而不应当是个人助理.