ActivityManagerService新加listener及触发其回调

前言

Android版本为7.1，之前调查的时候发现没有太多这个功能实现相关的文章，所以自己来写一篇，第一次分享、记录自己代码，有什么写的不对的地方请见谅。

Android.mk

framework/base/Android.mk中新加一行把新加的aidl文件加入编译

core/java/android/app/ITestListener.aidl

ActivityManager.java

framework/base/core/java/android/app/ActivityManager.java
新加注册监听和注销的接口

import android.app.ITestListener.aidl

public boolean registerTestCallback(ITestListener listener) {
	boolean ret = false;
	try {
		ret = ActivityManagerNative.getDefault().registerTestCallback(listener);
	} catch (RemoteException) {
		ret = false;
		throw e.rethrowFromSystemServer();
	}
	return ret;
}
public boolean unRegisterTestCallback(ITestListener listener) {
	boolean ret = false;
	try {
		ret = ActivityManagerNative.getDefault().unRegisterTestCallback(listener);
	} catch (RemoteException) {
		ret = false;
		throw e.rethrowFromSystemServer();
	}
	return ret;
}

ActivityManagerNative.java

framework/base/core/java/android/app/ActivityManagerNative.java

import android.app.ITestListener.aidl

	case REGISTER_ACTIVITY_FINISH_CALLBACK_TRANSACTION: {
		data.enforceInterface(IActivityManager.descriptor);
		ITestListener listener = ITestListener.Stub.asInterface(data.readStrongBinder());
		boolean result = registerTestCallback(listener);
		reply.writeNoException();
		reply.writeInt(result ? 1 : 0);
		return true;
	}
	case UNREGISTER_ACTIVITY_FINISH_CALLBACK_TRANSACTION: {
		data.enforceInterface(IActivityManager.descriptor);
		ITestListener listener = ITestListener.Stub.asInterface(data.readStrongBinder());
		boolean result = unRegisterTestCallback(listener);
		reply.writeNoException();
		reply.writeInt(result ? 1 : 0);
		return true;
	}

public boolean registerTestCallback(ITestListener listener) throws RemoteException {
	Parcel data = Parcel.obtain();
	Parcel replay = Parcel.obtain();
	data.writeInterfaceToken(IActivityManager.descriptor);
	data.writeStrongInterface(listener);
	mRemote.transact(REGISTER_ACTIVITY_FINISH_CALLBACK_TRANSACTION, data, reply, 0);
	reply.readException();
	boolean res - reply.readInt() != 0;
	data.recycle();
	reply.recycle();
	return res;
}
public boolean unRegisterTestCallback(ITestListener listener) throws RemoteException {
	Parcel data = Parcel.obtain();
	Parcel replay = Parcel.obtain();
	data.writeInterfaceToken(IActivityManager.descriptor);
	data.writeStrongInterface(listener);
	mRemote.transact(UNREGISTER_ACTIVITY_FINISH_CALLBACK_TRANSACTION, data, reply, 0);
	reply.readException();
	boolean res - reply.readInt() != 0;
	data.recycle();
	reply.recycle();
	return res;
}

IActivityManager.java

framework/base/core/java/android/app/IActivityManager.java

import android.app.ITestListener.aidl

public boolean registerTestCallback(ITestListener listener) throws RemoteException
public boolean unRegisterTestCallback(ITestListener listener) throws RemoteException

int REGISTER_ACTIVITY_FINISH_CALLBACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+382;
int UNREGISTER_ACTIVITY_FINISH_CALLBACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+383;

ITestListener.aidl

新加listener文件
framework/base/core/java/android/app/ITestListener.aidl

package android.app;

interface ITestListener {
	void OnNotify();
}

ActivityManagerService.java

framework/base/services/core/java/com/android/server/am/ActivityManagerService.java
service里新加接口，在适当时候触发回调

