AIDL(2)：服务端回调客户端

1.大致流程

• 在服务端声明远程服务接口IRemoteService.aidl,并声明回调接口ICallback.aidl
• 在服务端实现远程服务接口IRemoteService.Stub
• 使用RemoteCallbackList保存回调接口列表
• 发布服务
• 在客户端实现回调接口 ICallback.Stub
• 绑定服务,注册回调接口
• 调用服务
• 远程服务从RemoteCallbackList中找到回调,然后调用.

2.服务端

2.1 声明服务接口IRemoteService.aidl

// IRemoteService.aidl
package com.example.ee.aidl;

import com.example.ee.aidl.ICallback;

interface IRemoteService {

    int getPid();
    oneway void fun1();
    void registerCallback(ICallback cb);
    void unregisterCallback(ICallback cb);
}

2.2 声明回调接口ICallback.aidl

// ICallback.aidl
package com.example.ee.aidl;


interface ICallback {
    oneway void fun2();
}

2.3 实现服务,用 RemoteCallbackList 保存回调接口.

package com.example.ee.aidl;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.Process;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.support.annotation.Nullable;
import android.util.Log;

public class RemoteService extends Service {
    final String TAG = "RemoteService";

    private RemoteBinder binder = new RemoteBinder();
    private RemoteCallbackList<ICallback>  callbackList = new RemoteCallbackList<>();

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

    class RemoteBinder extends IRemoteService.Stub{

        void callback(){
            int count = callbackList.beginBroadcast();
            try {
                for (int i = 0; i < count; i++) {
                    callbackList.getBroadcastItem(i).fun2();
                }
            } catch (RemoteException e) {
                Log.e(TAG, e.getMessage());
            } finally {
            }
            callbackList.finishBroadcast();
        }


        @Override
        public int getPid() throws RemoteException {
            return Process.myPid();
        }

        @Override
        public void fun1() throws RemoteException {
            Log.d(TAG, "fun1 in remote service ");
            callback();
        }

        @Override
        public void registerCallback(ICallback cb) throws RemoteException {
            callbackList.register(cb);
        }

        @Override
        public void unregisterCallback(ICallback cb) throws RemoteException {
            callbackList.unregister(cb);
        }
    }
}

2.4 发布服务

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.ee.aidl">

    <application
        android:allowBackup="false"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:name=".AidlApp"
        android:theme="@style/AppTheme">
        <!--<meta-data
            android:name="APP_CHANNEL"
            android:value="${APP_CHANNEL}" />
-->
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <service android:name=".RemoteService" android:process=".RemoteService" android:exported="true"/>
    </application>

</manifest>

3.客户端

3.1 实现回调接口

    private ICallback callback  = new ICallback.Stub(){

        @Override
        public void fun2() throws RemoteException {
            Log.d(TAG, "fun2 in client ");
        }
    };

3.2 绑定远程服务,注册回调

    private void bindRemoteService(){
        connection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                remoteService = IRemoteService.Stub.asInterface(service);
                try {
                    remoteService.registerCallback(callback);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {

            }
        };

        Intent intent = new Intent(this,RemoteService.class);
        boolean ret = bindService(intent,connection, BIND_AUTO_CREATE);
        if (!ret ){
            Log.e(TAG, "bindRemoteService: bind failed.");
        }
    }

3.3 调用远程服务

    public void onClick(View view){
        if(view.getId() == R.id.btn_call_remote){
            AidlApp app = (AidlApp) getApplication();
            if (app.remoteService != null){
                try {
                    int pid = app.remoteService.getPid();
                    Log.d(TAG, "onServiceConnected: remote pid = " + pid);
                    app.remoteService.fun1();
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }else {
                Snackbar.make(view,"remote service unbinded",Snackbar.LENGTH_SHORT).show();
            }
        }
    }

4. 远程服务调用回调

    void callback(){
            int count = callbackList.beginBroadcast();
            try {
                for (int i = 0; i < count; i++) {
                    callbackList.getBroadcastItem(i).fun2();
                }
            } catch (RemoteException e) {
                Log.e(TAG, e.getMessage());
            } finally {
            }
            callbackList.finishBroadcast();
    }

 5.下载

　　https://gitee.com/xi/RemoteCallbackList.git