android 进程间通信之AIDL

2017-03-17

最近一直在想微信与支付宝这样的sdk是怎么做到支付回调的，明明是两个不同的apk，接口、StartActivityForResult什么的肯定是行不通的。忽然想到会不会使用了跨进程通信的机制，客户端给支付宝发送支付请求，支付宝通过回调将支付结果回传给客户端，从而实现连个apk支付的回调。
竟然是这么想的，就不如大胆的实践一下吧！

我们先说一说我想实现的效果
A.apk通过点击跳转到B.apk,然后传递相应的消息，然后B通过点击把消息回传给A。

效果图

服务器apk

首先我们新建一个工程作为服务器apk
然后使用android studio新建aidl文件

// IRemoteServiceCallback.aidl
package com.dongqing.aidlservice;
/**
 * a callback interface used by dvbService to send
 * synchronous notifications back to its clients.  Note that this is a
 * one-way interface so the server does not block waiting for the client.
 */
oneway interface IRemoteServiceCallback {
    /*
     * handler search message from service
     */
     void handlerSearchEvent(int msgID, String msg);
}

IRemoteServiceCallback顾名思义用于回调给客户端的接口，然后我们建立
IRemoteService.aidl

// IRemoteService.aidl
package com.dongqing.aidlservice;
//import 必须添加，就算是一个包
import com.dongqing.aidlservice.IRemoteServiceCallback;
// Declare any non-default types here with import statements
interface IRemoteService {
   void registerCallback(IRemoteServiceCallback callback);
   void sendMsgCallback(IRemoteServiceCallback callback);
}

IRemoteService用于注册回调接口，然后我们Make Project，android studio会自动帮助我们生成其相应的 java文件
然后我们新建一个service用于客户端与服务器通信

public class AIDLService extends Service {
    String TAG = AIDLService.class.getSimpleName();
    private RemoteCallbackList<IRemoteServiceCallback> mCallbacks = new RemoteCallbackList<IRemoteServiceCallback>();
    private HandlerThread handlerThread;
    private Messenger msg;
	
	 @Override
    public void onCreate() {
        super.onCreate();
        handlerThread = new HandlerThread("handle");
        handlerThread.start();
        msg = new Messenger(new Handler(handlerThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                Bundle bundle = msg.getData();
                if (msg.what == 1001) {
                    result = bundle.getString("data");
                    Log.v(TAG, result);
                }
                sendMsg();
            }
        });
    }
	private IRemoteService.Stub binder = new IRemoteService.Stub() {
        @Override
        public void registerCallback(IRemoteServiceCallback callback) throws RemoteException {
            if (callback != null) {
                mCallbacks.register(callback);
            }
        }
        @Override
        public void sendMsgCallback(IRemoteServiceCallback callback) throws RemoteException {
          
        }
    };
	 public void sendMsg() {
        // Broadcast to all clients the new value.
        final int N = mCallbacks.beginBroadcast();
        try {
            for (int i = 0; i < N; i++) {
                mCallbacks.getBroadcastItem(i).handlerSearchEvent(1, "service callback client");
            }
        } catch (RemoteException e) {
        }
        mCallbacks.finishBroadcast();
    }
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        if (("com.dongqing.aidl").equals(intent.getAction())) {
            return binder;
        }
        if (("com.dongqing.messenger").equals(intent.getAction())) {
            return msg.getBinder();
        }
        return null;
    }
}

我们通过Messenger用来处理Activity与本地service通信，使用RemoteCallbackList处理异步回调。
现在我们在配置文件注册我们的service

<service android:name=".AIDLService">
	<intent-filter>
		<action android:name="com.dongqing.aidl" />
		<action android:name="com.dongqing.messenger" />
		<category android:name="android.intent.category.DEFAULT" />
		</intent-filter>
</service>

