Native层怎样获得java层实现的服务，如activity manager

获得service提供的服务，必须实现proxy，对应activity manager 就是BpActivityManager,
而实现BpActivityManager要先实现，接口类IActivityManager.


class IActivityManager : public IInterface {
  public:
    DECLARE_META_INTERFACE(ActivityManager);
 
    virtual status_t registerListener(const sp<IProcessObserver>& listener) = 0;
};
这里只使用 am 提供的registerListener服务，所以这里只写一个对应接口，其他的可不写。


接口类IActivityManager的成员函数是纯虚函数，service 和 client端都要实现，service端在java层已经实现，
在native层，只实现：


enum {
    REGISTER_PROCESS_OBSERVER_TRANSACTION = IBinder::FIRST_CALL_TRANSACTION + 132,
};


class BpActivityManager : public BpInterface<IActivityManager>
{
  public:
    BpActivityManager(const sp<IBinder>& impl)
        : BpInterface<IActivityManager>(impl) {}


    virtual status_t registerListener(const sp<IProcessObserver>& listener) {
        Parcel data, reply;
        data.writeInterfaceToken(IActivityManager::getInterfaceDescriptor());
        data.writeStrongBinder(IInterface::asBinder(listener));
        status_t status = remote()->transact(REGISTER_PROCESS_OBSERVER_TRANSACTION, data, &reply);


        if (status == OK) {
            ALOGE("register BpActivityManager OK:\n");
            status = reply.readInt32();
        }


        return status;
    }
};
IMPLEMENT_META_INTERFACE(ActivityManager, "android.app.IActivityManager");




通过实名的bind　“activity” 使用服务registerListener 
    sp<IServiceManager> sm = defaultServiceManager();
    sp<IBinder> binder = sm->getService(String16("activity"));
    sp<IActivityManager> am = interface_cast<IActivityManager>(binder);
    sp<ProcessObserver> ps =  new ProcessObserver();
    am->registerListener(ps);




从上面看，在native层调用java实现的服务很简单，遇到的最大问题是如何实现registerListener的参数IProcessObserver
先看下am服务端收到数据后，是怎样处理的？
frameworks/base/core/java/android/app/ActivityManagerNative.java
    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
            throws RemoteException {
        switch (code) {
        case REGISTER_PROCESS_OBSERVER_TRANSACTION: {
            data.enforceInterface(IActivityManager.descriptor);
            IProcessObserver observer = IProcessObserver.Stub.asInterface(
                    data.readStrongBinder());
            registerProcessObserver(observer);
            return true;
        }


该文件中有registerProcessObserver(observer)的实现，
    public void registerProcessObserver(IProcessObserver observer) throws RemoteException {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IActivityManager.descriptor);
        data.writeStrongBinder(observer != null ? observer.asBinder() : null);
        mRemote.transact(REGISTER_PROCESS_OBSERVER_TRANSACTION, data, reply, 0);
        reply.readException();
        data.recycle();
        reply.recycle();
    }
它的实现是有向外发送，并没有处理这个请求，看到这里比较混乱
这时可以看下调用栈： 方法：
Exception e = new Exception();
e.printStackTrace();
07-12 11:27:16.368  1356  1756 W System.err: at com.android.server.am.ActivityManagerService.registerProcessObserver(ActivityManagerService.java:11200)
07-12 11:27:16.369  1356  1756 W System.err: at android.app.ActivityManagerNative.onTransact(ActivityManagerNative.java:1973)
07-12 11:27:16.369  1356  1756 W System.err: at com.android.server.am.ActivityManagerService.onTransact(ActivityManagerService.java:2528)
07-12 11:27:16.369  1356  1756 W System.err: at android.os.Binder.execTransact(Binder.java:453)
从栈可以看出：am处理客户端请求的总入口在
frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
注册ProcessObserver的处理函数是：
    public void registerProcessObserver(IProcessObserver observer) {
        enforceCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER,
                "registerProcessObserver()");
        synchronized (this) {
            mProcessObservers.register(observer);
        }
    }
mProcessObserver的定义是：所谓的注册就是向list中添加
final RemoteCallbackList<IProcessObserver> mProcessObservers = new RemoteCallbackList<>();


注册进去的IProcessObserver是怎样使用的哪？
    final class UiHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {


            case DISPATCH_PROCESSES_CHANGED: {
                dispatchProcessesChanged();
                break;
            }
}


    private void dispatchProcessesChanged() {
final IProcessObserver observer = mProcessObservers.getBroadcastItem(i);
ProcessChangeItem item = mActiveProcessChanges[j];
        if ((item.changes&ProcessChangeItem.CHANGE_PROCESS_STATE) != 0) {
            if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG_PROCESS_OBSERVERS,
                    "PROCSTATE CHANGED pid=" + item.pid + " uid=" + item.uid
                    + ": " + item.processState);
            observer.onProcessStateChanged(item.pid, item.uid, item.processState);
        }
    }
