同个应用不同进程异步回调数据交互

1.背景：A和B进程在同个应用当中。B进程需要得到A进程的接口异步返回数据，我们都知道，进程间是不能访问数据的，这个时候，通过service+broadcast可完成数据交互。
2.实现：
a.首先，创建B进程访问数据接口工具类：

public class DataHelper
{

    public static final String ACTION = "..."//service acticon

    public static final String ACTION_RECV = "..."//broadcast action

    private Context mContext;

    private Map<Long, EngineCallback> mCallbacks;//设置回调数据接口

    private static DataHelper mHelper;

    private BroadcastReceiver mRecv = new BroadcastReceiver()
    {
        @Override
        public void onReceive(Context context, Intent intent)
        {
            if (intent != null && intent.getAction().equals(ACTION_RECV))
            {
                long flag = intent.getLongExtra("flag", 0);


                EngineCallback callback  = mCallbacks.get((Long) flag);
            if (callback != null)
                {

                    int result =  intent
                            .getIntExtra("result");

                    callback.callbackProcess(result);


//                  remove((Long) flag);
                }
            }
        }
    };

    private LogicHelper(Context context)
    {
        mContext = context;

        mCallbacks = new HashMap<Long, EngineCallback>();

        IntentFilter intentFilter = new IntentFilter(ACTION_RECV);

        mContext.registerReceiver(mRecv, intentFilter);
    }

    private static LogicHelper getHelper(Context context)
    {
        if (mHelper == null)
        {
            mHelper = new DataHelper(context);
        }

        return mHelper;
    }

    /**
     * @param param
     *            请求A进程数据所需入参
     */
    public static void submit(Context context, int param,
            EngineCallback callback)
    {
        long flag = System.currentTimeMillis();

        getHelper(context).put((Long) flag, callback);

        Intent intent = new Intent(ACTION);
        intent.putExtra("param", param);
        intent.putExtra("callback", flag);

        context.startService(intent);
    }

    protected Callbackcallback(Long flag)
    {
        return mCallbacks.get(flag);
    }

    protected void put(Long flag, EngineCallback callback)
    {
        mCallbacks.put(flag, callback);
    }

    protected void remove(Long flag)
    {
        mCallbacks.remove(flag);
    }

    protected void clear()
    {
        if (mCallbacks != null)
        {
            mCallbacks.clear();
            mCallbacks = null;
        }

        mContext.unregisterReceiver(mRecv);

        Intent intent = new Intent(ACTION);
        mContext.stopService(intent);

        mContext = null;
    }

    public static void destory()
    {
        if(mHelper != null)
        {
            mHelper.clear();
            mHelper = null;
        }
    }
}

/**
* //b.设置回调数据抽象类
*
/
public abstract class EngineCallback
{

    public abstract void callbackProcess(int result);

/**
*//***c.声明service(确保在A进程中声明)
*/

public class DataService extends Service
{
    private static final String TAG = "DataService";

    @Override
    public void onCreate()
    {
        super.onCreate();
    }


    @Override
    public IBinder onBind(Intent intent)
    {
        return null;
    }

    @Override
    public int onStartCommand(final Intent intent, final int flags, final int startId)
    {
        if(intent != null)
        {
            new Thread(new Runnable()
            {               
                @Override
                public void run()
                {
                    final long flag = intent.getLongExtra("callback", 0);
                    int param= intent.getIntExtra("param", 0);      
                    //**

                            Intent intentBack = new Intent(DataHelper.ACTION_RECV);

//调用A进程异步回调数据
/**
*  submit(int param ...new EngineCallback(){
            @override
            void callbackProcess(int result){
            intentBack.putExtra("result", result);                                          intentBack.putExtra("flag", flag);

                            DataService.this.sendBroadcast(intentBack);
            }

* });
*/                      
                }).start();

                    });
                }
            }); 
        }

        return super.onStartCommand(intent, flags, startId);

    }
}

d.至此，B进程通过A进程的service调用异步接口回调result，通过DataHelper的广播得到数据result。