import android.app.ITestListener.aidl
import android.os.HandlerThread;

	private final Arraylist<TestListenerData>mTestListenerDatas = new ArrayList<TestListenerData>();
	private Object mTestObject = new Object();
	private void handleTestListenerDeath(TestListenerDeath death) {
		int index = -1;
		synchronized(mTestObject) {
			if (null != mTestListenerDatas) {
				for (int i = 0; i < mTestListenerDatas.size(); i++) {
					if (mTestListenerDatas.get(i).getTestListenerDeath() == death) {
						index = i;
						break;
					}
				}
			}
			if (index >= 0) {
				mTestListenerDatas.get(index).getTestListener().asBinder()>unlinkToDeath(death,0);
				mTestListenerDatas.remove(index);
			}
		}
	}

    private class TestListenerDeath implements IBinder.DeathRecipient {
        @Override
        public void binderDied() {
            handleTestListenerDeath(TestListenerDeath.this);
        }
    }	

	private final class TestListenerData {
		private TestListenerDeath mDeath;
		private ITestListener mListener;
	
		public TestListenerData(ITestListener listener, TestListenerDeath death) {
			mDeath = death;
			mListener = listener;
		}
		public ITestListener getTestListener() {
			return mListener;
		}
		public TestListenerDeath getTestListenerDeath() {
			return mDeath;
		}
	}
	private int getIndexOfTestListener(ITestListener listener) {
		int index = -1;
		if (null != listener) {
			for (int i = 0; i < mTestListenerDatas.size(); i++) {
				if (mTestListenerDatas.get(i).getActivityFinishListener().asBinder() == listener.asBinder()) {
					index = i;
					break;
				}
			}
		}
		return index;
	}
	private final static int MESSAGE_TEST = 0;
	private final class TestHandler extends Handler {
		public TestHandler(Looper looper){
			super (looper);
		}
	
		@Override
		public void handleMessage(Message msg) {
			switch (msg.what) {
				case MESSAGE_TEST: {
					synchronized(mTestObject) {
						if (null != mTestListenerDatas){
							for (int i = 0; i < mTestListenerDatas.size(); i++) {
								ITestActivity listener = mTestListenerDatas.get(i).getTestListener();
								try {
									if (listener != null) {
										listener.OnNotify();
									}
								} catch (Throwable e) {
									e.printStackTrace();
								}
							}
						}
					}
				}
				break;
			}
		}
	}
	
	private HandlerThread mHandlerThread1;
	private TestHandler mTestHandler;
	
	// Note: This method is invoked on the main thread but may need to attach various
	// handlers to other threads. So take care to be explicit about the looper.
	public ActivityManagerService(Context systemContext) {
	mContext = systemContext;
	
	mHandlerThread1 = new HandlerThread("ACtivityManagerServiceTestThread");
	mHandlerThread1.start();
	mTestHandler = new TestHandler(mHandlerThread1.getLooper());

在想要触发回调的地方加入：

if (mTestListenerDatas != null && !mTestListenerDatas.isEmpty()) {
	Message msgTest = new Message();
	msgTest.what = MESSAGE_TEST;
	mTestHandler.sendMessage(msgTest);
}

新加接口实现：

	@Override
	public boolean registerTestCallback(ITestListener listener) {
		int index;
		synchronized(mTestObject) {
			if (null != listener) {
				index = getIndexOfTestListener(listener);
	
				if (index < 0) {
					TestListenerDeath death = new TestListenerDeath();
					
					try {
						listener.asBinder().linkToDeath(death, 0);
					} catch (RemoteException e) {
						e.printStackTrace();
					}
					TestListenerDate data = new TestListenerDate(listener, death);
		
					if (null != data) {
						mTestListenerDatas.add(data);
						return true;
					}
				}
			}
			return false;
		}
	}
	
	@Override
	public boolean unRegisterTestCallback(ITestListener listener) {
		int index;
		synchronized(mTestObject) {
			if (null != listener) {
				index = getIndexOfTestListener(listener);
	
				if (index >= 0) {
					mTestListenerDatas.remove(index);
					return true;
				}
			}
			return false;
		}
	}