Android IPC之AIDL

最新推荐文章于 2020-01-18 10:43:39 发布

milotian

最新推荐文章于 2020-01-18 10:43:39 发布

阅读量705

点赞数

分类专栏： Android IPC

本文链接：https://blog.csdn.net/tianmi1988/article/details/50135371

版权

Android IPC 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

在Android中，如果我们需要在不同进程间实现通信，有很多种方式，其中最普通的方式就是AIDL。

AIDL（Android Interface Definition Language）是一种接口定义语言，编译器通过*.aidl文件的描述信息生成符合通信协议的Java代码，我们无需自己去写这段繁杂的代码，只需要在需要的时候调用即可，通过这种方式我们就可以完成进程间的通信工作。本文Demo为Android开发艺术探索的例子，姑且当做学习笔记记录下AIDL的基本用法。废话不说，先上干货。

1.准备好AIDL文件

IBookManager.aidl

package com.ryg.chapter_2.aidl;

import com.ryg.chapter_2.aidl.Book;
import com.ryg.chapter_2.aidl.IOnNewBookArrivedListener;

interface IBookManager {
     List<Book> getBookList();
     void addBook(in Book book);
     void registerListener(IOnNewBookArrivedListener listener);
     void unregisterListener(IOnNewBookArrivedListener listener);
}

由于AIDL文件包含自定义类Book，所以要添加一个Book类的声明文件，很简单一行代码搞定

Book.aidl

package com.ryg.chapter_2.aidl;

parcelable Book;

如果你打开了Eclipse的自动编译功能就可以看到gen目录下面自动生成了对应的java文件

2.自定义服务类

BookManagerService.java

package com.ryg.chapter_2.aidl;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicBoolean;

import android.app.Service;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Binder;
import android.os.IBinder;
import android.os.Parcel;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.os.SystemClock;
import android.util.Log;

public class BookManagerService extends Service {

    private static final String TAG = "BMS";

    private AtomicBoolean mIsServiceDestoryed = new AtomicBoolean(false);

    private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<Book>();
    // private CopyOnWriteArrayList<IOnNewBookArrivedListener> mListenerList =
    // new CopyOnWriteArrayList<IOnNewBookArrivedListener>();

    private RemoteCallbackList<IOnNewBookArrivedListener> mListenerList = new RemoteCallbackList<IOnNewBookArrivedListener>();

    private Binder mBinder = new IBookManager.Stub() {

        @Override
        public List<Book> getBookList() throws RemoteException {
            SystemClock.sleep(5000);
            return mBookList;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            mBookList.add(book);
        }

        public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
                throws RemoteException {
            int check = checkCallingOrSelfPermission("com.ryg.chapter_2.permission.ACCESS_BOOK_SERVICE");
            Log.d(TAG, "check=" + check);
            if (check == PackageManager.PERMISSION_DENIED) {
                return false;
            }

            String packageName = null;
            String[] packages = getPackageManager().getPackagesForUid(
                    getCallingUid());
            if (packages != null && packages.length > 0) {
                packageName = packages[0];
            }
            Log.d(TAG, "onTransact: " + packageName);
            if (!packageName.startsWith("com.ryg")) {
                return false;
            }

            return super.onTransact(code, data, reply, flags);
        }

        @Override
        public void registerListener(IOnNewBookArrivedListener listener)
                throws RemoteException {
            mListenerList.register(listener);

            final int N = mListenerList.beginBroadcast();
            mListenerList.finishBroadcast();
            Log.d(TAG, "registerListener, current size:" + N);
        }

        @Override
        public void unregisterListener(IOnNewBookArrivedListener listener)
                throws RemoteException {
            boolean success = mListenerList.unregister(listener);

            if (success) {
                Log.d(TAG, "unregister success.");
            } else {
                Log.d(TAG, "not found, can not unregister.");
            }
            final int N = mListenerList.beginBroadcast();
            mListenerList.finishBroadcast();
            Log.d(TAG, "unregisterListener, current size:" + N);
        };

    };

    @Override
    public void onCreate() {
        super.onCreate();
        mBookList.add(new Book(1, "Android"));
        mBookList.add(new Book(2, "Ios"));
        new Thread(new ServiceWorker()).start();
    }

