获取 ActivityManagerService 服务
API 26
一、Java 层获取系统服务
Context#getSystemService()
// Context 的实现类是 ContextImpl
@Override
public Object getSystemService(String name) {
// this 是 ContextImpl
return SystemServiceRegistry.getSystemService(this, name);
}
SystemServiceRegistry#getSystemService()
private static final HashMap<String, ServiceFetcher<?>> SYSTEM_SERVICE_FETCHERS = new HashMap<String, ServiceFetcher<?>>();
public static Object getSystemService(ContextImpl ctx, String name) {
ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
// 查看 ServiceFetcher#getService()
return fetcher != null ? fetcher.getService(ctx) : null;
}
ServiceFetcher#getService()
static abstract interface ServiceFetcher<T> {
T getService(ContextImpl ctx);
}
看一下 SystemServiceRegistry#CachedServiceFetcher
static abstract class CachedServiceFetcher<T> implements ServiceFetcher<T> {
// 伴随类的创建被赋值后就不可变，final 不可变
private final int mCacheIndex;
public CachedServiceFetcher() {
// 给 mCacheIndex 赋值，赋值后不能再次改变
// 下面就是用此值作为键保存相应的服务
mCacheIndex = sServiceCacheSize++;
}
// 获取服务，不为空直接返回
public final T getService(ContextImpl ctx) {
// 获取服务缓存数组（默认为空）
final Object[] cache = ctx.mServiceCache;
synchronized (cache) {
// 默认为空，第二次获取时才不为空
Object service = cache[mCacheIndex];
// 默认为空，创建并保存服务
if (service == null) {
try {
// 调用 createService() 方法创建服务
service = createService(ctx);
// 保存服务到服务缓存数组中
// mCacheIndex 是 final 不可变的，相对于当前类是固定的
// 创建一个新的类后，mCacheIndex 就固定下来了
cache[mCacheIndex] = service;
} catch (ServiceNotFoundException e) {
onServiceNotFound(e);
}
}
// 不为空时，直接返回
return (T)service;
}
}
// 抽象方法，用于创建服务
public abstract T createService(ContextImpl ctx) throws ServiceNotFoundException;
}
平时开发过程中，通过 ContextImpl#getSystemService(ContextImpl ctx, String name) 获取对应系统服务时涉及的类：
Context：上下文
ContextImpl：上下文实现类
ServiceFetcher：创建和获取服务的类的基本接口，这些对象只能在静态初始化期间创建
SystemServiceRegistry：管理所有的系统服务，静态代码块中注册了很多服务，如：ActivityManager 对应的服务、LayoutInflater 对应的服务…
二、SystemServiceRegistry 静态代码块，创建并保存服务
SystemServiceRegistry 静态代码块
static {
...
// 创建并保存 ActivityManager 对应的服务
registerService(Context.ACTIVITY_SERVICE, ActivityManager.class,
new CachedServiceFetcher<ActivityManager>() {
@Override
public ActivityManager createService(ContextImpl ctx) {
return new ActivityManager(ctx.getOuterContext(), ctx.mMainThread.getHandler());
}});
// 创建并保存 LayoutInflater 对应的服务
registerService(Context.LAYOUT_INFLATER_SERVICE, LayoutInflater.class,
new CachedServiceFetcher<LayoutInflater>() {
@Override
public LayoutInflater createService(ContextImpl ctx) {
return new PhoneLayoutInflater(ctx.getOuterContext());
}});
...
}
三、获取 ActivityManagerService 服务流程
关键一：ActivityManagerService 服务是由系统去调用（不是由我们主动调用），我们在使用的过程中也是通过 ActivityManager 对象来操作 ActivityManagerService 的，系统也避免我们直接操作 ActivityManagerService
ActivityThread 是 Activity 的入口，其 main() 函数会创建一个 ActivityThread 对象，并启动消息循环
ActivityThread#main()
public static void main(String[] args) {
...
Looper.prepareMainLooper();
// 创建 ActivityThread 对象
ActivityThread thread = new ActivityThread();
// 关键二：ActivityThread#attach(false)
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
...
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
关键二：ActivityThread#attach(false)
final ApplicationThread mAppThread = new ApplicationThread();
// 传的是 false
private void attach(boolean system) {
sCurrentActivityThread = this;
mSystemThread = system;
// 进入该 if 语句，表示当前不是系统应用
if (!system) {
...
RuntimeInit.setApplicationObject(mAppThread.asBinder());
// 关键三：ActivityManager#getService()
// 这里获取 AMS 在客户端进程的代理
final IActivityManager mgr = ActivityManager.getService();
...
} else {
...
}
...
}
关键三：ActivityManager#getService()
应用进程并不是直接和 AMS 进行沟通，中间隔了个 ActivityManager，通过 ActivityManager 去获取 AMS 服务，实际上客户端进程获取的是 AMS 在客户端进程的代理对象
[–>ActivityManager.java, getService()]
public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}
private static final Singleton<IActivityManager> IActivityManagerSingleton =
new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
// 关键五：这里获取的是 AMS 对象对应的 IBinder 对象
// Context.ACTIVITY_SERVICE = "activity"
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
// 关键八：IActivityManager.Stub.asInterface(b)
final IActivityManager am = IActivityManager.Stub.asInterface(b);
return am;
}
};
关键五：ServiceManager#getService()
[–>ServiceManager.java]
// name 传入的是 "activity"
public static IBinder getService(String name) {
try {
IBinder service = sCache.get(name);
if (service != null) {
return service;
} else {
// 调用 getIServiceManager().getService()
return Binder.allowBlocking(getIServiceManager().getService(name));
}
} catch (RemoteException e) {
}
return null;
}
看看 getIServiceManager() 返回啥
private static IServiceManager getIServiceManager() {
if (sServiceManager != null) {
return sServiceManager;
}
// 关键 5-1：BinderInternal.getContextObject()
// 关键 5-2：ServiceManagerNative.asInterface()
sServiceManager = ServiceManagerNative.asInterface(Binder.allowBlocking(BinderInternal.getContextObject()));
return sServiceManager;
}
关键 5-1：BinderInternal.getContextObject() 是一个 native 方法
看一下 BinderInternal#getContextObject() 实现的地方
[–>android_util_Binder.cpp]
static const JNINativeMethod gBinderInternalMethods[] = {
/* name, signature, funcPtr */
// getContextObject() 的 native 方法实现是 android_os_BinderInternal_getContextObject()
{ "getContextObject", "()Landroid/os/IBinder;", (void*)android_os_BinderInternal_getContextObject },
{ "joinThreadPool", "()V", (void*)android_os_BinderInternal_joinThreadPool },
{ "disableBackgroundScheduling", "(Z)V", (void*)android_os_BinderInternal_disableBackgroundScheduling },
{ "handleGc", "()V", (void*)android_os_BinderInternal_handleGc }
};
[–>android_util_Binder.cpp, android_os_BinderInternal_getContextObject()]
static jobject android_os_BinderInternal_getContextObject(JNIEnv* env, jobject clazz)
{
sp<IBinder> b = ProcessState::self()->getContextObject(NULL);
return javaObjectForIBinder(env, b);
}
先看 ProcessState::self()->getContextObject(NULL)，待会再回到 android_os_BinderInternal_getContextObject() 中看 javaObjectForIBinder()
[–>ProcessState.cpp, getContextObject()]
// ProcessState::self() 返回的就是 ProcessState 实例
sp<ProcessState> ProcessState::self()
{
Mutex::Autolock _l(gProcessMutex);
if (gProcess != NULL) {
return gProcess;
}
// new 一个 ProcessState
gProcess = new ProcessState;
// 返回 ProcessState
return gProcess;
}
// ProcessState#getContextObject
sp<IBinder> ProcessState::getContextObject(const sp<IBinder>& /*caller*/)
{
// 调用 getStrongProxyForHandle(0)
return getStrongProxyForHandle(0);
}
[–>ProcessState.cpp, getStrongProxyForHandle()]
// handle 传入的是 0
sp<IBinder> ProcessState::getStrongProxyForHandle(int32_t handle)
{
sp<IBinder> result;
AutoMutex _l(mLock);
handle_entry* e = lookupHandleLocked(handle);
if (e != NULL) {
IBinder* b = e->binder;
if (b == NULL || !e->refs->attemptIncWeak(this)) {
if (handle == 0) {
Parcel data;
status_t status = IPCThreadState::self()->transact(0, IBinder::PING_TRANSACTION, data, NULL, 0);
if (status == DEAD_OBJECT)
return NULL;
}
// 首次调用当前方法，会创建一个 BpBinder(0) 对象（属于 Native 对象）
b = new BpBinder(handle);
e->binder = b;
if (b) e->refs = b->getWeakRefs();
// 把 BpBinder(0) 赋给 result
result = b;
} else {
result.force_set(b);
e->refs->decWeak(this);
}
}
// 返回创建的 BpBinder(0) 对象（属于 Native 对象）
return result;
}
再回到 android_os_BinderInternal_getContextObject() 中看 javaObjectForIBinder()
[–>android_util_Binder.cpp, android_os_BinderInternal_getContextObject()]
static jobject android_os_BinderInternal_getContextObject(JNIEnv* env, jobject clazz)
{
// 由上面分析可得，这个 b 是一个 BpBinder(0) 对象（属于 Native 对象）
sp<IBinder> b = ProcessState::self()->getContextObject(NULL);
// javaObjectForIBinder()
return javaObjectForIBinder(env, b);
}
[–>android_util_Binder.cpp, javaObjectForIBinder()]
// val 传入的是 BpBinder(0)（属于 Native 对象）
jobject javaObjectForIBinder(JNIEnv* env, const sp<IBinder>& val)
{
if (val == NULL) return NULL;
if (val->checkSubclass(&gBinderOffsets)) {
jobject object = static_cast<JavaBBinder*>(val.get())->object();
return object;
}
// BpBinder 内部有一个成员变量 ObjectManager，这里的 findObject() 就是来查找 gBinderProxyOffsets 是否保存在 ObjectManager 中
jobject object = (jobject)val->findObject(&gBinderProxyOffsets);
// 若 gBinderProxyOffsets 已保存在 ObjectManager 中
if (object != NULL) {
jobject res = jniGetReferent(env, object);
if (res != NULL) {
return res;
}
android_atomic_dec(&gNumProxyRefs);
// 移除 ObjectManager 中保存的 gBinderProxyOffsets
val->detachObject(&gBinderProxyOffsets);
// 删除旧的 object
env->DeleteGlobalRef(object);
}
// 创建一个新的 BinderProxy 对象（Java 层对象）
object = env->NewObject(gBinderProxyOffsets.mClass, gBinderProxyOffsets.mConstructor);
if (object != NULL) {
// (jlong)val.get()：把 BpBinder(0) 转为指针类型
// 把 BpBinder(0) 指针类型保存到 object（上面创建的 BinderProxy）对象对应的 Native 关联对象 gBinderProxyOffsets 的 mObject 成员变量中
env->SetLongField(object, gBinderProxyOffsets.mObject, (jlong)val.get());
val->incStrong((void*)javaObjectForIBinder);
jobject refObject = env->NewGlobalRef(env->GetObjectField(object, gBinderProxyOffsets.mSelf));
// 上面已经新创建了一个 BinderProxy 对象（Java 层对象），现在可以重新把 gBinderProxyOffsets 关联到 BpBinder 成员变量 ObjectManager 中
val->attachObject(&gBinderProxyOffsets, refObject, jnienv_to_javavm(env), proxy_cleanup);
sp<DeathRecipientList> drl = new DeathRecipientList;
drl->incStrong((void*)javaObjectForIBinder);
env->SetLongField(object, gBinderProxyOffsets.mOrgue, reinterpret_cast<jlong>(drl.get()));
android_atomic_inc(&gNumProxyRefs);
incRefsCreated(env);
}
return object;
}
简单概括一下 javaObjectForIBinder() 执行流程，如下：
- 查看传入参数 BpBinder(0)（属于 Native 对象）成员变量 ObjectManager 中是否保存了 gBinderProxyOffsets（是则代表之前已创建过 Java 层 BinderProxy 对象）
是：则移除 ObjectManager 中保存的 gBinderProxyOffsets（因为需要创建新的 Java 层 BinderProxy 对象，也就需要重新绑定） - 创建一个新的 BinderProxy 对象（Java 层对象）
- 把 BpBinder(0) 转为指针类型保存到创建的 BinderProxy 对象对应 Native 关联对象 gBinderProxyOffsets 的 mObject 成员变量中
- 现在重新把 gBinderProxyOffsets 关联到 BpBinder 成员变量 ObjectManager 中（表示当前创建了一个新的 Java 层 BinderProxy 对象）
搞了半天，现在总结关键 5-1：BinderInternal.getContextObject() 这个 native 方法到底干了啥
- 返回了一个 BinderProxy 对象（Java 层对象）
- 把 BpBinder(0) 转为指针类型保存到 BinderProxy 对象对应的 Native 关联对象 gBinderProxyOffsets 的 mObject 成员变量中
也即是说，Java 层的 BinderProxy 对象关联着 BpBinder(0)
再贴一下，关键 5-2：ServiceManagerNative.asInterface() 出现的位置
[–>ServiceManager.java]
private static IServiceManager getIServiceManager() {
if (sServiceManager != null) {
return sServiceManager;
}
// 关键 5-1：BinderInternal.getContextObject()：返回了一个 BinderProxy 对象（Java 层对象）
// 关键 5-2：ServiceManagerNative.asInterface()，现在看看这个
sServiceManager = ServiceManagerNative.asInterface(Binder.allowBlocking(BinderInternal.getContextObject()));
return sServiceManager;
}
[–>ServiceManagerNative.java, asInterface()]
// obj 传入的是 BinderProxy
static public IServiceManager asInterface(IBinder obj)
{
if (obj == null) {
return null;
}
// 调用 BinderProxy#queryLocalInterface() 默认返回 null
// queryLocalInterface() 用来查询本地对象，当前获取 AMS 服务的进程和 AMS 所在进程不是同一个进程，因此返回 null
IServiceManager in = (IServiceManager)obj.queryLocalInterface(descriptor);
if (in != null) {
return in;
}
// 创建并返回 ServiceManagerProxy 对象
return new ServiceManagerProxy(obj);
}
[–>Binder.java, BinderProxy#queryLocalInterface()]
final class BinderProxy implements IBinder {
...
// BinderProxy#queryLocalInterface() 返回 null
public IInterface queryLocalInterface(String descriptor) {
return null;
}
...
}
再贴一下，getIServiceManager() 出现的位置
[–>ServiceManager.java]
private static IServiceManager getIServiceManager() {
if (sServiceManager != null) {
return sServiceManager;
}
// 关键 5-1：BinderInternal.getContextObject()：返回了一个 BinderProxy 对象（Java 层对象）
// 关键 5-2：ServiceManagerNative.asInterface()：返回 ServiceManagerProxy 对象
sServiceManager = ServiceManagerNative.asInterface(Binder.allowBlocking(BinderInternal.getContextObject()));
return sServiceManager;
}
getIServiceManager() 最终返回一个 ServiceManagerProxy 对象
简单小结一下 getIServiceManager() 流程，如下：
- BinderInternal.getContextObject()：返回了一个 BinderProxy 对象（Java 层对象）
// Java 层的 BinderProxy 对象关联着 BpBinder(0) - ServiceManagerNative.asInterface()：返回 ServiceManagerProxy 对象
// ServiceManagerProxy 对象持有 BinderProxy 对象引用
也即是说，Java 层的 ServiceManagerProxy 对象持有 BinderProxy 对象引用，而 Java 层的 BinderProxy 对象关联着 BpBinder(0)，事实上 Java 层的 ServiceManagerProxy 对象的各个业务函数会将请求转交给 BpBinder(0)，最终由 BpBinder(0) 对象发送给 Binder 驱动程序完成一次通信
再贴一下，关键五：ServiceManager#getService()
[–>ServiceManager.java]
// name 传入的是 "activity"
public static IBinder getService(String name) {
try {
IBinder service = sCache.get(name);
if (service != null) {
return service;
} else {
// getIServiceManager() 最终返回一个 ServiceManagerProxy 对象
// 调用 ServiceManagerProxy#getService()
return Binder.allowBlocking(getIServiceManager().getService(name));
}
} catch (RemoteException e) {
}
return null;
}
先画个 ServiceManagerProxy#getService() 的调用简图
[–>ServiceManagerNative.java, ServiceManagerProxy#getService()]
class ServiceManagerProxy implements IServiceManager {
// 上面创建 ServiceManagerProxy 对象时，参数传入的是 BinderProxy
public ServiceManagerProxy(IBinder remote) {
// mRemote 赋值为 BinderProxy
mRemote = remote;
}
public IBinder getService(String name) throws RemoteException {
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IServiceManager.descriptor);
// name 是 "activity"
data.writeString(name);
// 关键六：调用 BinderProxy#transact()，将封装好的请求数据 data 发送出去，返回结果保存在 reply 中
mRemote.transact(GET_SERVICE_TRANSACTION, data, reply, 0);
// 关键七：Parcel#readStrongBinder()，解析 reply 中的数据
IBinder binder = reply.readStrongBinder();
reply.recycle();
data.recycle();
return binder;
}
...
}
关键六：BinderProxy#transact()
[–>Binder.java, BinderProxy#transact()]
public boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
Binder.checkParcel(this, code, data, "Unreasonably large binder buffer");
// 调用 transactNative()
return transactNative(code, data, reply, flags);
}
// transactNative 是一个 native 方法
public native boolean transactNative(int code, Parcel data, Parcel reply, int flags) throws RemoteException;
看一下 transactNative() 实现的地方
[–>android_util_Binder.cpp]
static constJNINativeMethod gBinderProxyMethods[] = {
/* name, signature, funcPtr */
{"pingBinder", "()Z", (void*)android_os_BinderProxy_pingBinder},
{"isBinderAlive", "()Z", (void*)android_os_BinderProxy_isBinderAlive},
{"getInterfaceDescriptor", "()Ljava/lang/String;", (void*)android_os_BinderProxy_getInterfaceDescriptor},
// transactNative() 的 native 方法实现是 android_os_BinderProxy_transact()
{"transactNative", "(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z", (void*)android_os_BinderProxy_transact},
{"linkToDeath", "(Landroid/os/IBinder$DeathRecipient;I)V", (void*)android_os_BinderProxy_linkToDeath},
{"unlinkToDeath", "(Landroid/os/IBinder$DeathRecipient;I)Z", (void*)android_os_BinderProxy_unlinkToDeath},
{"destroy", "()V", (void*)android_os_BinderProxy_destroy},
};
[–>android_util_Binder.cpp, android_os_BinderProxy_transact()]
// 当前方法由 BinderProxy 调用，即 obj 传入的是 BinderProxy
static jboolean android_os_BinderProxy_transact(JNIEnv* env, jobject obj, jint code, jobject dataObj, jobject replyObj, jint flags)
{
if (dataObj == NULL) {
jniThrowNullPointerException(env, NULL);
return JNI_FALSE;
}
Parcel* data = parcelForJavaObject(env, dataObj);
if (data == NULL) {
return JNI_FALSE;
}
Parcel* reply = parcelForJavaObject(env, replyObj);
if (reply == NULL && replyObj != NULL) {
return JNI_FALSE;
}
// 在上面我们把 BpBinder(0) 转为指针类型保存到创建的 BinderProxy 对象对应 Native 关联对象 gBinderProxyOffsets 的 mObject 成员变量中
// 那现在就把这个 BpBinder(0) 取出来，赋给 target
IBinder* target = (IBinder*)env->GetLongField(obj, gBinderProxyOffsets.mObject);
if (target == NULL) {
jniThrowException(env, "java/lang/IllegalStateException", "Binder has been finalized!");
return JNI_FALSE;
}
// 调用 Native 层 BpBinder(0) 对象的 transact() 方法获取服务，返回的服务保存在 reply 中
// code = GET_SERVICE_TRANSACTION
// 获取的服务名称 name = "activity"
status_t err = target->transact(code, *data, reply, flags);
if (err == NO_ERROR) {
return JNI_TRUE;
} else if (err == UNKNOWN_TRANSACTION) {
return JNI_FALSE;
}
signalExceptionForError(env, obj, err, true /*canThrowRemoteException*/);
return JNI_FALSE;
}
此时返回结果 reply 中就有数据了，可以开始解析其中的数据
关键七：Parcel#readStrongBinder()
解析 reply（Parcel 类型）中的数据
[–>Parcel.java, readStrongBinder()]
public final IBinder readStrongBinder() {
return nativeReadStrongBinder(mNativePtr);
}
// nativeReadStrongBinder 是一个 native 方法
private static native IBinder nativeReadStrongBinder(long nativePtr);
看一下 Parcel#nativeReadStrongBinder() 实现的地方
[–>android_os_Parcel.cpp]
static const JNINativeMethod gParcelMethods[] = {
...
{"nativeReadStrongBinder", "(J)Landroid/os/IBinder;", (void*)android_os_Parcel_readStrongBinder},
...
};
[–>android_os_Parcel.cpp, android_os_Parcel_readStrongBinder()]
static jobject android_os_Parcel_readStrongBinder(JNIEnv* env, jclass clazz, jlong nativePtr)
{
// 这个 parcel 是 C++ 对象
Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
if (parcel != NULL) {
// 关键 7-1：parcel->readStrongBinder()
// 关键 7-2：javaObjectForIBinder()
return javaObjectForIBinder(env, parcel->readStrongBinder());
}
return NULL;
}
关键 7-1：parcel->readStrongBinder()
[–>Parcel.cpp, readStrongBinder()]
sp<IBinder> Parcel::readStrongBinder() const
{
sp<IBinder> val;
// 这个 this 是 reply
unflatten_binder(ProcessState::self(), *this, &val);
return val;
}
[–>Parcel.cpp, unflatten_binder()]
// 这个 in 是 reply
status_t unflatten_binder(const sp<ProcessState>& proc, const Parcel& in, sp<IBinder>* out)
{
// in（reply，Parcel 类型）能解析成 flat_binder_object？
const flat_binder_object* flat = in.readObject(false);
if (flat) {
switch (flat->type) {
case BINDER_TYPE_BINDER:
*out = reinterpret_cast<IBinder*>(flat->cookie);
return finish_unflatten_binder(NULL, *flat, in);
case BINDER_TYPE_HANDLE: // 应该走这个
// 调用 getStrongProxyForHandle()，这个方法在上面见到过，最终返回的是 BpBinder 对象
// 上面那个 handle 值为 0，这次是由 Binder 驱动程序为获取服务进程生成的，大于 0 的整数
*out = proc->getStrongProxyForHandle(flat->handle);
return finish_unflatten_binder(tatic_cast<BpBinder*>(out->get()), *flat, in);
}
}
return BAD_TYPE;
}
因为 transaction() 的过程涉及太多 Binder 驱动的底层代码，但又怕对理解 Parcel#readStrongBinder() 造成困扰，这里直接给出代码执行路线（有空会给出详细说明）
- in（reply，Parcel 类型）能解析成 flat_binder_object
- flat_binder_object 的 type 是 BINDER_TYPE_HANDLE
- flat_binder_object 的 handle 是由 Binder 驱动程序为获取服务进程生成的，值生成规律为按照服务注册的顺序，从 1 开始递增，注册的序号就是服务的句柄值（句柄值为 0 表示通信目标是 ServiceManager 进程）
[–>ProcessState.cpp, getStrongProxyForHandle()]
// 这回服务句柄 handle 传入的值是正整数
sp<IBinder> ProcessState::getStrongProxyForHandle(int32_t handle)
{
sp<IBinder> result;
AutoMutex _l(mLock);
handle_entry* e = lookupHandleLocked(handle);
if (e != NULL) {
IBinder* b = e->binder;
if (b == NULL || !e->refs->attemptIncWeak(this)) {
if (handle == 0) {
Parcel data;
status_t status = IPCThreadState::self()->transact(0, IBinder::PING_TRANSACTION, data, NULL, 0);
if (status == DEAD_OBJECT)
return NULL;
}
// 首次调用当前方法，会创建一个 BpBinder(Binder 驱动程序为获取服务进程生成的 handle) 对象（属于 Native 对象）
b = new BpBinder(handle);
e->binder = b;
if (b) e->refs = b->getWeakRefs();
// 把 BpBinder(Binder 驱动程序为获取服务进程生成的 handle) 赋给 result
result = b;
} else {
result.force_set(b);
e->refs->decWeak(this);
}
}
// 返回创建的 BpBinder(Binder 驱动程序为获取服务进程生成的 handle) 对象（属于 Native 对象）
return result;
}
因此，关键 7-1 parcel->readStrongBinder() 返回的是 BpBinder(Binder 驱动程序为获取服务进程生成的 handle) 对象（属于 Native 对象）
关键 7-2：javaObjectForIBinder()
[–>android_util_Binder.cpp, javaObjectForIBinder()]
// val 传入的是 BpBinder(Binder 驱动程序为获取服务进程生成的 handle)（属于 Native 对象）
jobject javaObjectForIBinder(JNIEnv* env, const sp<IBinder>& val)
{
if (val == NULL) return NULL;
if (val->checkSubclass(&gBinderOffsets)) {
jobject object = static_cast<JavaBBinder*>(val.get())->object();
return object;
}
// BpBinder 内部有一个成员变量 ObjectManager，这里的 findObject() 就是来查找 gBinderProxyOffsets 是否保存在 ObjectManager 中
jobject object = (jobject)val->findObject(&gBinderProxyOffsets);
// 若 gBinderProxyOffsets 已保存在 ObjectManager 中
if (object != NULL) {
jobject res = jniGetReferent(env, object);
if (res != NULL) {
return res;
}
android_atomic_dec(&gNumProxyRefs);
// 移除 ObjectManager 中保存的 gBinderProxyOffsets
val->detachObject(&gBinderProxyOffsets);
// 删除旧的 object
env->DeleteGlobalRef(object);
}
// 创建一个新的 BinderProxy 对象（Java 层对象）
object = env->NewObject(gBinderProxyOffsets.mClass, gBinderProxyOffsets.mConstructor);
if (object != NULL) {
// (jlong)val.get()：把 BpBinder(Binder 驱动程序为获取服务进程生成的 handle) 转为指针类型
// 把 BpBinder(Binder 驱动程序为获取服务进程生成的 handle) 指针类型保存到 object（上面创建的 BinderProxy）对象对应的 Native 关联对象 gBinderProxyOffsets 的 mObject 成员变量中
env->SetLongField(object, gBinderProxyOffsets.mObject, (jlong)val.get());
val->incStrong((void*)javaObjectForIBinder);
jobject refObject = env->NewGlobalRef(env->GetObjectField(object, gBinderProxyOffsets.mSelf));
// 上面已经新创建了一个 BinderProxy 对象（Java 层对象），现在可以重新把 gBinderProxyOffsets 关联到 BpBinder 成员变量 ObjectManager 中
val->attachObject(&gBinderProxyOffsets, refObject, jnienv_to_javavm(env), proxy_cleanup);
sp<DeathRecipientList> drl = new DeathRecipientList;
drl->incStrong((void*)javaObjectForIBinder);
env->SetLongField(object, gBinderProxyOffsets.mOrgue, reinterpret_cast<jlong>(drl.get()));
android_atomic_inc(&gNumProxyRefs);
incRefsCreated(env);
}
return object;
}
对于 jobject javaObjectForIBinder(JNIEnv* env, const sp<IBinder>& val)，前面分析分析过一次，这两次调用的区别在于第二个参数的不同
- 上次 val 传入的是 BpBinder(0)（属于 Native 对象）
- 本次 val 传入的是 BpBinder(Binder 驱动程序为获取服务进程生成的 handle)（属于 Native 对象）
简单概括一下 关键 7-2：javaObjectForIBinder() 执行流程，如下：
- 查看传入参数 BpBinder(Binder 驱动程序为获取服务进程生成的 handle)（属于 Native 对象）成员变量 ObjectManager 中是否保存了 gBinderProxyOffsets（是则代表之前已创建过 Java 层 BinderProxy 对象）
是：则移除 ObjectManager 中保存的 gBinderProxyOffsets（因为需要创建新的 Java 层 BinderProxy 对象，也就需要重新绑定） - 创建一个新的 BinderProxy 对象（Java 层对象）
- 把 BpBinder(Binder 驱动程序为获取服务进程生成的 handle) 转为指针类型保存到创建的 BinderProxy 对象对应 Native 关联对象 gBinderProxyOffsets 的 mObject 成员变量中
- 现在重新把 gBinderProxyOffsets 关联到 BpBinder 成员变量 ObjectManager 中（表示当前创建了一个新的 Java 层 BinderProxy 对象）
搞了半天，现在总结 android_os_Parcel_readStrongBinder 这个 native 方法到底干了啥
- 返回了一个 BinderProxy 对象（Java 层对象）
- 把 BpBinder(Binder 驱动程序为获取服务进程生成的 handle) 转为指针类型保存到 BinderProxy 对象对应的 Native 关联对象 gBinderProxyOffsets 的 mObject 成员变量中
也即是说，Java 层的 BinderProxy 对象关联着 BpBinder(Binder 驱动程序为获取服务进程生成的 handle)
再贴一下，关键七：Parcel#readStrongBinder()
解析 reply（Parcel 类型）中的数据
[–>Parcel.java, readStrongBinder()]
public final IBinder readStrongBinder() {
// 返回 BinderProxy 对象
return nativeReadStrongBinder(mNativePtr);
}
再贴一下，关键三：ActivityManager#getService()
应用进程并不是直接和 AMS 进行沟通，中间隔了个 ActivityManager，通过 ActivityManager 去获取 AMS 服务，实际上客户端进程获取的是 AMS 在客户端进程的代理对象
[–>ActivityManager.java, getService()]
public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}
private static final Singleton<IActivityManager> IActivityManagerSingleton =
new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
// 最终返回的是 AMS 对象对应的 IBinder 对象（实际为 BinderProxy 对象，属于 Java 对象）
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
// 关键八：IActivityManager.Stub.asInterface(b) 返回 AMS 在客户端进程的代理对象（实际是把 BinderProxy 对象转为 IActivityManager.Stub.Proxy 这个代理对象，因为 IActivityManager.Stub.Proxy 是 IActivityManager 的子类，所以可以返回 IActivityManager）
final IActivityManager am = IActivityManager.Stub.asInterface(b);
return am;
}
};
关键八：IActivityManager.Stub.asInterface(b) 返回 AMS 在客户端进程的代理对象，于是在 APP 客户端进程可以调用 AMS 服务端的方法
IActivityManager：定义了一系列 Activity 操作相关的接口，比如：startActivity(…)
IActivityManager.Stub 并不在 IActivityManager 中，那对应的类是谁呢？在 API 26 中，客户端进程和 AMS 的通信机制，已经被改成 AIDL 的方式了，所以我们看一下 API 26 对应 AMS 类
// AMS 继承自 IActivityManager.Stub
// 说明了 IActivityManager.Stub 相当于 AIDL 中的 Stub 类
// 因此 AMS 是 Stub 类 IActivityManager 的实现类
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
...
}
至此，我们可以知道：
ActivityManager#getService() 获取了实现了 IActivityManager 接口的那个代理对象（虽然没找到，估计在没有阉割的源码中可以找到，但是不影响我们理解客户端进程和 AMS 的通信机制所用到的 AIDL 方式的调用过程）
ActivityManagerService 继承自 IActivityManager.Stub，即 AMS 是 Stub 类 IActivityManager 的实现类
跨进程调用的流程：
代理对象#mRemote#transact(code,…) ——> Stub 对象#onTransact(code, …) {switch code: function}（抽象类）——> ActivityManagerService（Stub 的实现类）#function()
我们再看一下 ApplicationThread
// IApplicationThread.Stub：对应 AIDL 中的 Stub
// ApplicationThread 继承自 IApplicationThread.Stub
// 说明了 IApplicationThread.Stub 相当于 AIDL 中的 Stub 类
// ApplicationThread 是 Stub 类的实现类
private class ApplicationThread extends IApplicationThread.Stub {
...
// IApplicationThread 中一系列接口的实现
}
ActivityManagerService 通过 ProcessRecord#thread 对象（ApplicationThread 的代理对象），完成了 AMS 进程到应用进程的跨进程操作，如果要操作 UI，则先要通过 ActivityThread#mH（Handler）成员变量切换到主线程，然后再操作 UI
至此，APP 进程和 AMS 系统服务所在进程可以相互通信
- 通过 AMS 所在进程在 APP 进程的代理对象 BinderProxy(BpBinder(服务句柄))，可以实现在 APP（Client 端）进程可以调用 AMS（Server 端）的方法
- 通过 APP 进程在 AMS 所在进程的代理对象 ApplicationThreadProxy（这个对象的获取过程，看下面的 “四、补充：API 25 获取 AMS 的方式”），可以实现在 AMS（Client 端）进程可以调用 APP（Server 端）的方法
四、补充：API 25 获取 AMS 的方式
ActivityManagerNative#getDefault()
public abstract class ActivityManagerNative extends Binder implements IActivityManager {
static public IActivityManager asInterface(IBinder obj) {
if (obj == null) {
return null;
}
// 查询服务是否和调用端进程为同一个进程
IActivityManager in =
(IActivityManager)obj.queryLocalInterface(descriptor);
// 同一个进程
if (in != null) {
// 直接返回
return in;
}
// 不是同一个进程，返回服务在调用端进程的代理对象
// ActivityManagerProxy 是 ActivityManagerNative 的内部类
return new ActivityManagerProxy(obj);
}
/**
* Retrieve the system's default/global activity manager.
*/
static public IActivityManager getDefault() {
return gDefault.get();
}
@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
throws RemoteException {
switch (code) {
case START_ACTIVITY_TRANSACTION:
{
data.enforceInterface(IActivityManager.descriptor);
// 返回 BinderProxy 对象
IBinder b = data.readStrongBinder();
// 返回 ApplicationThreadProxy 对象（APP 进程的 ApplicationThread 在 AMS 进程中的代理对象）
IApplicationThread app = ApplicationThreadNative.asInterface(b);
...
// ActivityManagerNative 是抽象类，这里要调用实现类 AMS#startActivity(...)
// 之后 AMS 进程跨进程回调 APP 进程的方法就是通过 app（APP 进程的 ApplicationThread 在 AMS 进程中的代理对象）完成的
int result = startActivity(app, callingPackage, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profilerInfo, options);
...
return true;
}
}
public IBinder asBinder() {
return this;
}
private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
protected IActivityManager create() {
// 获取 ActivityManager 对象
IBinder b = ServiceManager.getService("activity");
// 调用 ActivityManagerNative#asInterface(ActivityManager)
IActivityManager am = asInterface(b);
return am;
}
};
}
class ActivityManagerProxy implements IActivityManager {
public ActivityManagerProxy(IBinder remote)
{
mRemote = remote;
}
public IBinder asBinder()
{
return mRemote;
}
// IActivityManager 中一系列接口的实现
public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IActivityManager.descriptor);
// APP 进程把 caller.asBinder() 转为 IBinder 对象传递给 AMS 进程
data.writeStrongBinder(caller != null ? caller.asBinder() : null);
...
// 调用到 ActivityManagerNative#onTransact()
// 当前线程挂起，根据 START_ACTIVITY_TRANSACTION 这个 code 去执行 ActivityManagerNative#onTransact() 中对应的方法
mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
...
}
...
}
ActivityManagerService
// ActivityManagerService 继承自 ActivityManagerNative
// 也说明了 ActivityManagerNative 相当于 AIDL 中的 Stub 类
// ActivityManagerService 是 Stub 类 ActivityManagerNative 的实现类
public final class ActivityManagerService extends ActivityManagerNative
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
...
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
resultWho, requestCode, startFlags, profilerInfo, bOptions,
UserHandle.getCallingUserId());
}
...
}
startActivity() 跨进程调用的流程：
① 调用代理对象的 startActivity()
ActivityManagerNative#getDefault() ——> ActivityManagerProxy（AMS 在客户端进程的代理对象）#startActivity()
② transact 调用（ActivityManagerNative 是抽象类，需要去调用实现类 AMS 的方法）
ActivityManagerProxy#mRemote#transact(code, …) ——> ActivityManagerNative#onTransact(code, …) {switch code: startActivity();}
③ 调用实现类的 startActivity()
ActivityManagerService（Stub 的实现类）#startActivity()
4263
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