最后调用的是注册对象的成员函数。
IProcessObserver没有对应的java函数，使用IProcessObserver.aidl接口语音实现的，编译framework会在目录下生成文件
./target/common/obj/JAVA_LIBRARIES/framework-full_intermediates/src/core/java/android/app/IProcessObserver.java
该文件就是标准的java层实现binder的方法：


public interface IProcessObserver extends android.os.IInterface
{
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements android.app.IProcessObserver
{


　　private static final java.lang.String DESCRIPTOR = "android.app.IProcessObserver";


　　/**
　　　* Cast an IBinder object into an android.app.IProcessObserver interface,
　　　* generating a proxy if needed.
　　　*/
　　public static android.app.IProcessObserver asInterface(android.os.IBinder obj)
　　{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof android.app.IProcessObserver))) {
return ((android.app.IProcessObserver)iin);
}
return new android.app.IProcessObserver.Stub.Proxy(obj);
　　}
　　@Override public android.os.IBinder asBinder()
　　{
return this;
　　}
@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
{
　　　switch (code)｛
case TRANSACTION_onProcessStateChanged:
{
data.enforceInterface(DESCRIPTOR);
int _arg0;
_arg0 = data.readInt();
int _arg1;
_arg1 = data.readInt();
int _arg2;
_arg2 = data.readInt();
this.onProcessStateChanged(_arg0, _arg1, _arg2);
return true;
}
　｝
　　　｝


private static class Proxy implements android.app.IProcessObserver
{
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote)
{
mRemote = remote;
}
@Override public android.os.IBinder asBinder()
{
return mRemote;
}
public java.lang.String getInterfaceDescriptor()
{
return DESCRIPTOR;
}


@Override public void onProcessStateChanged(int pid, int uid, int procState) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(pid);
_data.writeInt(uid);
_data.writeInt(procState);
mRemote.transact(Stub.TRANSACTION_onProcessStateChanged, _data, null, android.os.IBinder.FLAG_ONEWAY);
}
finally {
_data.recycle();
}
}
｝
public void onForegroundActivitiesChanged(int pid, int uid, boolean foregroundActivities) throws android.os.RemoteException;
public void onProcessStateChanged(int pid, int uid, int procState) throws android.os.RemoteException;
public void onProcessDied(int pid, int uid) throws android.os.RemoteException;
}


从上面可以看出，am收到的数据结构是直接处理事件observer.onProcessStateChanged，而不是请求server去处理，所以传递的参数是个service，
实现service 就要先实现 接口层 IProcessObserver


class IProcessObserver : public IInterface {
  public:
    DECLARE_META_INTERFACE(ProcessObserver);
    virtual void onForegroundActivitiesChanged(int pid, int uid, bool foregroundActivities){};
    virtual void onProcessStateChanged(int pid, int uid, int procState) = 0;
    virtual void onProcessDied(int pid, int uid){};
};


实现BpProcessObserver,原则上不用实现客户端，native端又不需要它。是为了编译的问题，
enum {
    ON_PROCESS_STATE_CHANGED = IBinder::FIRST_CALL_TRANSACTION + 1,
};


class BpProcessObserver : public BpInterface<IProcessObserver>
{
    public:
        BpProcessObserver(const sp<IBinder>& impl)
            : BpInterface<IProcessObserver>(impl) {}


        virtual void onProcessStateChanged(int pid, int uid, int procState){
            Parcel data, reply;
            data.writeInterfaceToken(IProcessObserver::getInterfaceDescriptor());
            data.writeInt32(pid);
            data.writeInt32(uid);
            data.writeInt32(procState);
            status_t status = remote()->transact(ON_PROCESS_STATE_CHANGED, data, &reply);


            if (status == OK) {
                status = reply.readInt32();
            }
        }   
};
IMPLEMENT_META_INTERFACE(ProcessObserver, "android.app.IProcessObserver");


实现服务端，服务端ProcessObserver继承了BnProcessOberver, 重新实现了函数onProcessStateChanged
当ProcessState改变时，该函数进行我们的处理。
class BnProcessObserver : public BnInterface<IProcessObserver> {
  public:
    virtual status_t onTransact(uint32_t code, const Parcel& data,
                                Parcel* reply, uint32_t flags = 0);
};


status_t BnProcessObserver::onTransact(
        uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
    //ALOGE("BnProcessObserver\n");
    switch (code) {
        case ON_PROCESS_STATE_CHANGED:
        int pid = data.readInt32();
        int uid = data.readInt32();
        int procState = data.readInt32();
        onProcessStateChanged(pid, uid, procState);
        return true;
    }


    return BBinder::onTransact(code, data, reply, flags);
}


class ProcessObserver : public BnProcessObserver{
    void onProcessStateChanged(int pid, int uid, int procState){
        ALOGE("callinto BnProcessObserver:\n");
    }
};


总结：
native侧调用java层的服务，就是在native 层创建客户端，构造对应的参数传入，至于传入什么样的参数，就看服务端需要什么样的数据，
整形等数据没什么问题，麻烦的是Binder对象, 直到套路了，就很简单。