Android(安卓)RemoteCallbackList类

在网上很少看到有解释 RemoteCallbackList类的，没办法要搞懂只能去看源码，大致理解：一个容器，容纳的对象是一些接口，用于执行列表中对象的回调函数，主要用于服务调用activity函数，或者解释为服务端和客户端通信。

/* * Copyright (C) 2008 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package android.os;import java.util.HashMap;/** * Takes care of the grunt work of maintaining a list of remote interfaces, * typically for the use of performing callbacks from a * {@link android.app.Service} to its clients.  In particular, this: * *  *  Keeps track of a set of registered {@link IInterface} callbacks, * taking care to identify them through their underlying unique {@link IBinder} * (by calling {@link IInterface#asBinder IInterface.asBinder()}. * 
 Attaches a {@link IBinder.DeathRecipient IBinder.DeathRecipient} to * each registered interface, so that it can be cleaned out of the list if its * process goes away. * 
 Performs locking of the underlying list of interfaces to deal with * multithreaded incoming calls, and a thread-safe way to iterate over a * snapshot of the list without holding its lock. * 
 * * To use this class, simply create a single instance along with your * service, and call its {@link #register} and {@link #unregister} methods * as client register and unregister with your service.  To call back on to * the registered clients, use {@link #beginBroadcast}, * {@link #getBroadcastItem}, and {@link #finishBroadcast}. * * 
If a registered callback's process goes away, this class will take * care of automatically removing it from the list.  If you want to do * additional work in this situation, you can create a subclass that * implements the {@link #onCallbackDied} method. */public class RemoteCallbackList<E extends IInterface> {    /*package*/ HashMap mCallbacks            = new HashMap();    private Object[] mActiveBroadcast;    private int mBroadcastCount = -1;    private boolean mKilled = false;    private final class Callback implements IBinder.DeathRecipient {        final E mCallback;        final Object mCookie;        Callback(E callback, Object cookie) {            mCallback = callback;            mCookie = cookie;        }        public void binderDied() {            synchronized (mCallbacks) {                mCallbacks.remove(mCallback.asBinder());            }            onCallbackDied(mCallback, mCookie);        }    }    /**     * Simple version of {@link RemoteCallbackList#register(E, Object)}     * that does not take a cookie object.     */    public boolean register(E callback) {        return register(callback, null);    }    /**     * Add a new callback to the list.  This callback will remain in the list     * until a corresponding call to {@link #unregister} or its hosting process     * goes away.  If the callback was already registered (determined by     * checking to see if the {@link IInterface#asBinder callback.asBinder()}     * object is already in the list), then it will be left as-is.     * Registrations are not counted; a single call to {@link #unregister}     * will remove a callback after any number calls to register it.     *     * @param callback The callback interface to be added to the list.  Must     * not be null -- passing null here will cause a NullPointerException.     * Most services will want to check for null before calling this with     * an object given from a client, so that clients can't crash the     * service with bad data.     *     * @param cookie Optional additional data to be associated with this     * callback.     *      * @return Returns true if the callback was successfully added to the list.     * Returns false if it was not added, either because {@link #kill} had     * previously been called or the callback's process has gone away.     *     * @see #unregister     * @see #kill     * @see #onCallbackDied     */    public boolean register(E callback, Object cookie) {        synchronized (mCallbacks) {            if (mKilled) {                return false;            }            IBinder binder = callback.asBinder();            try {                Callback cb = new Callback(callback, cookie);                binder.linkToDeath(cb, 0);                mCallbacks.put(binder, cb);                return true;            } catch (RemoteException e) {                return false;            }        }    }    /**     * Remove from the list a callback that was previously added with     * {@link #register}.  This uses the     * {@link IInterface#asBinder callback.asBinder()} object to correctly     * find the previous registration.     * Registrations are not counted; a single unregister call will remove     * a callback after any number calls to {@link #register} for it.     *     * @param callback The callback to be removed from the list.  Passing     * null here will cause a NullPointerException, so you will generally want     * to check for null before calling.     *     * @return Returns true if the callback was found and unregistered.  Returns     * false if the given callback was not found on the list.     *     * @see #register     */    public boolean unregister(E callback) {        synchronized (mCallbacks) {            Callback cb = mCallbacks.remove(callback.asBinder());            if (cb != null) {                cb.mCallback.asBinder().unlinkToDeath(cb, 0);                return true;            }            return false;        }    }    /**     * Disable this callback list.  All registered callbacks are unregistered,     * and the list is disabled so that future calls to {@link #register} will     * fail.  This should be used when a Service is stopping, to prevent clients     * from registering callbacks after it is stopped.     *     * @see #register     */    public void kill() {        synchronized (mCallbacks) {            for (Callback cb : mCallbacks.values()) {                cb.mCallback.asBinder().unlinkToDeath(cb, 0);            }            mCallbacks.clear();            mKilled = true;        }    }    /**     * Old version of {@link #onCallbackDied(E, Object)} that     * does not provide a cookie.     */    public void onCallbackDied(E callback) {    }    /**     * Called when the process hosting a callback in the list has gone away.     * The default implementation calls {@link #onCallbackDied(E)}     * for backwards compatibility.     *      * @param callback The callback whose process has died.  Note that, since     * its process has died, you can not make any calls on to this interface.     * You can, however, retrieve its IBinder and compare it with another     * IBinder to see if it is the same object.     * @param cookie The cookie object original provided to     * {@link #register(E, Object)}.     *      * @see #register     */    public void onCallbackDied(E callback, Object cookie) {        onCallbackDied(callback);    }    /**     * Prepare to start making calls to the currently registered callbacks.     * This creates a copy of the callback list, which you can retrieve items     * from using {@link #getBroadcastItem}.  Note that only one broadcast can     * be active at a time, so you must be sure to always call this from the     * same thread (usually by scheduling with {@link Handler}) or     * do your own synchronization.  You must call {@link #finishBroadcast}     * when done.     *     * 
A typical loop delivering a broadcast looks like this:     *     * 
     * int i = callbacks.beginBroadcast();     * while (i > 0) {     *     i--;     *     try {     *         callbacks.getBroadcastItem(i).somethingHappened();     *     } catch (RemoteException e) {     *         // The RemoteCallbackList will take care of removing     *         // the dead object for us.     *     }     * }     * callbacks.finishBroadcast();
     *     * @return Returns the number of callbacks in the broadcast, to be used     * with {@link #getBroadcastItem} to determine the range of indices you     * can supply.     *     * @see #getBroadcastItem     * @see #finishBroadcast     */    public int beginBroadcast() {        synchronized (mCallbacks) {            if (mBroadcastCount > 0) {                throw new IllegalStateException(                        "beginBroadcast() called while already in a broadcast");            }            final int N = mBroadcastCount = mCallbacks.size();            if (N <= 0) {                return 0;            }            Object[] active = mActiveBroadcast;            if (active == null || active.length < N) {                mActiveBroadcast = active = new Object[N];            }            int i=0;            for (Callback cb : mCallbacks.values()) {                active[i++] = cb;            }            return i;        }    }    /**     * Retrieve an item in the active broadcast that was previously started     * with {@link #beginBroadcast}.  This can only be called after     * the broadcast is started, and its data is no longer valid after     * calling {@link #finishBroadcast}.     *     * Note that it is possible for the process of one of the returned     * callbacks to go away before you call it, so you will need to catch     * {@link RemoteException} when calling on to the returned object.     * The callback list itself, however, will take care of unregistering     * these objects once it detects that it is no longer valid, so you can     * handle such an exception by simply ignoring it.     *     * @param index Which of the registered callbacks you would like to     * retrieve.  Ranges from 0 to 1-{@link #beginBroadcast}.     *     * @return Returns the callback interface that you can call.  This will     * always be non-null.     *     * @see #beginBroadcast     */    public E getBroadcastItem(int index) {        return ((Callback)mActiveBroadcast[index]).mCallback;    }    /**     * Retrieve the cookie associated with the item     * returned by {@link #getBroadcastItem(int)}.     *      * @see #getBroadcastItem     */    public Object getBroadcastCookie(int index) {        return ((Callback)mActiveBroadcast[index]).mCookie;    }    /**     * Clean up the state of a broadcast previously initiated by calling     * {@link #beginBroadcast}.  This must always be called when you are done     * with a broadcast.     *     * @see #beginBroadcast     */    public void finishBroadcast() {        if (mBroadcastCount < 0) {            throw new IllegalStateException(                    "finishBroadcast() called outside of a broadcast");        }        Object[] active = mActiveBroadcast;        if (active != null) {            final int N = mBroadcastCount;            for (int i=0; inull;            }        }        mBroadcastCount = -1;    }    /**     * Returns the number of registered callbacks. Note that the number of registered     * callbacks may differ from the value returned by {@link #beginBroadcast()} since     * the former returns the number of callbacks registered at the time of the call     * and the second the number of callback to which the broadcast will be delivered.     * 
     * This function is useful to decide whether to schedule a broadcast if this     * requires doing some work which otherwise would not be performed.     * 
     *     * @return The size.     */    public int getRegisteredCallbackCount() {        synchronized (mCallbacks) {            if (mKilled) {                return 0;            }            return mCallbacks.size();        }    }}