我们指定action，这样可以通过action隐式的绑定其service。
然后我们在服务器的Activity中

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    String TAG = MainActivity.class.getName();
    private Button button;
	 private TextView textView;
    private Messenger mService;
    boolean isBind;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        bindService();
    }
    private void initView() {
        button = (Button) findViewById(R.id.button);
        button.setOnClickListener(this);
		textView = (TextView) findViewById(R.id.textView);
        Bundle bundle=getIntent().getExtras();
        if(bundle!=null){
            Log.v(TAG,bundle.getString("data"));
            textView.setText(bundle.getString("data"));
    }
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.button:
                Message msgFromClient = Message.obtain(null,1001);
                Bundle bundle = new Bundle();  // 因为bundle实现了Parcelable接口。
                bundle.putString("data", "OK");
                msgFromClient.setData(bundle);
                if(isBind){
                    try {
                        mService.send(msgFromClient);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
                finish();
                break;
        }
    }
    private void bindService() {
        Intent intent = new Intent(this,AIDLService.class);
        intent.setAction("com.dongqing.messenger");
        bindService(intent, conn, Context.BIND_AUTO_CREATE);
    }
    private ServiceConnection conn=new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            mService=new Messenger(iBinder);
            isBind=true;
        }
        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            isBind=false;
        }
    };
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(conn);
    }
}

首先我们绑定本地的service，通过button的点击事件模拟支付成功的回调。点击时我们通过Messenger给service发送一个消息，service收到消息后通过RemoteCallbackList调用回调函数handlerSearchEvent实现服务端给客户端发送异步消息。

客户端apk

首先我们新建一个工程作为客户端apk，然后需要把服务端aidl的文件夹拷贝到相同的目录下。然后在Activity

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    String TAG = MainActivity.class.getName();
    private IRemoteService mService;
    boolean isBind;
    private Button button;
    private TextView textView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        BindService();
    }
    private void BindService() {
        Intent intent = new Intent();
        intent.setAction("com.dongqing.aidl");
        intent.setPackage("com.dongqing.aidlservice");
        bindService(intent, sc, Context.BIND_AUTO_CREATE);
    }
    private ServiceConnection sc = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            mService = IRemoteService.Stub.asInterface(iBinder);
            isBind = true;
            if (mService != null) {
                try {
                    mService.registerCallback(mCallback);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            isBind = false;
            mService = null;
        }
    };
    private IRemoteServiceCallback.Stub mCallback = new IRemoteServiceCallback.Stub() {
        @Override
        public void handlerSearchEvent(int msgID, String msg) throws RemoteException {
//            Toast.makeText(getContext(), msg, Toast.LENGTH_SHORT).show();
            Log.v(TAG, msg);
             runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    textView.setText(msg);
                }
            });
        }
    };
    private void initView() {
        button = (Button) findViewById(R.id.button);
        button.setOnClickListener(this);
        textView = (TextView) findViewById(R.id.textView);
    }
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.button:
                try {
                    Intent intent = getPackageManager().getLaunchIntentForPackage("com.dongqing.aidlservice");
                    intent.putExtra("data","client to service");
                    startActivity(intent);
                    if (isBind) {
                        if (mService != null && mCallback != null) {
                            mService.sendMsgCallback(mCallback);
                        }
                    }
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
        }
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (isBind) {
            unbindService(sc);
        }
    }
    public Context getContext() {
        return this;
    }
}

通过绑定service，实现回调callback方法，便可以实现客户端apk与服务器apk之间的相互通信。

流程

首先客户端需要绑定服务端的service，通过startIntent传递传递参数给服务端的Activity，并且注册回调接口。服务端拿到传递过来的数据进行一系列的操作，当点击按钮是通过Messenger向service传递数据，service收到Activity传递来的数据后，通过RemoteCallbackList调用回调的接口将接受到的数据传递给客户端的Activity，这样便实现了两个apk时间Activity的通信。

最后

通过一系列的实践与测试实现了apk之间的通信，但是不清楚支付宝、微信等sdk是不是以这种方式实现。这里仅仅是通过学习AIDL实现了类似于这种apk之间异步操作的通信，当然说不定有其他实现的方式。