Android（java）学习笔记175：Android进程间通讯（IPC）之AIDL

一、IPC

inter process communication  进程间通讯

二、AIDL

android  interface  defination  language  安卓接口定义语言

满足两个进程之间  接口数据的交换（ipc）

首先我们搞清楚两个概念  远程服务和本地服务 ？

           本地服务：服务的代码在应用程序工程的内部

           远程服务：服务的代码在另一个应用程序的里面

三、下面通过案例说明AIDL（IPC）在远程服务中使用

1.首先创建一个Android项目，命名为"远程服务"；

（1）工程一栏表如下：

（2）既然是远程服务，我们就先创建远程服务为RemoteServiceDemo.java，同时也需要在AndroidMainfest.xml的清单文件中注册，如下：

AndroidMainfest.xml：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.himi.remoteservice"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="15"
        android:targetSdkVersion="17" />

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <service android:name="com.himi.remoteservice.RemoteServiceDemo">
            <intent-filter >
                <action android:name="com.himi.remoteservice"/>
            </intent-filter>
        </service>
    </application>

</manifest>

这里我们定义了service的action，这是因为倘若应用程序自己调用服务，直接使用显式意图即可，也就是如下这种形式：

Intent intent = new Intent(this，Service.class)；

startActivity(intent)；

但是，我们这里是自己定义的远程服务程序，也就是这个程序在远程，让本地（或者其他用户）去调用的，所以这里使用了隐式意图。

与此同时，我们编写RemoteServiceDemo.java代码如下：

package com.himi.remoteservice;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;

public class RemoteServiceDemo extends Service {
    
    private class MyBinder extends Binder implements IService {

        public void callMethodInService() {
            methodInservice();
            
        }
        
    }

    @Override
    public IBinder onBind(Intent intent) {
        System.out.println("远程的服务被绑定 onBind");
        return new MyBinder();
    }

    @Override
    public boolean onUnbind(Intent intent) {
        System.out.println("远程的服务被解除绑定 onUnbind");
        return super.onUnbind(intent);
    }
    
    @Override
    public void onCreate() {
        System.out.println("远程的服务onCreate");
        super.onCreate();
    } 
    
    @Override
    public void onDestroy() {
        System.out.println("远程的服务onDestroy");
        super.onDestroy();
    }
    
    public void methodInservice() {
        System.out.println("我是远程服务里面的方法，我被调用了");
    }
}

这里我们定义的methodInservice（），是远程服务中的方法，这也是本地用户（或者其他用户）希望调用和访问的方法。

现在我们的需求，就是可以由别的用户程序调用这个methodInservice（）方法。

上面接口IService.java为如下：

package com.himi.remoteservice;

public interface IService {

    public void callMethodInService();
}

（3）其他的MainActivity和activity_main布局文件我们这里没有修改

（4）这样一个远程的服务就搭建好了

工程一览表如下：

2.接下来我们再新建一个Android项目，命名为" 调用远程服务的方法 "，如下：

（1）项目一览表：

（2）先编写布局文件activity_main.xml，如下：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.himi.remotecall.MainActivity" >

    <Button
        android:onClick="bind"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="绑定远程服务" />
     <Button
        android:onClick="call"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="调用远程服务方法" />

</LinearLayout>

布局效果如下：

（3）实现一下MainActivity里面的代码，如下：

package com.himi.remotecall;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.view.View;

public class MainActivity extends Activity {
    private MyConn conn;

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

    /**
     * 绑定远程服务
     * @param view
     */
    public void bind(View view) {
        Intent service = new Intent();
        service.setAction("com.himi.remoteservice");
        conn = new MyConn();
        bindService(service, conn, BIND_AUTO_CREATE);
    }
    
    private class MyConn implements ServiceConnection {

        public void onServiceConnected(ComponentName name, IBinder service) {
            
        }

        public void onServiceDisconnected(ComponentName name) {

        }
        
    }
    
    public void call(View view) {
        
    }
}

这个客户端访问远程服务的框架，我们搭建好了；

但是我们不能访问远端的服务方法，因为这里的

public void onServiceConnected(ComponentName name, IBinder service)，这个方法是绑定服务成功的时候调用的，Service.java会反馈一个IBinder service的信息，但是我们这里并不像远程服务那样，具备这个IService的接口，通过接口类型转化，也就是如下：

 IService iService = （IService）service；

 iService.callMethodInService();

现在不能这样调用methodInservice（）方法，因为根本就不能接收到 IBinder service

所以不能调用远程服务的methodInservice()方法。

3.该怎么办？如何调用远程服务方法？这里要利用到AIDL（IPC）

（1）第一步，我们回到"远程服务”的项目，如下：

IService.java文件在工程目录下的路径，如下：

找到这个路径如下：

看到上面的IService.java文件了，这里我们修改它的扩展名，由java 改成 aidl，如下：

回到"远程服务"这个工程，刷新它，结果如下：

这会我们发现这里的IService.java变成了IService.aidl，但是报错了，不用担心我们慢慢修改错误；