通过查看上面的源码，我们可以知道主要是维护 mCallbacks ，mCallbacks中包含我们的客户端接口

    /*package*/ HashMap mCallbacks            = new HashMap();

其中常用的几个函数 register

    public boolean register(E callback) {        return register(callback, null);    }    public boolean register(E callback, Object cookie) {        synchronized (mCallbacks) {            if (mKilled) {                return false;            }            IBinder binder = callback.asBinder();            try {                Callback cb = new Callback(callback, cookie);                binder.linkToDeath(cb, 0);                mCallbacks.put(binder, cb);                return true;            } catch (RemoteException e) {                return false;            }        }    }

向 mCallbacks中添加接口对象，主要使用 mCallbacks.put(binder, cb);方法，

unregister()方法

    public boolean unregister(E callback) {        synchronized (mCallbacks) {            Callback cb = mCallbacks.remove(callback.asBinder());            if (cb != null) {                cb.mCallback.asBinder().unlinkToDeath(cb, 0);                return true;            }            return false;        }    }

通过 mCallbacks.remove(callback.asBinder()); 从HashMap中删除

kill()方法

    public void kill() {        synchronized (mCallbacks) {            for (Callback cb : mCallbacks.values()) {                cb.mCallback.asBinder().unlinkToDeath(cb, 0);            }            mCallbacks.clear();            mKilled = true;        }    }

