Android组件间交互

四大组件相信大家都不陌生了吧，今天咱们就组件间通信做个说明：

首先：

　　主要今天的目的是为了说明Android 提供的一个ResultReceiver类，这个类相信大家都不陌生吧》？但是你们层深入了解过么，这个类不可谓不强大，辣么，咱们就看看怎么使他吧，

　　实例：Activity和service通信，484很屌，我也这么觉得，然并卵。

　　这里直接就来源码看看吧！！！！

　　牛逼的不行不行，

/*
 * Copyright (C) 2009 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 com.android.internal.os.IResultReceiver;

/**
 * Generic interface for receiving a callback result from someone.  Use this
 * by creating a subclass and implement {@link #onReceiveResult}, which you can
 * then pass to others and send through IPC, and receive results they
 * supply with {@link #send}.
 */
public class ResultReceiver implements Parcelable {
    final boolean mLocal;
    final Handler mHandler;
    
    IResultReceiver mReceiver;
    
    class MyRunnable implements Runnable {
        final int mResultCode;
        final Bundle mResultData;
        
        MyRunnable(int resultCode, Bundle resultData) {
            mResultCode = resultCode;
            mResultData = resultData;
        }
        
        public void run() {
            onReceiveResult(mResultCode, mResultData);
        }
    }
    
    class MyResultReceiver extends IResultReceiver.Stub {
        public void send(int resultCode, Bundle resultData) {
            if (mHandler != null) {
                mHandler.post(new MyRunnable(resultCode, resultData));
            } else {
                onReceiveResult(resultCode, resultData);
            }
        }
    }
    
    /**
     * Create a new ResultReceive to receive results.  Your
     * {@link #onReceiveResult} method will be called from the thread running
     * <var>handler</var> if given, or from an arbitrary thread if null.
     */
    public ResultReceiver(Handler handler) {
        mLocal = true;
        mHandler = handler;
    }
    
    /**
     * Deliver a result to this receiver.  Will call {@link #onReceiveResult},
     * always asynchronously if the receiver has supplied a Handler in which
     * to dispatch the result.
     * @param resultCode Arbitrary result code to deliver, as defined by you.
     * @param resultData Any additional data provided by you.
     */
    public void send(int resultCode, Bundle resultData) {
        if (mLocal) {
            if (mHandler != null) {
                mHandler.post(new MyRunnable(resultCode, resultData));
            } else {
                onReceiveResult(resultCode, resultData);
            }
            return;
        }
        
        if (mReceiver != null) {
            try {
                mReceiver.send(resultCode, resultData);
            } catch (RemoteException e) {
            }
        }
    }
    
    /**
     * Override to receive results delivered to this object.
     * 
     * @param resultCode Arbitrary result code delivered by the sender, as
     * defined by the sender.
     * @param resultData Any additional data provided by the sender.
     */
    protected void onReceiveResult(int resultCode, Bundle resultData) {
    }
    
    public int describeContents() {
        return 0;
    }

    public void writeToParcel(Parcel out, int flags) {
        synchronized (this) {
            if (mReceiver == null) {
                mReceiver = new MyResultReceiver();
            }
            out.writeStrongBinder(mReceiver.asBinder());
        }
    }

    ResultReceiver(Parcel in) {
        mLocal = false;
        mHandler = null;
        mReceiver = IResultReceiver.Stub.asInterface(in.readStrongBinder());
    }
    
    public static final Parcelable.Creator<ResultReceiver> CREATOR
            = new Parcelable.Creator<ResultReceiver>() {
        public ResultReceiver createFromParcel(Parcel in) {
            return new ResultReceiver(in);
        }
        public ResultReceiver[] newArray(int size) {
            return new ResultReceiver[size];
        }
    };
}

　　

　　Line27：说明该类是Parcelable的SubClass，这就为我们今天Service和Act通信提供的可能

　　Bundle是Android通信中参数的载体，同时提供了各种各样的set方法，其中主要的一个set方法，可以接受一个Parcelable子类对象。

　　

　　不到大家注意了木；

　　Line99：protected void onReceiveResult(int resultCode, Bundle resultData)这个方法是个空实现，纳尼问题来了，咱们阔以重载了他么，

　　下边是我自己的代码，来看俺的风骚；

import android.os.Bundle;
import android.os.Handler;
import android.os.ResultReceiver;

/**
 * @author ArMn
 *    859686819@qq.com
 */
public class MyResultReceiver extends ResultReceiver
{

    public MyResultReceiver(Handler handler) {
        super(handler);
        // TODO Auto-generated constructor stub
    }
    
    @Override
    protected void onReceiveResult(int resultCode, Bundle resultData) {
        // TODO Auto-generated method stub
        if(null != mActCallBackListener)
            mActCallBackListener.callBack();
    }
    
    public void setReceiver(ActCallBackListener listener){
        this.mActCallBackListener = listener;
    }
    
    private ActCallBackListener mActCallBackListener = null;
    
    public interface ActCallBackListener{
        void callBack();
    }
}

　　代码实现了ResultRecceview类，然后重载了onReceiveResult方法，同事自定义了内部interface，setReceiver方法用于指定所需要的回调对象，callback就是真正的回调方法了。

　　现在是时候说怎么通信了 ，通信的简单代码我就不再复述了，上边说道Bundle可以接受一个Parcelable对象，当然了现在咱们的MyReceiver继承自Receiver，同事Receiver是Parcelable的子类，别的就不用说了，new MyREceiver给Bundle是没问题了，回头继续源码Line74方法send方法；

　　核心源码：

public void send(int resultCode, Bundle resultData) {
            if (mLocal) {
                if (mHandler != null) {
                    mHandler.post(new MyRunnable(resultCode, resultData));
                } else {
                    onReceiveResult(resultCode, resultData);
                }
                return;
            }
         .........
        }

　　Line6：大家可以看到这里callback到咱们重载的方法onReceiveResul方法，咱们的callback484真的就完成了回调了哪？？？？？

　　饿死人了，粢饭！！！！！！

　　有空继续吹，今天先到这<><><><><><><><><>66666666666666666