（2）来到IService.aidl文件下，如下：

aidl作为两个进程之间的接口，当然是共有的，不是共有的无法互相通信了，这里aidl中没有权限修饰符，所以删除上下两个public，结果如下：

现在IService.aidl文件也就不报错了；

（3）接着，我们来到RemoteServiceDemo.java如下：

修改成如下形式，即可：

为什么这样修改？

相应我们在gen目录下，生成一个IService.java,如下：

因为IService.Stub在gen目录下生成的IService.java的实现了接口com.himi.remoteservice.IService，同时继承了android.os.Binder，如下：

/*
 * This file is auto-generated.  DO NOT MODIFY.
 * Original file: C:\Users\Administrator.GDIZOK2X2LA0SQG\workspace\远程服务\src\com\himi\remoteservice\IService.aidl
 */
package com.himi.remoteservice;
public interface IService extends android.os.IInterface
{
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.himi.remoteservice.IService
{
private static final java.lang.String DESCRIPTOR = "com.himi.remoteservice.IService";
/** Construct the stub at attach it to the interface. */
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
 * Cast an IBinder object into an com.himi.remoteservice.IService interface,
 * generating a proxy if needed.
 */
public static com.himi.remoteservice.IService asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.himi.remoteservice.IService))) {
return ((com.himi.remoteservice.IService)iin);
}
return new com.himi.remoteservice.IService.Stub.Proxy(obj);
}
@Override 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_callMethodInService:
{
data.enforceInterface(DESCRIPTOR);
this.callMethodInService();
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.himi.remoteservice.IService
{
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;
}
@Override public void callMethodInService() throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_callMethodInService, _data, _reply, 0);
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_callMethodInService = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
}
public void callMethodInService() throws android.os.RemoteException;
}

（4）这样"远端服务"，我们就修改好了，如下洁白无瑕：

4. 接着回到"调用远程服务的方法”这个项目下:

（1）在src目录下，创建一个包名，这个包名要  和 远程服务下的RemoteServiceDemo.java的包名一致， 这里都是com.himi.remoteservice,如下：

（2）把工程"远程服务"中的IService.aidl   复制到  工程”调用远程服务的方法"的src/com.himi.remoteservice，如下：

工程”调用远程服务的方法"的gen目录下也生成了IService.java

（3）回到工程”调用远程服务的方法"的MainActivity，编写代码如下：

package com.himi.remotecall;

import com.himi.remoteservice.IService;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.view.View;

public class MainActivity extends Activity {
    private MyConn conn;
    private IService iservice;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    /**
     * 绑定远程服务
     * @param view
     */
    public void bind(View view) {
        Intent service = new Intent();
        service.setAction("com.himi.remoteservice");
        conn = new MyConn();
        bindService(service, conn, BIND_AUTO_CREATE);
    }
    
    private class MyConn implements ServiceConnection {

        public void onServiceConnected(ComponentName name, IBinder service) {
            iservice = IService.Stub.asInterface(service);
        }

        public void onServiceDisconnected(ComponentName name) {

        }
        
    }
    
    public void call(View view) {
        try {
            iservice.callMethodInService();
        } catch (RemoteException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
    }
}

（4）布署程序到模拟器上演示：

首先布署"远端服务" 到模拟器上，如下：

最小化 "远程服务", 然后布署" 调用远程服务的方法"到模拟器上，如下：

接下我们点击  按钮----绑定远程服务 ，观察logcat打印的日志，如下：

这两条日志是 工程"远程服务"中的RemoteServiceDemo中打印的；

我们再点击多次这个  按钮----调用远程服务的方法  ，在观察logcat打印的日志，如下：

这两条日志是 工程"调用远程服务的方法"中的MainActivity中call点击事件，调用工程“远程服务”中RemoteServiceDemo的methodInservice（）方法打印的；如下：

四、使用 AIDL 远程服务绑定调用的步骤：

 （1）采用bind的方法绑定开启服务。

　　Intent intent = new Intent（）；//隐式的意图

      intent.setAction("action")；
　　bindService(intent， conn， BIND_AUTO_CREATE)；

 （2）  .java的接口文件改成.aidl文件，删除public 访问修饰符。

 （3） 在工程目录gen目录下会自动编译生成IService.java的接口文件

      生成的IService.java，是通过aidl文件生成的。服务的中间人想暴露什么方法,就怎么定义接口

 （4）  远程服务代码为private class MyBinder extends  IService.Stub

       同时在返回代理人对象，如下：

       public IBinder onBind（Intent intent）{……}  

 （5）实现ServiceConnection接口里面的方法

　　private class MyConn implements ServiceConnection{
　　　　@Override
　　　　public void onServiceConnected(ComponentName name, IBinder service) {
　　　　　　IService.Sub.asInterface(service);
　　　　　　System.out.println("Activity,得到代理人对象");
　　　　}

　　注意：iService = IService.Stub.asInterface（service）

 （6）  iService.callMethodInService（）；