通过 mCallbacks.clear(); 清空集合。

beginBroadcast() ;

    public int beginBroadcast() {        synchronized (mCallbacks) {            if (mBroadcastCount > 0) {                throw new IllegalStateException(                        "beginBroadcast() called while already in a broadcast");            }            final int N = mBroadcastCount = mCallbacks.size();            if (N <= 0) {                return 0;            }            Object[] active = mActiveBroadcast;            if (active == null || active.length < N) {                mActiveBroadcast = active = new Object[N];            }            int i=0;            for (Callback cb : mCallbacks.values()) {                active[i++] = cb;            }            return i;        }    }

从注释的解释来说大致是：准备开始调用当前注册的回调。这将创建一个回调列表的副本,你可以从使用getBroadcastItem检索条目，注意:一次只能激活一个广播,所以你必须确保总是从同一个线程调用这个或者是自己做同步。完成后必须调用finishBroadcast。
返回值：callbacks的大小；

如果 mBroadcastCount > 0 说明之前调用过beginBroadcast()，则会抛出异常；

getBroadcastItem()方法从副本中获取我们之前存入的接口对象

    public E getBroadcastItem(int index) {        return ((Callback)mActiveBroadcast[index]).mCallback;    }

finishBroadcast()，清理我们之前建立的active[] 副本

    public void finishBroadcast() {        if (mBroadcastCount < 0) {            throw new IllegalStateException(                    "finishBroadcast() called outside of a broadcast");        }        Object[] active = mActiveBroadcast;        if (active != null) {            final int N = mBroadcastCount;            for (int i=0; inull;            }        }        mBroadcastCount = -1;    }

如果 mBroadcastCount <0 说明之前掉用过finishBroadcast() 则会抛出异常。

常用的函数大概就是这个样子，如果我理解有误欢迎大家留言指正，也欢迎大家补充，一起学习

更多相关文章

随机推荐