Android源码 · IBinder

package android.os;

import java.io.FileDescriptor;

/**
 * IBinder是一个远程处理对象的基本接口，是单进程和跨进程调用时，高性能的的轻量级的远程调用机制的核心部
 * 分。此接口描述与对象进行交互的抽象协议。不能直接实现这个接口，而是继承Binder。
 *
 * Base interface for a remotable object, the core part of a lightweight
 * remote procedure call mechanism designed for high performance when
 * performing in-process and cross-process calls.  This
 * interface describes the abstract protocol for interacting with a
 * remotable object.  Do not implement this interface directly, instead
 * extend from {@link Binder}.
 * 
 * @see Binder
 */
public interface IBinder {
    /**
     * 用户第一次使用的标识码 
    */
    int FIRST_CALL_TRANSACTION  = 0x00000001;
    /**
     * 用户最后一次使用的标识码 
     */
    int LAST_CALL_TRANSACTION   = 0x00ffffff;

    /** 
     * IBinder 记录交易码:pingBinder()
     */
    int PING_TRANSACTION        = ('_'<<24)|('P'<<16)|('N'<<8)|'G';

    /** 
     * IBinder 记录交易码 :转存内部状态     
     */
    int DUMP_TRANSACTION        = ('_'<<24)|('D'<<16)|('M'<<8)|'P';

    /** 
     * IBinder 记录交易码 :为接口询问交易的接收方     
     */
    int INTERFACE_TRANSACTION   = ('_'<<24)|('N'<<16)|('T'<<8)|'F';

    /**
     * IBinder protocol transaction code: send a tweet to the target
     * object.  The data in the parcel is intended to be delivered to
     * a shared messaging service associated with the object; it can be
     * anything, as long as it is not more than 130 UTF-8 characters to
     * conservatively fit within common messaging services.  As part of
     * {@link Build.VERSION_CODES#HONEYCOMB_MR2}, all Binder objects are
     * expected to support this protocol for fully integrated tweeting
     * across the platform.  To support older code, the default implementation
     * logs the tweet to the main log as a simple emulation of broadcasting
     * it publicly over the Internet.
     * 
     * <p>Also, upon completing the dispatch, the object must make a cup
     * of tea, return it to the caller, and exclaim "jolly good message
     * old boy!".
     */
    int TWEET_TRANSACTION   = ('_'<<24)|('T'<<16)|('W'<<8)|'T';

    /**
     * IBinder protocol transaction code: tell an app asynchronously that the
     * caller likes it.  The app is responsible for incrementing and maintaining
     * its own like counter, and may display this value to the user to indicate the
     * quality of the app.  This is an optional command that applications do not
     * need to handle, so the default implementation is to do nothing.
     * 
     * <p>There is no response returned and nothing about the
     * system will be functionally affected by it, but it will improve the
     * app's self-esteem.
     */
    int LIKE_TRANSACTION   = ('_'<<24)|('L'<<16)|('I'<<8)|'K';

    /** @hide */
    int SYSPROPS_TRANSACTION = ('_'<<24)|('S'<<16)|('P'<<8)|'R';

    /** transact的标志 :这是唯一的调用，表示调用方立刻返回，被调用方没有等待结果。只应用在调用者和被调
    *用者不在一个进程的时候。
     */
    int FLAG_ONEWAY             = 0x00000001;

    /** 
     * 确保 IPC 的大小，以保证记录缓冲的安全性
     * @hide
     */
    public static final int MAX_IPC_SIZE = 64 * 1024;

    /** 
     * 获得binder提供的接口的名称
     */
    public String getInterfaceDescriptor() throws RemoteException;

    /**
     * 查看对象是否还存在
     */
    public boolean pingBinder();

    /**
     * 查看binder进程是否还存活
     */
    public boolean isBinderAlive();

    /**
     * 尝试检索Binder对象的接口实现接口
     */
    public IInterface queryLocalInterface(String descriptor);

    /**
     * 将对象状态打印到给定的流中
     * 
     * @param fd The raw file descriptor that the dump is being sent to.
     * @param args additional arguments to the dump request.
     */
    public void dump(FileDescriptor fd, String[] args) throws RemoteException;

    /**
     *  就像dump(FileDescriptor, String[])，但是只有异步执行。如果对象存在本地，就要创建一个新
     * 线程执行存储。
     *
     * @param fd The raw file descriptor that the dump is being sent to.
     * @param args additional arguments to the dump request.
     */
    public void dumpAsync(FileDescriptor fd, String[] args) throws RemoteException;

    /**
     * 使用对象执行常规操作
     * 
     * @param code The action to perform.  This should
     * be a number between {@link #FIRST_CALL_TRANSACTION} and
     * {@link #LAST_CALL_TRANSACTION}.
     * @param data Marshalled data to send to the target.  Must not be null.
     * If you are not sending any data, you must create an empty Parcel
     * that is given here.
     * @param reply Marshalled data to be received from the target.  May be
     * null if you are not interested in the return value.
     * @param flags Additional operation flags.  Either 0 for a normal
     * RPC, or {@link #FLAG_ONEWAY} for a one-way RPC.
     */
    public boolean transact(int code, Parcel data, Parcel reply, int flags)
        throws RemoteException;

    /** 
     * 当该进程销毁一个 IBinder 的时候，接收回调的接口
     * 
     * @see #linkToDeath
     */
    public interface DeathRecipient {
        public void binderDied();
    }

    /** 
     * 如果binder销毁，为消息注册一个接受者
     * 
     * <p>You will only receive death notifications for remote binders,
     * as local binders by definition can't die without you dying as well.
     * 
     * @throws RemoteException if the target IBinder's
     * process has already died.
     * 
     * @see #unlinkToDeath
     */
    public void linkToDeath(DeathRecipient recipient, int flags)
            throws RemoteException;

    /** 
     * 移除被销毁的注册信息。如果对象被销毁，接受者不会再被调用
     * 
     * @return {@code true} if the <var>recipient</var> is successfully
     * unlinked, assuring you that its
     * {@link DeathRecipient#binderDied DeathRecipient.binderDied()} method
     * will not be called;  {@code false} if the target IBinder has already
     * died, meaning the method has been (or soon will be) called.
     * 
     * @throws java.util.NoSuchElementException if the given
     * <var>recipient</var> has not been registered with the IBinder, and
     * the IBinder is still alive.  Note that if the <var>recipient</var>
     * was never registered, but the IBinder has already died, then this
     * exception will <em>not</em> be thrown, and you will receive a false
     * return value instead.
     */
    public boolean unlinkToDeath(DeathRecipient recipient, int flags);
}

总结：

IBinder是一个能进行远程操作对象的基接口。提供进程间和跨进程间的调用时提供高性能的轻量级远程调用的核心部分。该接口描述了与远程对象进行交互的抽象协议。

IBinder的主要API是transact()，与它对应另一方法是Binder.onTransact()。第一个方法使你可以向远端的IBinder对象发送发出调用，第二个方法使你自己的远程对象能够响应接收到的调用。IBinder的API都是同步执行的，比如transact()直到对方的Binder.onTransact()方法调用完成后才返回。

参考：http://www.360doc.com/content/10/1227/14/4525948_81732732.shtml