    @Override
    public IBinder onBind(Intent intent) {
        int check = checkCallingOrSelfPermission("com.ryg.chapter_2.permission.ACCESS_BOOK_SERVICE");
        Log.d(TAG, "onbind check=" + check);
        if (check == PackageManager.PERMISSION_DENIED) {
            return null;
        }
        return mBinder;
    }

    @Override
    public void onDestroy() {
        mIsServiceDestoryed.set(true);
        super.onDestroy();
    }

    private void onNewBookArrived(Book book) throws RemoteException {
        mBookList.add(book);
        final int N = mListenerList.beginBroadcast();
        for (int i = 0; i < N; i++) {
            IOnNewBookArrivedListener l = mListenerList.getBroadcastItem(i);
            if (l != null) {
                try {
                    l.onNewBookArrived(book);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
        mListenerList.finishBroadcast();
    }

    private class ServiceWorker implements Runnable {
        @Override
        public void run() {
            // do background processing here.....
            while (!mIsServiceDestoryed.get()) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                int bookId = mBookList.size() + 1;
                Book newBook = new Book(bookId, "new book#" + bookId);
                try {
                    onNewBookArrived(newBook);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

这个类有点长，其实不太适合作为介绍AIDL的入门用法，我们只看其中的关键方法，用伪代码表示为

    @Override
    public IBinder onBind(Intent intent) {
       
        return new IBookManager.Stub() {

        @Override
        public List<Book> getBookList() throws RemoteException {
           // Todo
            return null;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            //Todo
        };
    }

本质就是重写父类service的onBind方法，返回AIDL文件生成的interface对应的Stub()方法。服务器端的Service就是这么简单。

3.客户端调用

BookManagerActivity.java

package com.ryg.chapter_2.aidl;

import java.util.List;
import com.ryg.chapter_2.R;
import com.ryg.chapter_2.aidl.IBookManager;
import com.ryg.chapter_2.utils.MyConstants;
import android.annotation.SuppressLint;
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.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;
import android.widget.Toast;

public class BookManagerActivity extends Activity {

    private static final String TAG = "BookManagerActivity";
    private static final int MESSAGE_NEW_BOOK_ARRIVED = 1;

    private IBookManager mRemoteBookManager;

    @SuppressLint("HandlerLeak")
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MESSAGE_NEW_BOOK_ARRIVED:
                Log.d(TAG, "receive new book :" + msg.obj);
                break;
            default:
                super.handleMessage(msg);
            }
        }
    };

    private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
        @Override
        public void binderDied() {
            Log.d(TAG, "binder died. tname:" + Thread.currentThread().getName());
            if (mRemoteBookManager == null)
                return;
            mRemoteBookManager.asBinder().unlinkToDeath(mDeathRecipient, 0);
            mRemoteBookManager = null;
            // TODO:这里重新绑定远程Service
        }
    };

    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            IBookManager bookManager = IBookManager.Stub.asInterface(service);
            mRemoteBookManager = bookManager;
            try {
                mRemoteBookManager.asBinder().linkToDeath(mDeathRecipient, 0);
                List<Book> list = bookManager.getBookList();
                Log.i(TAG, "query book list, list type:"
                        + list.getClass().getCanonicalName());
                Log.i(TAG, "query book list:" + list.toString());
                Book newBook = new Book(3, "Android进阶");
                bookManager.addBook(newBook);
                Log.i(TAG, "add book:" + newBook);
                List<Book> newList = bookManager.getBookList();
                Log.i(TAG, "query book list:" + newList.toString());
                bookManager.registerListener(mOnNewBookArrivedListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        public void onServiceDisconnected(ComponentName className) {
            mRemoteBookManager = null;
            Log.d(TAG, "onServiceDisconnected. tname:" + Thread.currentThread().getName());
        }
    };

    private IOnNewBookArrivedListener mOnNewBookArrivedListener = new IOnNewBookArrivedListener.Stub() {

        @Override
        public void onNewBookArrived(Book newBook) throws RemoteException {
            mHandler.obtainMessage(MESSAGE_NEW_BOOK_ARRIVED, newBook)
                    .sendToTarget();
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_book_manager);
        Intent intent = new Intent(this, BookManagerService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

    public void onButton1Click(View view) {
        Toast.makeText(this, "click button1", Toast.LENGTH_SHORT).show();
        new Thread(new Runnable() {

            @Override
            public void run() {
                if (mRemoteBookManager != null) {
                    try {
                        List<Book> newList = mRemoteBookManager.getBookList();
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

    @Override
    protected void onDestroy() {
        if (mRemoteBookManager != null
                && mRemoteBookManager.asBinder().isBinderAlive()) {
            try {
                Log.i(TAG, "unregister listener:" + mOnNewBookArrivedListener);
                mRemoteBookManager
                        .unregisterListener(mOnNewBookArrivedListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        unbindService(mConnection);
        super.onDestroy();
    }

}

跟服务器端一样，我们主要看核心部分

 private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            IBookManager bookManager = IBookManager.Stub.asInterface(service);
            //bookManager.addBook(book)
            //bookManager.getBookList()
        }

        public void onServiceDisconnected(ComponentName className) {
            mRemoteBookManager = null;
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_book_manager);
        Intent intent = new Intent(this, BookManagerService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

 protected void onDestroy() {
            ...
        unbindService(mConnection);
        super.onDestroy();
    }

在客户端Activity中OnCreate方法中bindService,onDestory中unbindService

请注意该interface 中的onServiceConnected()方法的第二个变量Service。当客户端请求AmS 启动某个Service 后，该Service 如果正常启动，那么AmS 就会远程调用ActivityThread 类中的ApplicationThread对象，调用的参数中会包含Service 的Binder 引用，然后在ApplicationThread 中会回调bindService 中的conn 接口。因此，在客户端中，可以在onServiceConnected()方法中将其参数Service 保存为一个全局变量，从而在客户端的任何地方都可以随时调用该远程服务。

有几点需要注意的

1.本Demo服务器端客户端在同一个应用中，所以可以直接用显式Intent作为bindService的第一个参数，如果客服端服务器端在不同的应用，客户端AIDL文件要跟客户端保持一致，可以用隐式Intent作为bindService的第一个参数。

2.本应用虽然在一个应用中，通过process：remote配置Service在另外的进程中，所以跟两个应用跨进程IPC调用是一样的效果。

3.如果服务器端和客户端在同一个进程，则不会调用AIDL文件对应Interface中实现的onTransact方法，直接调用对应实现方法。否则跨进程会通过onTransact调用对应的实现方法。这个逻辑是由Stub类的内部代理Proxy来完成的。

4.本Demo中 mDeathRecipient = new IBinder.DeathRecipient(){ public void binderDied() {...}}；

 mRemoteBookManager.asBinder().linkToDeath(mDeathRecipient, 0);

当远程服务异常挂掉的情况下，会调用binderDied的方法，在其中可以解除关联

 mRemoteBookManager.asBinder().unlinkToDeath(mDeathRecipient, 0);

4.使用总结

1.AIDL文件ready,IServiceManager.aidl
2.服务器：MyService extends Service 重写onBind方法返回Stub()实例
3.客户端：ServiceConnection实例serviceConnection onServiceConnected方法得到IBinder（android.os.BinderProxy）参数获取IServiceManager实例(IServiceManager$Stub$Proxy)，接下来调用方法。
4.若客户端服务器端在一个进程，3中onServiceConnected方法得到IBinder和IServiceManager为同一个MyService对象，且不会调用transact方法。

最后附上源码：http://download.csdn.net/detail/tianmi1988/9320963，对总结中的3、4点读者可以添加打印自行验证。

milotian

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
Android IPC之AIDL

在Android中，如果我们需要在不同进程间实现通信，有很多种方式，其中最普通的方式就是AIDL。 AIDL（Android Interface Definition Language）是一种接口定义语言，编译器通过*.aidl文件的描述信息生成符合通信协议的Java代码，我们无需自己去写这段繁杂的代码，只需要在需要的时候调用即可，通过这种方式我们就可以完成进程间的通信工作
复制链接

扫一扫