ActivityManagerService


ActivityManagerService(AMS)主要负责系统中四大组件的启动、切换、调度以及应用程序的管理和调度工作,其职责与操作系统中的进程管理和调度模块类似。

ActivityManagerService 进行初始化的时机很明确,就是在 system_server 进程开启的时候,就会初始化 ActivityManagerService。(启动 APP 的时候,是需要 AMS 通知 Zygote 进程,所有的 Activity 的生命周期都需要 AMS 来控制)
ActivityThread 在 Android 中代表主线程,在 APP 进程创建完成之后,就会加载 ActivityThread.main 函数,然后执行 Looper.loop() 循环,使当前线程进入消息循环。

ApplicationThread 是 ActivityThread 的内部类,继承了 IApplicationThread.Stub。如果需要在目标进程中启动 Activity,就要通过 ApplicationThread 与 AMS 所在的进程(system_server 进程)进行通信。



ActivityManager

ActivityManager 是一个和 AMS 相关联的类,主要是对运行中的 Activity 进行管理,但是,这些管理工作并不是直接由 ActivityManager 管理的,而是交由 AMS 来处理。
ActivityManager 中的方法会通过 ActivityManagerNative(AMN).getDefault() 方法来得到 ActivityManagerProxy(AMP),通过 AMP 就可以和 AMN 进行通信。AMN 是一个抽象类,它将功能交给它的子类 AMS 来处理,因此,AMP 就是 AMS 的代理类。

public interface IInterface{
    public IBinder asBinder();
}

public interface IBinder { 
    public boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException;
}

public class Binder implements IBinder { }

public interface IActivityManager extends IInterface { }

public abstract class ActivityManagerNative extends Binder 
        implements IActivityManager { 
            class ActivityManagerProxy implements IActivityManager { }
}
public final class ActivityManagerService extends ActivityManagerNative
    implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback { 



}

AMS 作为系统服务,很多 API 是不会暴露给 ActivityManager 的,因此 ActivityManager 并不算是 AMS 家族中的一份子。在 Activity 的启动过程中会调用 Instrumentation.execStartActivity 方法:

```java
// /frameworks/base/core/java/android/app/Instrumentation.java
public ActivityResult execStartActivity(
    ...
    try {
        intent.migrateExtraStreamToClipData();
        intent.prepareToLeaveProcess(who);
        int result = ActivityManagerNative.getDefault()
            .startActivity(whoThread, who.getBasePackageName(), intent,
                           intent.resolveTypeIfNeeded(who.getContentResolver()),
                           token, target, requestCode, 0, null, options);
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    return null;
}

AMS 和 ActivityThread 之间,比如 Activity 的创建、暂停等交互工作实际上是由 Instumentation 具体操作的。每个 Activity 都持有一个 Instrumentation 对象的引用,整个进程中也只有一个 Instrumentation。mInstrumentation 的初始化在 ActivityThread.handleBindApplication 函数中,可以用来独立地控制某个组件的生命周期。Activity.startActivity 方法调用 mInstrumentation.execStartActivity 方法,最终,通过 AMS 告知 Zygote 进程 fork 子进程。

// /frameworks/base/core/java/android/app/ActivityThread.java
private void handleBindApplication(AppBindData data) {
    ...
    if (ii != null) {
        ...
        try {
            final ClassLoader cl = instrContext.getClassLoader();
            mInstrumentation = (Instrumentation)
                cl.loadClass(data.instrumentationName.getClassName()).newInstance();
        } catch (Exception e) {
            throw new RuntimeException(
                "Unable to instantiate instrumentation "
                + data.instrumentationName + ": " + e.toString(), e);
        }
        ...
    } else {
        mInstrumentation = new Instrumentation();
    }

}


在 Instrumentation.execStartActivity 方法中会调用 ActivityManagerNative(AMN).getDefault() 方法来获取 AMS 的代理类 AMP,接着调用了 ActivityManagerProxy(AMP).startActivity 方法。 首先来看 ActivityMangerNative.getDefault() 方法:

// /frameworks/base/core/java/android/app/ActivityManagerNative.java
static public IActivityManager getDefault() {
    return gDefault.get();
}

private static final Singleton gDefault = new Singleton() {
    protected IActivityManager create() {
        IBinder b = ServiceManager.getService("activity"); // 1
        if (false) {
            Log.v("ActivityManager", "default service binder = " + b);
        }
        IActivityManager am = asInterface(b); // 2
        if (false) {
            Log.v("ActivityManager", "default service = " + am);
        }
        return am;
    }
};

// frameworks/base/core/java/android/util/Singleton.java
public abstract class Singleton {
    private T mInstance;

    protected abstract T create();

    public final T get() {
        synchronized (this) {
            if (mInstance == null) {
                mInstance = create();
            }
            return mInstance;
        }
    }
}

在 ActivityManagerNative.getDefault() 方法中调用了 gDefault.get() 方法,gDefault 是一个 Singleton 类。在注释1 处得到名为 “activity” 的 Service 引用,也就是 IBinder 类型的 AMS 的引用。接着在注释 2 处将它封装成 AMP 类型对象,并将它保存到 gDefault 中,此后调用 ActivityManagerNative.getDefault() 方法就会直接获取 AMS 的代理对象 AMP。 注释 2 处的 asInterface 方法如下所示:

// /frameworks/base/core/java/android/app/ActivityManagerNative.java
static public IActivityManager asInterface(IBinder obj) {
    if (obj == null) {
        return null;
    }
    IActivityManager in =
        (IActivityManager)obj.queryLocalInterface(descriptor); // 1
    if (in != null) {
        return in;
    }

    return new ActivityManagerProxy(obj); // 2
}

注释 1 处的 descriptor 值为 android.app.IActivityManager,注释 1 处的代码主要用来查询本地进程是否有 IActivityManager 接口的实现,如果有则返回,如果没有,就在注释 2 处将 IBinder 类型的 AMS 引用封装成 AMP,AMP 的构造方法如下所示:

// /frameworks/base/core/java/android/app/ActivityManagerNative.java
 class ActivityManagerProxy implements IActivityManager {
    public ActivityManagerProxy(IBinder remote) {
        mRemote = remote;
    }
    ...
}

在 AMP 的构造方法中将 AMS 的引用赋值给变量 mRemote,这样在 AMP 中就可以使用 AMS 了。其中,IActivityManager 是一个接口,AMN 和 AMP 都实现了这个接口,用于实现代理模式和 Binder 通信。
再回到 Instrumentation.execStartActivity 方法中,查看 ActivityManagerProxy(AMP).startActivity 方法,AMP 是 AMN 的内部类,代码如下所示:

// ActivityManagerService.java
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 {
    ...
    data.writeInt(requestCode);
    data.writeInt(startFlags);
    ...
    mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0); // 1
    reply.readException();
    int result = reply.readInt();
    reply.recycle();
    data.recycle();
    return result;
}

首先将传入的参数写入到 Parcel 类型的 data 中。在注释 1 处,通过 IBinder 类型对象 mRemote(AMS 的引用)向服务端的 AMS 发送一个 START_ACTIVITY_TRANSACTION 类型的进程间通信请求,之后,服务端 AMS 就会从 Binder 线程池中读取客户端发来的数据,最终会调用 ActivityManagerNative.onTransact 方法,如下所示:

@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
    throws RemoteException {
    switch (code) {
        case START_ACTIVITY_TRANSACTION:
            {
                ...
                int result = startActivity(app, callingPackage, intent, resolvedType,
                       resultTo, resultWho, requestCode, startFlags, profilerInfo, options);
                reply.writeNoException();
                reply.writeInt(result);
                return true;
            }
          ...
    }


本站内容来源于作者发布和网络转载,如有版权相关问题请及时与我们取得联系,我们将立即删除。

 关于作者
 热门教程
系统启动流程
1、BootRom 启动电源以及系统启动。 当电源按下时,引导芯片代码从预定义的地方(固化在ROM中)开始执行。加载引
2023-09-10
剑道仙尊
36
Android源码开始
Framework源码下载: https://android.googlesource.com/platform/fr
2023-09-10
剑道仙尊
39
Launcher的Activity.onCreate
进入 ActivityThread.main,最终完成 Launcher.onCreate 操作 Zygote for
2022-09-11
剑道仙尊
28
Launcher启动流程
Launcher介绍 系统启动的最后一步是启动一个应用程序来显示系统中已经安装的应用程序,这个应用程序就叫做 Laun
2022-09-11
剑道仙尊
27
创建Launcher进程
Zygote进程接收请求并创建 Launcher进程 想要启动一个应用程序,首先要保证这个应用程序所需要的应用程序进程
2022-09-11
剑道仙尊
33
Launcher的配置
Launcher 的配置 在 SystemServer.startOtherServices 方法中调用Activit
2022-09-11
剑道仙尊
35
PackageManagerService
PackageManagerService( PMS ) 1、PMS会把每个apk进行扫描,然后分别把每个apk里的信
2022-09-11
剑道仙尊
35
WindowManagerService
待更新。。。
2022-09-11
剑道仙尊
16
ActivityManagerService
ActivityManagerService(AMS)主要负责系统中四大组件的启动、切换、调度以及应用程序的管理和调度
2022-09-11
剑道仙尊
27
systemserver进程
system server进程是由zygote进程fork出来的,在上面的ZygoteInit.main方法中调用fo
2022-09-10
剑道仙尊
23
 友情链接