blue_fen

Framework学习之路（一）—— UI绘制深入源码分析

本篇为笔者对Android SDK 33版本的UI绘制入口进行追踪的过程，主要作笔记作用。由于笔者经验尚浅，水平也有限，所以会存在很多不足的地方。如果有大神发现问题，可以在评论区指出。

章节目录：

一、APP程序入口

1、 ActivityThread的main方法、重要属性及其父类的介绍

1. ActivityThread及其main函数的介绍

2. ActivityThread重要属性的介绍

3. 启动主线程的Looper

4. ActivityThread的父类ClientTransactionHandler

2、 Application的创建与启动

1. 创建ActivityThread实例

2. 通过AMS获取Application信息

3. 创建Instrumentation实例

4. 创建Application实例

5. 启动Application

3、Activity的创建和启动

1. 系统进程的准备工作

(1) ActivityTaskManagerService

(2) WindowContainer

(3) ClientTransaction

[1] 初始化mDecor属性

[2] 初始化mContentParent属性

附录：ActivityTaskManagerService的启动

2. 创建Activity实例

附录：AppComponentFactory

3. 启动Activity

二、UI绘制流程

1、Activity加载XML文件的过程

1. PhoneWindow的初始化

(1) 创建PhoneWindow

(2) PhoneWindow的重要属性——mDecor和mContentParent

(3) mDecor和mContentParent属性的初始化

附录一：常见的根布局——screen_simple.xml

附录二：DecorVIew添加RootView

2. 加载自定义布局

2、AppCompatActivity加载XML文件的过程

1. 初始化PhoneWIndow的mDecor和mDecorContentParent属性

2. 初始化AppCompatDelegateImpl的mSubDecor属性

3.加载自定义布局

附录一：简单根布局abc_screen_simple.xml

3、UI绘制过程

1. 调用Activity的onResume方法

2. ViewRootImpl进行UI绘制的过程

(1) View绘制三大流程的入口

(2) View绘制三大流程之onMeasure方法

(3) View绘制三大流程之onLayout方法

(4) View绘制三大流程之onDraw方法

附录一：将ViewRootImpl添加为DecorView的父布局

附录二：UI线程检查

一、APP程序入口

1、ActivityThread的main方法、重要属性及其父类的介绍

1. ActivityThread及其main函数的介绍

/**
* ActivityThread是一个handeler类，这个看他的父类就可以知道
*/
public final class ActivityThread extends ClientTransactionHandler {
    ...
    public static void main(String[] arg) {
        //CloseGuard类实现了一种机制用于检查是否有内存泄露，，默认是关闭的，可以通过setEnabled(true)开启
        CloseGuard.setEnabled(false);
        
        //初始化Environment类，主要是一些目录的设置
        //比如我们通常用的获取外部储存路径的函数Environment.getExternalStorageDirectory()的返回值就是在这里进行初始化的
    	Environment.initForCurrentUser();
        
        //确保 TrustedCertificateStore 在正确的位置查找 CA 证书
        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
        TrustedCertificateStore.setDefaultUserDirectory(configDir);
        
        //调用每个进程的主线模块初始化
        initializeMainlineModules();
        
        //初始化Handler中的Looper对象
        Looper.prepareMainLooper();
        
        ...
        //创建一个ActivityThread    
        ActivityThread thread = new ActivityThread();
        thread.attach(false, startSeq);
		//初始化专门处理消息的handler对象
        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }
        
        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        // End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        //开始循环主线程里面的MessageQueue
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
    ...
}

2. ActivityThread重要属性的介绍

首先我们需要知道一点，ActivityThread不会持有Activity或者ActivityThread里面的任何东西，真正管理我们application或者activity的是AMS或者PMS。ActivityThread就是一个handler，它会不停的和我们的AMS或者PMS进行通信，然后得到结果，再来通过消息队列来执行它的handlerMessage。

我们接着看ActivityThread的几个主要的属性：

mAppThread： ActivityThread不能直接和系统进行通讯，需要通过Binder，所以我们用ActivityTread的main方法不能直接获取Application（也就是不能直接启动应用），需要通过作为桥梁的ApplicationThread进行调用。而AMS作为桥梁的一端，会持有我们的ApplicationThread，然后来进行回调。（这里注意ApplicationThread是ActivityThread的子类）
mLooper：ActivityThread作为一个handler想持续不停的往MessageQueue里面拿消息，肯定需要looper一直去轮询，也就是这里的mLooper属性。
mInstrumentation： Instrumentation是所有的Application和Activity用来跟踪生命周期的类。ActivityThread不会直接的去执行某一个组件的生命周期方法，比如对于Application和Activity，它真正的启动是经过Instrumentation，Instrumentation是真正管理它们生命周期的类

public final class ActivityThread extends ClientTransactionHandler {
    //ApplicationThread是ActivityThread与AMS通讯的桥梁，它作为服务端，接收ActivityManagerService的指令并执行
    final ApplicationThread mAppThread = new ApplicationThread();

    final Looper mLooper = Looper.myLooper();
    ...  
    //真正管理Activity生命周期的类
    Instrumentation mInstrumentation;  
}

3. 启动主线程的Looper

//ActivityThread.java#main
Looper.prepareMainLooper(); //初始化Handler中的Looper对象

//Looper.java
...
private static Looper sMainLooper;  
...
public static void prepareMainLooper() {
    //设置当前线程为不可退出的线程
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        //将主线程赋值给sMainLooper，这也是我们可以直接通过Looper.getMainLooper()获取主线程的原因
        sMainLooper = myLooper();
    }
}

public static Looper getMainLooper() {
    synchronized (Looper.class) {
        return sMainLooper;
    }
}

这里我们注意，main方法运行完就退出了，但是我们有个looper.loop，一直在循环的接受消息和发送消息，所以它会一直在运行，不会退出。

//ActivityThread.java#main
Looper.loop(); //开始循环主线程里面的MessageQueue

4. ActivityThread的父类ClientTransactionHandler

个人见解：ClientTransactionHandler既然是Handler，显然它会具备sendMessage方法，不过它并没有继承我们熟悉的Handler类，也就是说它虽然具备处理消息的职责，但真正处理消息的可能另有其人，比如ActivityThread就把真正处理消息的任务下发给了Handler类型的mH成员变量，这个后面会讲。

//ClientTransactionHandler.java
abstract void sendMessage(int what, Object obj);

我们看到ClientTransactionHandler里面有很多和Activity的生命周期有关的方法。

public abstract class ClientTransactionHandler {
    ...
	public abstract void handleDestroyActivity(@NonNull ActivityClientRecord r, boolean finishing,
            int configChanges, boolean getNonConfigInstance, String reason);

    public abstract void handlePauseActivity(@NonNull ActivityClientRecord r, boolean finished,
            boolean userLeaving, int configChanges, PendingTransactionActions pendingActions,
            String reason);

    public abstract void handleResumeActivity(@NonNull ActivityClientRecord r,
            boolean finalStateRequest, boolean isForward, String reason);
    
    public abstract void handleTopResumedActivityChanged(@NonNull ActivityClientRecord r,
            boolean isTopResumedActivity, String reason);

    public abstract void handleStopActivity(@NonNull ActivityClientRecord r, int configChanges,
            PendingTransactionActions pendingActions, boolean finalStateRequest, String reason);
	...
}

AMS通过ApplicationThread封装好数据，回调到ActivityThread，ActivityThread就可以通过发通知的方式，发给Handler，然后通过Handler的方法来执行相应的操作。

我们发现AMS->ApplicationThread->ActivityThread三者之间的分工非常明确，有点像MVP模式：

AMS（M层）：数据管理者。
ApplicationThread（P层）：通讯桥梁。
ActivityThread（V层）：具体逻辑的执行者。

这里有一点值得注意，Activity是在主线程中创建的，也就说ActivityThread的main方法所在的线程就是APP的主线程，这点在上面看到ActivityThread的Looper时就可见一斑。因为主线程是main方法所在的线程，也就是APP进程的第一个线程，所以主线程无法修改。

2、 Application的创建与启动

1. 创建ActivityThread实例

我们启动应用，就必须先创建Application。由于不确定项目中具体的Application类，所以不能通过new来创建，而是需要通过AMS去获取Application的类名信息，再通过反射将它实例化；若AMS获取不到，再使用new的方式创建默认的Application。

//ActivityThread.java#main   
ActivityThread thread = new ActivityThread();//创建一个ActivityThread 
thread.attach(false, startSeq);

2. 通过AMS获取Application信息

我们先看看attach方法做了什么？

//ActivityThread.java   
private static volatile ActivityThread sCurrentActivityThread;
...
final ApplicationThread mAppThread = new ApplicationThread();
...
private void attach(boolean system, long startSeq) {   
    //ActivityThread赋值给自己的静态成员变量，是为了方便外部通过静态方法调用自己，算是单例模式的变种
    sCurrentActivityThread = this;
    ... 
    //获取到ActivityManagerService的代理对象IActivityManager
    final IActivityManager mgr = ActivityManager.getService();
    try {
        //调用AMS的attachApplication方法，mAppThread作为沟通桥梁传入该方法
        mgr.attachApplication(mAppThread, startSeq);   //PS:这里是AMS在attach方法里唯一调用地方
    } catch (RemoteException ex) {
        throw ex.rethrowFromSystemServer();
    }
    ...
}

我们看一下上面的IActivityManager的代理接口是如何获取的？

//ActivityThread.java#attach
final IActivityManager mgr = ActivityManager.getService();

//ActivityManager.java#getService
public static IActivityManager getService() {
    return IActivityManagerSingleton.get();
}

private static final Singleton<IActivityManager> IActivityManagerSingleton =
    new Singleton<IActivityManager>() {
    @Override
    protected IActivityManager create() {
        //通过binder机制进行进程通讯 从Activity系统服务中获取到AMS的代理对象
        final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
        final IActivityManager am = IActivityManager.Stub.asInterface(b);
        return am;
    }
};

我们可以看到IActivityManager从系统服务管理者ServiceManager中获取到了可以和系统服务进程的AMS进行远程通讯Binder通道。

接下来看看ActivityThread的attach方法，在获取AMS的代理对象后，做了什么事情？

//ActivityThread.java#attach
mgr.attachApplication(mAppThread, startSeq);

//ActivityManagerService.java#attachApplication
@Override
public final void attachApplication(IApplicationThread thread, long startSeq) {
    if (thread == null) {
        throw new SecurityException("Invalid application interface");
    }
    synchronized (this) {
        //从Binder中获取到一些进程信息
        int callingPid = Binder.getCallingPid();
        final int callingUid = Binder.getCallingUid();
        final long origId = Binder.clearCallingIdentity();
        attachApplicationLocked(thread, callingPid, callingUid, startSeq); //* 重点方法
        Binder.restoreCallingIdentity(origId);
    }
}

//ActivityManagerService.java#attachApplicationLocked
private boolean attachApplicationLocked(@NonNull IApplicationThread thread,
            int pid, int callingUid, long startSeq) {
    ///(1)
    //查找正在附加的应用程序记录...
    //如果我们在多个进程中运行，则通过PID，或者如果我们使用匿名线程模拟进程，则只需拉取下一个应用程序记录。
    ProcessRecord app; //(2) 储存进程信息，attachApplicationLocked方法里面存在大量对该对象及其属性进行赋值的代码
   	...
    //(3)
        if (app.getIsolatedEntryPoint() != null) {
            // This is an isolated process which should just call an entry point instead of
            // being bound to an application.
            thread.runIsolatedEntryPoint(
                app.getIsolatedEntryPoint(), app.getIsolatedEntryPointArgs());
        } else if (instr2 != null) {
            thread.bindApplication(processName, appInfo,
                                   app.sdkSandboxClientAppVolumeUuid, 
                                   app.sdkSandboxClientAppPackage,
                                   ...);
        }else {
            thread.bindApplication(processName, appInfo, 
                                   app.sdkSandboxClientAppVolumeUuid, 
                                   app.sdkSandboxClientAppPackage,
                                   ...);
        }
    ...
}

//ActivityThread$ApplicationThread.java#bindApplication
@Override
public final void bindApplication(String processName, ApplicationInfo appInfo,
                                  String sdkSandboxClientAppVolumeUuid, String sdkSandboxClientAppPackage,
                                  ...) {
	...
    AppBindData data = new AppBindData(); //(4)
    data.processName = processName;
    data.appInfo = appInfo;
    ...  
    sendMessage(H.BIND_APPLICATION, data); //(5)
}

//ActivityThread.java#sendMessage
 private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
     if (DEBUG_MESSAGES) {
         Slog.v(TAG,
                "SCHEDULE " + what + " " + mH.codeToString(what) + ": " + arg1 + " / " + obj);
     }
     Message msg = Message.obtain();
     msg.what = what;
     msg.obj = obj;
     msg.arg1 = arg1;
     msg.arg2 = arg2;
     if (async) {
         msg.setAsynchronous(true);
     }
     mH.sendMessage(msg); //(6)
 }

//ActivityThread$H.java#handleMessage
 public void handleMessage(Message msg) {
     if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
     switch (msg.what) {
         case BIND_APPLICATION:
             Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
             AppBindData data = (AppBindData)msg.obj;
             handleBindApplication(data); //(7)
             Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
             break;
             ...
     }
     ...
 }

① 在创建Application之前，要从AMS中获取Application的一些比较重要的信息。比如我们的Application到底是自己创建的，还是别人传过来的？还是系统原生的，或者系统自带的，或者系统自己创建的？我们都要进行判断，而这些信息都保留在AMS里面。

② ProcessRecord是进程记录者，该类专门储存当前进程的所有信息，这就说明它也保存了Application的一些信息。（该类存在很多成员变量，如果我们看到类似的成员变量多的类，就可以把它认为是专门储存数据的类）

③ AMS将数据封装到ProcessRecord等变量之后，通过传入大量参数的形式将信息回调给IApplicationThread。

④ ActivityThread.AppBindData是应用数据的封装类，ApplicationThread把AMS传过来的数据全部都传给了AppBindData，也就是说AppBindData携带了Application的信息。

⑤ 将AppBindData传递给ActivityThread的sendMessage方法。（因为ApplicationThread并不是ActivityThread静态内部类，所以可以直接调用ActivityThread的方法）

⑥ ActivityThread里面所有的通知最终都是在mH里面进行了具体的操作，这个上面有提到。

⑦ handleBindApplication方法对Application进行了绑定。

本小节后续内容，都会在handleBindApplication方法里面展开，我们会看到ActivityThread在handleBindApplication方法里面依次创建了Instrumentation、Application，然后调用了Application的onCreate方法。

3. 创建Instrumentation实例

//ActivityThread.java#handleBindApplication
private void handleBindApplication(AppBindData data) {
	...
    //mInstrumentation在这里进行了初始化
    if (ii != null) {
        initInstrumentation(ii, data, appContext); //* 重点方法
    } else {
        mInstrumentation = new Instrumentation();
        mInstrumentation.basicInit(this);
    }
    ...
}

//ActivityThread.java#initInstrumentation
private void initInstrumentation(
            InstrumentationInfo ii, AppBindData data, ContextImpl appContext) {
    ...
    try {       
        final ClassLoader cl = instrContext.getClassLoader();
        mInstrumentation = (Instrumentation)
            cl.loadClass(data.instrumentationName.getClassName()).newInstance(); //通过反射的方式来创建mInstrumentation的实例
    } catch (Exception e) {
        throw new RuntimeException(
            "Unable to instantiate instrumentation "
            + data.instrumentationName + ": " + e.toString(), e);
    }
    ...
}

4. 创建Application实例

initInstrumentation方法执行结束后，我们得到了mInstrumentation实例，接着我们重新回到ActivityThread的handleBindApplication方法这里，看看Application是如何创建的。

//ActivityThread.java#handleBindApplication
private void handleBindApplication(AppBindData data) {
	...
    //mInstrumentation初始化完成后开始创建Application对象
    Application app;
    ...
    app = data.info.makeApplicationInner(data.restrictedBackupMode, null); //通过LoadedApk创建application
    ...
}

//LoadedApk.java#makeApplicationInner
public final class LoadedApk {
    ...
    //application缓存的实例
    private Application mApplication; 
    ...
    //我们在此处缓存此进程中每个包的实例化应用程序对象。
    private static final ArrayMap<String, Application> sApplications = new ArrayMap<>(4);
    ...
    public Application makeApplicationInner(boolean forceDefaultAppClass,
                                            Instrumentation instrumentation) {
        return makeApplicationInner(forceDefaultAppClass, instrumentation,
                                    /* allowDuplicateInstances= */ false);
    }

    private Application makeApplicationInner(boolean forceDefaultAppClass,
                Instrumentation instrumentation, boolean allowDuplicateInstances) {
        if (mApplication != null) {
            //如果application已经存在，则直接返回
            return mApplication; 
        }
        ...
        //从缓存的sApplications集合中尝试获取Application
        synchronized (sApplications) {
            final Application cached = sApplications.get(mPackageName); 
            if (cached != null) {
                ...
                if (!allowDuplicateInstances) {
                    mApplication = cached;
                    return cached;
                }
            }
        }
        
        //创建Application对象
      	Application app = null;
        ...
        //获取application类名
        String appClass = mApplicationInfo.getCustomApplicationClassNameForProcess(myProcessName);       
        if (forceDefaultAppClass || (appClass == null)) {
            appClass = "android.app.Application";
        }
        ...
            app = mActivityThread.mInstrumentation.newApplication(cl, appClass, appContext); //(1)
        ...            
        //缓存Application
       	mActivityThread.mAllApplications.add(app);
        mApplication = app;
        if (!allowDuplicateInstances) {
            synchronized (sApplications) {
                sApplications.put(mPackageName, app);
            }
        }
    }
}

//Instrumentation.java#newApplication
public Application newApplication(ClassLoader cl, String className, Context context)
    throws InstantiationException, IllegalAccessException, 
ClassNotFoundException {
    Application app = getFactory(context.getPackageName()).instantiateApplication(cl, className);
    app.attach(context); //application创建后，调用了attach方法，而attach方法里面调用了我们熟知的attachBaseContext方法。
    return app;
}

//AppComponentFactory.java#instantiateApplication
public @NonNull Application instantiateApplication(@NonNull ClassLoader cl,
                                                   @NonNull String className)
    throws InstantiationException, IllegalAccessException, ClassNotFoundException {
    return (Application) cl.loadClass(className).newInstance(); //(2) 这里就是通过类加载器最终创建了我们的Application
}

① ActivityThread通过的mInstrumentation来创建Application实例。我们之前提过，Application和Activity包括创建和生命周期等操作都是由mInstrumentation来监管的。

② Instrumentation最终通过AppComponentFactory的instantiateApplication方法，使用类加载器创建了Application。

5. 启动Application

我们继续看handleBindApplication方法，在mInstrumentation和app都创建完成后，我们继续跟踪mInstrumentation，就可以看到它使用callApplicationOnCreate方法调用了app的onCreate方法，mInstrumentation监听Application和Activity其实都是通过这样的方式。

调用了onCreate方法后，Application就已经启动了。

//ActivityThread.java#handleBindApplication
private void handleBindApplication(AppBindData data) {
    ...
	mInstrumentation.callApplicationOnCreate(app);
    ...
}

//Instrumentation.java#callApplicationOnCreate
public void callApplicationOnCreate(Application app) {
    app.onCreate();
}

3、Activity的创建和启动

1. 系统进程的准备工作

(1) ActivityTaskManagerService

前面我们在ActivityManagerService的attachApplicationLocked方法中创建了Application，创建完成后，也会在该方法中创建Activity。

个人见解：attachApplicationLocked方法中必然创建了Actiivity，我们回顾上面的ActivityThread的main方法调用AMS的代码，发现只有attach方法沟通了AMS，追踪后可以发现attach方法调用的AMS方法中，核心逻辑都在attachApplicationLocked方法里面，也就是说在应用启动过程中，attachApplicationLocked方法就是AMS的核心逻辑，这也就意味着启动Application和MainActivity的逻辑也必然在此方法中。

所以我们就attachApplicationLocked方法往下跟踪，发现application启动后，执行了下面的代码。

//ActivityManagerService.java#attachApplicationLocked
private boolean attachApplicationLocked(@NonNull IApplicationThread thread,
            int pid, int callingUid, long startSeq) {
    ...
    // 查看此进程中最可见的活动是否正在等待运行...
    if (normalMode) {
        try {
            didSomething = mAtmInternal.attachApplication(app.getWindowProcessController()); // (1)
        } catch (Exception e) {
            Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
            badApp = true;
        }
    }

    //查找应在此进程中运行的任何服务...
    if (!badApp) {
        try {
            didSomething |= mServices.attachApplicationLocked(app, processName); // (2)
            checkTime(startTime, "attachApplicationLocked: after mServices.attachApplicationLocked");
        } catch (Exception e) {
            Slog.wtf(TAG, "Exception thrown starting services in " + app, e);
            badApp = true;
        }
    }

}

①Activity创建与启动的逻辑就在mAtmInternal的attachApplicationLocked方法中。

② mServices是ActiveServices，其attachApplicationLocked方法创建的是Service而不是Activity，这里不要搞混。

那么我们来看看mAtmInternal究竟是谁？

//ActivityManagerService.java
public ActivityTaskManagerInternal mAtmInternal;

//ActivityTaskManagerInternal.java
public abstract class ActivityTaskManagerInternal {
    ...
}

//ActivityManagerService.java#Constructor
public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
    ...
    mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class); //这里创建并启动了Activity
    ...
}

//LocalServices
public final class LocalServices {
    ...
    private static final ArrayMap<Class<?>, Object> sLocalServiceObjects =
            new ArrayMap<Class<?>, Object>();
    
    /**
    * 返回实现指定接口的本地服务实例。
    * 参数：类型 – 服务的类型。
    * 返回：服务对象。
    */
 	public static <T> T getService(Class<T> type) {
        synchronized (sLocalServiceObjects) {
            return (T) sLocalServiceObjects.get(type);
        }
    }

    /**
     * 将指定接口的服务实例添加到本地服务的全局注册表中。
     */
    public static <T> void addService(Class<T> type, T service) {
        synchronized (sLocalServiceObjects) {
            if (sLocalServiceObjects.containsKey(type)) {
                throw new IllegalStateException("Overriding service registration");
            }
            sLocalServiceObjects.put(type, service);
        }
    }   
    
    ...       
}

mAtmInternal是AMS的成员变量，是ActivityTaskManagerInternal抽象类型的实例对象。从AMS的构造方法中，可以发现mAtmInternal是来自LocalServices缓存的某个服务。

这时候想要知道mAtmInternal究竟是什么类型的对象，我们就需要知道是谁把它存到了LocalServices中，但这并不好找。

干脆以“ActivityTaskManager”这个字段来搜索，这时候就发现了一个可疑的类型：ActivityTaskManagerService（ActivityTaskManagerService的启动见本节附录）。

搜索一下“ActivityTaskManagerInternal.class”，果然找到了mAtmInternal的入口。

//ActivityTaskManagerService.java
...
final ActivityTaskManagerInternal mInternal;
...
public ActivityTaskManagerService(Context context) {
    ...
    mInternal = new LocalService();
    ...
}
...
private void start() {
	LocalServices.addService(ActivityTaskManagerInternal.class, mInternal); //ActivityManagerService#mAtmInternal的来源
}

我们发现mInternal是LocalService类型的对象（注意这个LocalService并不是缓存服务的LocalServices），而LocalService是ActivityTaskManagerService的内部类。

//ActivityTaskManagerService$LocalService.java
final class LocalService extends ActivityTaskManagerInternal {
	...
    @Override
    public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
        synchronized (mGlobalLockWithoutBoost) {
            if (Trace.isTagEnabled(TRACE_TAG_WINDOW_MANAGER)) {
                Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "attachApplication:" + wpc.mName);
            }
            try {
                return mRootWindowContainer.attachApplication(wpc); //* 核心方法
            } finally {
                Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
            }
        }
    }
	...
}

(2) WindowContainer

//ActivityTaskManagerService$LocalService.java#attachApplication
public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
    ...
    return mRootWindowContainer.attachApplication(wpc);
    ...
}

//ActivityTaskManagerService.java
RootWindowContainer mRootWindowContainer;

RootWindowContainer是窗口容器（WindowContainer）的根容器，管理所有的窗口容器，设备上所有的窗口（Window）、显示屏幕（Display）都是由它来管理的。

//RootWindowContainer.java
class RootWindowContainer extends WindowContainer<DisplayContent>
        implements DisplayManager.DisplayListener {
    ...
    private final AttachApplicationHelper mAttachApplicationHelper = new AttachApplicationHelper();
    ...
    boolean attachApplication(WindowProcessController app) throws RemoteException {
        try {
            return mAttachApplicationHelper.process(app);
        } finally {
            mAttachApplicationHelper.reset();
        }
    }
    
    private class AttachApplicationHelper implements Consumer<Task>, Predicate<ActivityRecord> {
        ...
        private ActivityRecord mTop;
        ...
        boolean process(WindowProcessController app) throws RemoteException {
            mApp = app;
            for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
                getChildAt(displayNdx).forAllRootTasks(this); //(1)
                if (mRemoteException != null) {
                    throw mRemoteException;
                }
            }
            if (!mHasActivityStarted) {
                ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,
                        false /* preserveWindows */);
            }
            return mHasActivityStarted;
        }
        
        @Override
        public void accept(Task rootTask) { 
            if (mRemoteException != null) {
                return;
            }
            if (rootTask.getVisibility(null /* starting */)
                    == TASK_FRAGMENT_VISIBILITY_INVISIBLE) {
                return;
            }
            mTop = rootTask.topRunningActivity(); //(2)
            rootTask.forAllActivities(this);
        }
        ...
    }
}

① 遍历RootWindowContainer所有的窗口和显示屏幕，这里最终会调用AttachApplicationHelper的accept方法

② Task用来描述一个Activity任务栈，而ActivityRecord记录了Activity的所有信息。这里是通过调用rootTask的topRunningActivity方法获取到栈顶Activity的信息，然后存到了mTop。（这里栈顶Activity并不是我们熟知的Activity，而是记录Activity配置信息的ActivityRecord）

//Task.java#topRunningActivity
class Task extends TaskFragment {
    ActivityRecord topRunningActivity(IBinder token, int taskId) {
        final PooledPredicate p = PooledLambda.obtainPredicate(Task::isTopRunning,
        PooledLambda.__(ActivityRecord.class), taskId, token);
        final ActivityRecord r = getActivity(p);
        p.recycle();
        return r;
	}
}

//TaskFragment.java
class TaskFragment extends WindowContainer<WindowContainer> {
    ...
}

//WindowContainer.java#getActivity
class WindowContainer<E extends WindowContainer> extends ConfigurationContainer<E>
        implements Comparable<WindowContainer>, Animatable, SurfaceFreezer.Freezable,
        InsetsControlTarget {
    ActivityRecord getActivity(Predicate<ActivityRecord> callback, boolean traverseTopToBottom,
                ActivityRecord boundary) {
         ...
         for (int i = mChildren.size() - 1; i >= 0; --i) {
             final WindowContainer wc = mChildren.get(i);
             ...
             final ActivityRecord r = wc.getActivity(callback, traverseTopToBottom, boundary);
             ...
         }
         ...
    }
}

Task的topRunningActivity方法最终调用了WindowContainer的getActivity方法，该方法遍历Task下所有的窗口。

得到了ActivityRecord后，接着调回了RootWindowContainer$AttachApplicationHelper.java的test方法，尝试创建并启动Activity。

(PS：accept方法和test方法的具体调用方还没仔细找，这里只是猜测)

//RootWindowContainer$AttachApplicationHelper.java
private class AttachApplicationHelper implements Consumer<Task>, Predicate<ActivityRecord> {
    boolean process(WindowProcessController app) throws RemoteException {
        ...
        if (!mHasActivityStarted) { //(3)
            ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,
                                    false /* preserveWindows */); //(4)
        }
        return mHasActivityStarted;
    }
    ...
    @Override
  	public boolean test(ActivityRecord r) {
        if (r.finishing || !r.showToCurrentUser() || !r.visibleIgnoringKeyguard
            || r.app != null || mApp.mUid != r.info.applicationInfo.uid
            || !mApp.mName.equals(r.processName)) {
            return false;
        }

        try {
            if (mTaskSupervisor.realStartActivityLocked(r, mApp,
                                                        mTop == r && r.getTask().canBeResumed(r) /* andResume */,
                                                        true /* checkConfig */)) { //(1)
                mHasActivityStarted = true; //(2)
            }
        } catch (RemoteException e) {
            Slog.w(TAG, "Exception in new application when starting activity " + mTop, e);
            mRemoteException = e;
            return true;
        }
        return false;
    }
}

通过调用mTaskSupervisor的realStartActivityLocked方法(见①)，真正创建并启动了Activity，如果启动成功设置mHasActivityStarted为true(见②)，回到process方法后会判断Activity是否启动成功(见③)，如果失败，会调用ensureActivitiesVisible方法确保活动可见(见④)。

我们看看mTaskSupervisor是如何创建Activity的？

(3) ClientTransaction

//RootWindowContainer.java#mTaskSupervisor
ActivityTaskSupervisor mTaskSupervisor;

//ActivityTaskSupervisor.java#realStartActivityLocked
public class ActivityTaskSupervisor implements RecentTasks.Callbacks {
    ...
    boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
                                    boolean andResume, boolean checkConfig) throws RemoteException {
   		...
		// 创建活动启动事务。
        final ClientTransaction clientTransaction = ClientTransaction.obtain(
            proc.getThread(), r.token); //(1) 这里的proc.getThread()其实就是ApplicationtThread

        final boolean isTransitionForward = r.isTransitionForward();
        final IBinder fragmentToken = r.getTaskFragment().getFragmentToken();
        //* 添加LaunchActivityItem回调对象，这个后面会提到
        clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                                                                System.identityHashCode(r), ...);
		...
        //提交事务
		mService.getLifecycleManager().scheduleTransaction(clientTransaction); //(3) 将事务提交给了ClientLifecycleManager
    }
    ...
}
         
//ClientLifecycleManager.java#scheduleTransaction
class ClientLifecycleManager {    
    ...
    /**
    * 调度一个事务，该事务可能由多个回调和一个生命周期请求组成
    */
    void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        transaction.schedule(); //* 核心方法
        if (!(client instanceof Binder)) {
            // If client is not an instance of Binder - it's a remote call and at this point it is
            // safe to recycle the object. All objects used for local calls will be recycled after
            // the transaction is executed on client in ActivityThread.
            transaction.recycle();
        }
    }
    ...
}
      
//ClientTransaction.java#schedule
public class ClientTransaction implements Parcelable, ObjectPoolItem {
    ...
    private IApplicationThread mClient;
    ...
    public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this); //(4)
    }
    ...
}

① 这里创建了ClinetTransaction， ActivityThread创建Activity需要一个用来启动Activity事物的对象，也就是ClinetTransaction，ClinetTransaction就是用来启动我们的Activity的。（ClientTransaction的obtain方法传入了ApplicationtThread，说明Activity在该obtain方法里面完成创建）

② 这里添加了回调，并把LaunchActivityItem传到了ClientTransaction内。

③ 将Activity的启动事务提交给了ClientLifecycleManager。

④ 这里调用了ApplicationThread代理对象的scheduleTransaction方法，也就是从系统进程回到了APP进程。

我们来看看ApplicationThread是如何传入ClientTransaction的。

//ActivityTaskSupervisor.java#realStartActivityLocked
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
                                boolean andResume, boolean checkConfig) throws RemoteException {
    ...
	final ClientTransaction clientTransaction = ClientTransaction.obtain(proc.getThread(), r.token);
    ...
}

//ClientTransaction.java#obtain
public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
     ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
     if (instance == null) {
         instance = new ClientTransaction();
     }
     instance.mClient = client;
     instance.mActivityToken = activityToken;

     return instance;
 }

附录：ActivityTaskManagerService的启动

可以在SystemService中看到ActivityTaskManagerService的启动，这个了解一下就可以了。

//SystemServer.java
...
public static void main(String[] args) {new SystemServer().run();}
...
private void run() {
    ...
    startBootstrapServices(t);
    startCoreServices(t);
    startOtherServices(t);
    startApexServices(t);
    ...
}
...
private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
    ...
    ActivityTaskManagerService atm = mSystemServiceManager.startService(
        ActivityTaskManagerService.Lifecycle.class).getService();
    mActivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);
    mWindowManagerGlobalLock = atm.getGlobalLock();
    ...
}

2. 创建Activity实例

//ActivityThread$ApplicationThread.java#scheduleTransaction
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    ActivityThread.this.scheduleTransaction(transaction);
}
    
//ActivityThread.java
public final class ActivityThread extends ClientTransactionHandler
        implements ActivityThreadInternal {
	...
}
                                      
//ClientTransactionHandler.java
public abstract class ClientTransactionHandler {
   	void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
    }
}

//ActivityThread$H.java#handleMessage
public final class ActivityThread extends ClientTransactionHandler
        implements ActivityThreadInternal {
    private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this); //*
    ...
	class H extends Handler {
        public void handleMessage(Message msg) {
            ...
            case EXECUTE_TRANSACTION:
                final ClientTransaction transaction = (ClientTransaction) msg.obj;
                mTransactionExecutor.execute(transaction); //mTransactionExecutor是执行事务的对象
                if (isSystem()) {
                    transaction.recycle();
                }
                break;
            ...
        }
    }
}

//TransactionExecutor.java#execute
public void execute(ClientTransaction transaction) {
	...
	executeCallbacks(transaction);    
	executeLifecycleState(transaction);
    ...
}

//TransactionExecutor.java#executeCallbacks
private ClientTransactionHandler mTransactionHandler; //(1)
...
public void executeCallbacks(ClientTransaction transaction) {
    final List<ClientTransactionItem> callbacks = transaction.getCallbacks(); //获取transaction的所有回调类
    ... 
    //遍历事务管理器中的所有窗口请求对象
    final int size = callbacks.size();
    for (int i = 0; i < size; ++i) {
        final ClientTransactionItem item = callbacks.get(i); //*
        ...
        item.execute(mTransactionHandler, token, mPendingActions); //(2) 进行窗体创建请求
        item.postExecute(mTransactionHandler, token, mPendingActions);
    }
    ...
}

//ClientTransactionItem.java
public abstract class ClientTransactionItem implements BaseClientRequest, Parcelable {
}

② item的execute方法有个mTransactionHandler参数是ClientTransactionHandler类型①的成员变量，而ClientTransactionHandler则是ActivityThread的父类，也就是说这里传入execute的是ActivityThread。

在TransactionExecutor.java#executeCallbacks方法中，遍历了ClientTransaction所有的回调对象，也就是ClientTransactionItem的实例，然后调用了它们的execute方法，来进行窗口创建请求。

而这些ClientTransactionItem实例是在哪里添加进来的？之前在3-1-(3)-ActivityTaskSupervisor.java#realStartActivityLocked方法中有提到，添加进来的就是LaunchActivityItem，而LaunchActivityItem是ClientTransactionItem的实现类。

//LaunchActivityItem.java#execute
public void execute(ClientTransactionHandler client, IBinder token,
                    PendingTransactionActions pendingActions) {
    Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
    //创建一个ActivityClientRecord对象，用于Activity的实例化
    ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
                mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
                mPendingResults, mPendingNewIntents, mActivityOptions, mIsForward, mProfilerInfo,
                client, mAssistToken, mShareableActivityToken, mLaunchedFromBubble,
                mTaskFragmentToken);
    //将创建的ActivityClientRecord回调给ActivityThread
    client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
    Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}


//ActivityThread.java#handleLaunchActivity
public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent) {
    ...
    //根据传过来的ActivityClientRecord创建一个Activity
	final Activity a = performLaunchActivity(r, customIntent);
    ...
}

//ActivityThread.java#performLaunchActivity
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
   	...
    Activity activity = null;
    try {
        java.lang.ClassLoader cl = appContext.getClassLoader();
        activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent); //创建Activity
    ...
}
    
    
//Instrumentation.java#newActivity
public Activity newActivity(ClassLoader cl, String className, Intent intent)
    throws InstantiationException, IllegalAccessException, ClassNotFoundException {
    //通过意图获取目标Activity的包名，用来获取Activity工厂
    String pkg = intent != null && intent.getComponent() != null
        ? intent.getComponent().getPackageName() : null; 
    这里获取AppComponentFactory实例后，创建了Activity
    return getFactory(pkg).instantiateActivity(cl, className, intent); //(1)
}
    
//AppComponentFactory.java
public class AppComponentFactory {
    ...
    public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className,
            @Nullable Intent intent)
            throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        return (Activity) cl.loadClass(className).newInstance(); //类加载器创建Activfity实例
    }
    ...
}

① 详情见本节附录

Activity的启动会通过Intent拿到目的地Activity的全类名，然后根据类加载器来进行实例化。

附录：AppComponentFactory

public class AppComponentFactory {
   public @NonNull ClassLoader instantiateClassLoader(@NonNull ClassLoader cl,
            @NonNull ApplicationInfo aInfo) {...}
	
    public @NonNull Application instantiateApplication(@NonNull ClassLoader cl,@NonNull String className) { ...}
    
    public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className,
            @Nullable Intent intent) {...}
    
    public @NonNull BroadcastReceiver instantiateReceiver(@NonNull ClassLoader cl,
                                                          @NonNull String className, @Nullable Intent intent) {...}

    public @NonNull Service instantiateService(@NonNull ClassLoader cl,
                                               @NonNull String className, @Nullable Intent intent){...}
    
    public @NonNull ContentProvider instantiateProvider(@NonNull ClassLoader cl,
                                                          @NonNull String className) {,,,}
    
    public static final AppComponentFactory DEFAULT = new AppComponentFactory();
}

可以看到所有的组件都是通过AppComponentFactory创建的。

接下来看看Instrumentation是怎么获取AppComponentFactory的。

//Instrumentation.java#getFactory
private ActivityThread mThread = null;
...
private AppComponentFactory getFactory(String pkg) {
    if (pkg == null) { //如果没有Intent携带的全类名，就用默认工厂对象
        Log.e(TAG, "No pkg specified, disabling AppComponentFactory");
        return AppComponentFactory.DEFAULT;
    }
    if (mThread == null) {        //如果没有ActivityThread，也用默认工厂对象
        Log.e(TAG, "Uninitialized ActivityThread, likely app-created Instrumentation,"
              + " disabling AppComponentFactory", new Throwable());
        return AppComponentFactory.DEFAULT; 
    }
    LoadedApk apk = mThread.peekPackageInfo(pkg, true); //根据包名获取当前apk对应的LoadedApk对象
    // This is in the case of starting up "android".
    if (apk == null) apk = mThread.getSystemContext().mPackageInfo;
    //获取由manifest文件标签的android:appComponentFactory属性指定的工厂，也就是可以自定义应用组件实例化的工厂
    return apk.getAppFactory();
}

//ActivityThread.java#peekPackageInfo
//这里缓存了不同APK对应的LoadedApk对象，也就是可以通过这些map来实现APP间的远程通讯
final ArrayMap<String, WeakReference<LoadedApk>> mPackages = new ArrayMap<>();
final ArrayMap<String, WeakReference<LoadedApk>> mResourcePackages = new ArrayMap<>();
...
public final LoadedApk peekPackageInfo(String packageName, boolean includeCode) {
    //ActivityThead通过弱引用的方式缓存不同APK的LoadedApk对象，这里根据APK的包名取出对应的LoaderApk
    synchronized (mResourcesManager) {
        WeakReference<LoadedApk> ref;
        if (includeCode) {
            ref = mPackages.get(packageName);
        } else {
            ref = mResourcePackages.get(packageName);
        }
        return ref != null ? ref.get() : null;
    }
}

//LoadedApk.java#createAppFactory
private AppComponentFactory createAppFactory(ApplicationInfo appInfo, ClassLoader cl) {
    if (mIncludeCode && appInfo.appComponentFactory != null && cl != null) {
        try {
            //如果清单文件指定了appComponentFactory就通过类加载器创建该对象，否则返回默认的AppComponentFactory对象
            return (AppComponentFactory)
                cl.loadClass(appInfo.appComponentFactory).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            Slog.e(TAG, "Unable to instantiate appComponentFactory", e);
        }
    }
    return AppComponentFactory.DEFAULT;
}

3. 启动Activity

现在Activity已经创建，我们回到创建Activity的创建的地方，看看Activity创建后是如何启动的。

//ActivityThread.java#performLaunchActivity
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    ...
    Activity activity = null;
    ...
    activity = mInstrumentation.newAct\ivity(cl, component.getClassName(), r.intent); //创建Activity
    ...
    activity.attach(appContext, **); //调用Activity的attachBaseContext方法
    ...
    //调用Activity的onCreate方法
    if (r.isPersistable()) {
        mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
    } else {
        mInstrumentation.callActivityOnCreate(activity, r.state);
    }
    ...
}

//Instrumentation.java#callActivityOnCreate
public void callActivityOnCreate(Activity activity, Bundle icicle,
                                 PersistableBundle persistentState) {
    prePerformCreate(activity);
    activity.performCreate(icicle, persistentState);
    postPerformCreate(activity);
}

//Activity.java#performCreate
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
    ...
    if (persistentState != null) {
        onCreate(icicle, persistentState);
    } else {
        onCreate(icicle);
    }
    ...
}

Activity启动完成后，接下来就是启动UI页面了。

二、UI绘制流程

1、Activity加载XML文件的过程

1. PhoneWindow的初始化

(1) 创建PhoneWindow

上一小节，我们已经追踪到了Activity的onCreate方法，这UI绘制流程的入口呼之欲出，也就是setContentView方法了。

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

不妨让我们看看setContentView做了什么。

//Activity.java#setContentView
public void setContentView(@LayoutRes int layoutResID) {
    //实际上调用的是PhoneWindow.setContentView()方法 --> PhoneWindow是window的唯一实现类
    getWindow().setContentView(layoutResID);
    initWindowDecorActionBar();
}

//Activity.java#getWindow
private Window mWindow;
...
public Window getWindow() {
    return mWindow;
}

//Window.java#setContentView
public abstract class Window {
    ...
    public abstract void setContentView(View view);
    ...
}

//Activity.java#mWindow
final void attach(Context context, ...) {
    attachBaseContext(context);
    ...
    mWindow = new PhoneWindow(this, window, activityConfigCallback);
    ...
}

可以看到mWindow其实是PhoneWindow（该类其实也是Window的唯一实现类）对象，也就是Activity#setContentView，后面调用的其实是PhoneWindow#setContentView。

番外话：从Activity#attach可以看出，执行attachBaseContext方法时，mWIndow还未实例化，所以attachBaseContext中不能执行setContentView方法

(2) PhoneWindow的重要属性——mDecor和mContentParent

在追踪PhoneWindow#setContentView之前，先来了解一下PhoneWindow的几个重要的属性。

public class PhoneWindow extends Window implements MenuBuilder.Callback {
    //这是窗口的顶级视图，它可以包含所有的窗口修饰	
    private DecorView mDecor; //(1)
    
    /**
    * 布局容器
    * 这是放置窗口内容的视图。它要么是mDecor本身，要么是mDecor的内容所在的子级。
    */
    ViewGroup mContentParent; //(2)
}

① DecorView是顶层的视图，是Activity最外层的View。

② mContentParent要么是mDecor，要么是mDecor的子View。

2-1-1-2 图片来自网图

(3) mDecor和mContentParent属性的初始化

接下来看看PhoneWindow#setContentView做了什么？

//PhoneWindow.java#setContentView
public void setContentView(int layoutResID) {
    //mContentParent肯定会为空  因为我们当前还是窗体初始化
    if (mContentParent == null) {
        //初始化顶层布局
        installDecor(); //这里做了两件事，分别是mDecor的初始化和mContentParent的初始化
    } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        mContentParent.removeAllViews();
    }
    ...
}

//PhoneWindow.java#installDecor
private void installDecor() {
    mForceDecorInstall = false;
    if (mDecor == null) {
        //初始化mDecor
        mDecor = generateDecor(-1); //创建mDecor
        mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
        mDecor.setIsRootNamespace(true);
        if (!mInvalidatePanelMenuPosted && mInvalidatePanelMenuFeatures != 0) {
            mDecor.postOnAnimation(mInvalidatePanelMenuRunnable);
        }
    } else {
        mDecor.setWindow(this);
    }
    if (mContentParent == null) {
        //通过mDecor初始化ContentParent
        mContentParent = generateLayout(mDecor);
        ...
    }
}

[1] 初始化mDecor属性

先看一下mDecor初始化时，PhoneWindow.java#generateDecor方法做了什么。

//PhoneWindow.java#generateDecor
protected DecorView generateDecor(int featureId) {
    //系统进程没有应用程序上下文，在这种情况下，我们需要直接使用我们拥有的上下文。否则，我们需要应用程序上下文，因此我们不会紧紧抓住活动。
    Context context;
    if (mUseDecorContext) {
        Context applicationContext = getContext().getApplicationContext();
        if (applicationContext == null) {
            context = getContext();
        } else {
            context = new DecorContext(applicationContext, this);
            if (mTheme != -1) {
                context.setTheme(mTheme);
            }
        }
    } else {
        context = getContext();
    }
    return new DecorView(context, featureId, this, getAttributes()); //创建DecorView对象
}

PhoneWindow.java#generateDecor只是简单new了一个DecorView对象。

[2] 初始化mContentParent属性

接着看ContentParent初始化时，PhoneWindow.java#generateLayout方法做了什么。

//PhoneWindow.java#generateLayout
protected ViewGroup generateLayout(DecorView decor) {
    //获取应用当前主题中的数据，比如是否全屏、悬浮、有无title等
    TypedArray a = getWindowStyle();
    ...
    //获取窗体布局属性    
    WindowManager.LayoutParams params = getAttributes();
    ...
    //给窗体进行装饰
        
	int layoutResource; //资源ID，他会根据不同的主题加载对应的XML文件
    
    int features = getLocalFeatures();
    //加载系统布局 判断到底是加载哪个系统的布局
    if ((features & ((1 << FEATURE_LEFT_ICON) | (1 << FEATURE_RIGHT_ICON))) != 0) {
        if (mIsFloating) {
            layoutResource = res.resourceId;
        } else {
            layoutResource = R.layout.screen_title_icons;
        }
    } ...  else {
        layoutResource = R.layout.screen_simple; //(1)
    }

    mDecor.startChanging();
    //将加载到的基础布局添加到了最外层View，也就是mDecor里面。
    mDecor.onResourcesLoaded(mLayoutInflater, layoutResource);   //(2)
    //通过系统content资源ID去加载实例化这个控件
    ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT); //(3)
    if (contentParent == null) {
        //如果contentParent为null，就会抛出异常。这点毋庸置疑，它肯定不能为空
        throw new RuntimeException("Window couldn't find content container view");
    }
    ... 
    return contentParent;  //这里返回了ContentView
}

//Window.java#ID_ANDROID_CONTENT
/**
* XML布局文件中主布局应具有的ID
*/
public static final int ID_ANDROID_CONTENT = com.android.internal.R.id.content; //(4)

① R.layout.screen_simple是最常见的布局，详见本节附录一。

② DecorView通过onResourcesLoaded方法添加layoutResource基础布局，详见本节附录二。

③④ R.id.content，就是附录一中根布局的FrameLayout的id，也就是说③这里拿到了ContentView，并赋值给contentParent局部变量。

我们回到PhoneWindow，在2-1-1-(2)中，我们提到过mContentParent是mDecor，要么是mDecor的子View。通过上面的跟踪，发现我们现在得到的mContentParent正是根布局的ContentView，也就是mDecor的子View。

//PhoneWindow.java#installDecor
ViewGroup mContentParent;
...
private void installDecor() {    
    if (mContentParent == null) {
        //通过mDecor初始化ContentParent
        mContentParent = generateLayout(mDecor);
        ...
    }
}

这时候PhoneWindow.java#installDecor方法的两个初始化操作已经完成了，mDecor和mContentPare都完成了初始化。

附录一：常见的根布局——screen_simple.xml

下面就是最常见的根布局XML文件的代码。

R.id.action_mode_bar_stub待会再提。

R.id.content是状态栏下的页面，也就是手机显示屏上的主体内容。它是Activity#setContentView对应的ContentView，一般情况下，我们自己写的布局文件真正的父布局就是ContentView。

action_mode_bar_stub和content分别对应图片2-1-1-2中的TitleView和ContentView，不过还是有些出入，所以笔者又找了一张更合适的图片2-1-1-a。

2-1-1-a 图片来自网图

接下来特别说说R.id.action_mode_bar_stub，之所以特别说，是因为我在追踪R.id.action_mode_bar_stub的时候绕了个弯路，下面讲讲踩坑过程。

R.id.action_mode_bar_stub之前以为是状态栏，直到追踪AppCompatActivity的时候（详见2-2），发现有两个R.id.action_mode_bar_stub，难道AppCompatActivity还能有两个状态栏不成？？？

绝对不可能！！！

于是按惯性思维，认为AppCompatActivity的R.id.action_mode_bar_stub替换了原来的R.id.action_mode_bar_stub，这样的话它替换的逻辑应该类似ContentView，那么它必然是在布局初始化的时候发生的，思路有了之后，以PhoneWindow.java#generateLayout和AppCompatDelegateImpl.java#ensureSubDecor方法为核心追踪了半天，结果当然是追踪了个寂寞。

干脆用"R.id.action_mode_bar_stub"来进行查找，很快我在DecorView找到了它。

//DecorView.java#createStandaloneActionMode
private ActionBarContextView mPrimaryActionModeView;
...
private ActionMode createStandaloneActionMode(ActionMode.Callback callback) {
    ...
    ViewStub stub = findViewById(R.id.action_mode_bar_stub);
    if (stub != null) {
        mPrimaryActionModeView = (ActionBarContextView) stub.inflate();
        mPrimaryActionModePopup = null;
    }
    ...
}

ActionBarContextView？这是和标题栏有关？再看一下调用的方法名createStandaloneActionMode，创建ActionMode？

于是我有了一种不祥的预感，反向追踪一下代码。

//DecorView.java#createStandaloneActionMode
private ActionMode createStandaloneActionMode(ActionMode.Callback callback) {
    ...
}

//DecorView.java#createActionMode
private ActionMode createActionMode(
    ....
    return createStandaloneActionMode(callback);
    ...
}
     
//DecorView.java#startActionMode
private ActionMode startActionMode(
            View originatingView, ActionMode.Callback callback, int type) {
    ...
    mode = createActionMode(type, wrappedCallback, originatingView);
    ...
}

可以看到在启动ActionMode的时候，膨胀了action_mode_bar_stub。

再回忆一下id的名字action_mode_bar_stub和它的类型ViewStub（状态栏还能不可见？）。

这时候该抽自己一巴掌，action_mode_bar_stub和状态栏不能说一模一样，只能说毫无关系。

那么状态栏究竟是谁？

这时候为了避免干扰，设置一下无标题主题，然后运行了一下程序。

打开SDK->tools->bin->uiautomatorviewer.bat，终于看到了正正经经的状态栏R.id.statusBarBackground（如图2-1-1-a2）。

为了更清晰的和action_mode_bar_stub进行对比，又打开了SDK->tools->monitor.bat->HierarchyView（如同2-1-1-a3）。

2-1-1-a2

2-1-1-a3

在DecorView中可以找到ColorViewState类型的mStatusColorViewState变量，它持有状态栏，也持有状态栏的状态和资源ID等属性。

//DecorView.java#mStatusColorViewState
public static final ColorViewAttributes STATUS_BAR_COLOR_VIEW_ATTRIBUTES =
    new ColorViewAttributes(FLAG_TRANSLUCENT_STATUS,
                            Gravity.TOP, Gravity.LEFT, Gravity.RIGHT,
                            Window.STATUS_BAR_BACKGROUND_TRANSITION_NAME,
                            com.android.internal.R.id.statusBarBackground, ITYPE_STATUS_BAR);
...
private final ColorViewState mStatusColorViewState =
    new ColorViewState(STATUS_BAR_COLOR_VIEW_ATTRIBUTES);

//DecorView$ColorViewState.java
private static class ColorViewState {
    View view = null;
    int targetVisibility = View.INVISIBLE;
    boolean present = false;
    boolean visible;
    int color;

    final ColorViewAttributes attributes;

    ColorViewState(ColorViewAttributes attributes) {
        this.attributes = attributes;
    }
}

//DecorView$ColorViewAttributes.java
public static class ColorViewAttributes {
    final int id;
    final int translucentFlag;
    final int verticalGravity;
    final int horizontalGravity;
    final int seascapeGravity;
    final String transitionName;
    final @InternalInsetsType int insetsType;

    private ColorViewAttributes(int translucentFlag, int verticalGravity, int horizontalGravity,
                                int seascapeGravity, String transitionName, int id,
                                @InternalInsetsType int insetsType) {
        this.id = id;
        this.translucentFlag = translucentFlag;
        this.verticalGravity = verticalGravity;
        this.horizontalGravity = horizontalGravity;
        this.seascapeGravity = seascapeGravity;
        this.transitionName = transitionName;
        this.insetsType = insetsType;
    }

    public boolean isPresent(boolean requestedVisible, int windowFlags, boolean force) {
        return requestedVisible
            && ((windowFlags & FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS) != 0 || force);
    }

    public boolean isVisible(boolean present, int color, int windowFlags, boolean force) {
        return present
            && (color & Color.BLACK) != 0
            && ((windowFlags & translucentFlag) == 0  || force);
    }

    public boolean isVisible(InsetsState state, int color, int windowFlags, boolean force) {
        final boolean present = isPresent(state.getSource(insetsType).isVisible(), windowFlags,
                                          force);
        return isVisible(present, color, windowFlags, force);
    }
}

接下来看看状态栏的初始化过程。

//ActivityThread.java#handleStartActivity
public void handleStartActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, ActivityOptions activityOptions) {
    ...
    mInstrumentation.callActivityOnPostCreate(activity, ...);
    ...
}

//Instrumentation.java#callActivityOnPostCreate
public void callActivityOnPostCreate(@NonNull Activity activity,
                                     @Nullable Bundle savedInstanceState) {
    activity.onPostCreate(savedInstanceState);
}

//Activity.java#onPostCreate
protected void onPostCreate(@Nullable Bundle savedInstanceState) {
    if (!isChild()) {
        mTitleReady = true;
        onTitleChanged(getTitle(), getTitleColor());
    }

    mCalled = true;

    notifyContentCaptureManagerIfNeeded(CONTENT_CAPTURE_START);
}

//Activity.java#setTitle
protected void onTitleChanged(CharSequence title, int color) {
    if (mTitleReady) {
        final Window win = getWindow();
        if (win != null) {
            win.setTitle(title);
            if (color != 0) {
                win.setTitleColor(color);
            }
        }
        if (mActionBar != null) {
            mActionBar.setWindowTitle(title);
        }
    }
}

//PhoneWindow.java#setTitle
public void setTitle(CharSequence title) {
    setTitle(title, true);
}

public void setTitle(CharSequence title, boolean updateAccessibilityTitle) {
    if (mTitleView != null) {
        mTitleView.setText(title);
    } else if (mDecorContentParent != null) {
        mDecorContentParent.setWindowTitle(title);
    }
    mTitle = title;
    if (updateAccessibilityTitle) {
        WindowManager.LayoutParams params = getAttributes();
        if (!TextUtils.equals(title, params.accessibilityTitle)) {
            params.accessibilityTitle = TextUtils.stringOrSpannedString(title);
            if (mDecor != null) {
                // ViewRootImpl will make sure the change propagates to WindowManagerService
                ViewRootImpl vr = mDecor.getViewRootImpl();
                if (vr != null) {
                    vr.onWindowTitleChanged();
                }
            }
            dispatchWindowAttributesChanged(getAttributes());
        }
    }
}

//PhoneWindow.java#dispatchWindowAttributesChanged
protected void dispatchWindowAttributesChanged(WindowManager.LayoutParams attrs) {
    super.dispatchWindowAttributesChanged(attrs);
    if (mDecor != null) {
        mDecor.updateColorViews(null /* insets */, true /* animate */);
    }
}

//DecorView.java#updateColorViews
WindowInsets updateColorViews(WindowInsets insets, boolean animate) {
    ...
    updateColorViewInt(mStatusColorViewState, statusBarColor, 0,
                       mLastTopInset, false /* matchVertical */, statusBarNeedsLeftInset,
                       statusBarSideInset, animate && !disallowAnimate,
                       mForceWindowDrawsBarBackgrounds, controller);
    ...
}


//DecorView.java#updateColorViewInt
private void updateColorViewInt(final ColorViewState state, int color, int dividerColor,
                                int size, boolean verticalBar, boolean seascape, int sideMargin, boolean animate,
                                boolean force, WindowInsetsController controller) {
    ...
    if (view == null) {
        if (showView) {
            state.view = view = new View(mContext); //初始化状态栏对应的View
            setColor(view, color, dividerColor, verticalBar, seascape);
            view.setTransitionName(state.attributes.transitionName);
            view.setId(state.attributes.id); //状态栏的ID
            visibilityChanged = true;
            view.setVisibility(INVISIBLE);
            state.targetVisibility = VISIBLE;
            ...            
            addView(view, lp); //将状态栏添加到DecorView中
            ...
        }
    }
}

到这里状态栏就添加到了布局中。

最后，推荐一篇写的很好的博客：探索 Android View 绘制流程。

附录二：DecorVIew添加RootView

下面是DecorView添加基础布局的代码。

//DecorView.java#onResourcesLoaded
void onResourcesLoaded(LayoutInflater inflater, int layoutResource) {
 	...
    mDecorCaptionView = createDecorCaptionView(inflater);
    //把传过来的根布局layoutResource进行解析并渲染
    final View root = inflater.inflate(layoutResource, null); //通过inflate解析根布局layoutResource
    if (mDecorCaptionView != null) {
        if (mDecorCaptionView.getParent() == null) {
            addView(mDecorCaptionView,
                    new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
        }
        mDecorCaptionView.addView(root,
                                  new ViewGroup.MarginLayoutParams(MATCH_PARENT, MATCH_PARENT));
    } else {
        //将其放在颜色视图下方
        addView(root, 0, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT)); //将rootView添加到进DecorView中并填满屏幕
    }
    mContentRoot = (ViewGroup) root;
    initializeElevation();
}

2. 加载自定义布局

根布局加载完后，就开始来加载我们自己定义的布局了，例如加载activity_main.xml。

//PhoneWindow.java#setContentView
private LayoutInflater mLayoutInflater;
...
public void setContentView(int layoutResID) {
    if (mContentParent == null) {
        //初始化mDecor和mContentParent
        installDecor(); 
    } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
		...
    }

    if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        ...
    } else {
        //去加载自己定义的layout
        mLayoutInflater.inflate(layoutResID, mContentParent); //传入R.layout.activity_main和ContentView
    }   
    ...
}

//LayoutInflater.java#inflate
public View inflate(@LayoutRes int resource, @Nullable ViewGroup root, boolean attachToRoot) {
    final Resources res = getContext().getResources();
 	...
    XmlResourceParser parser = res.getLayout(resource); //解析activity_main.xml布局文件
    try {
        return inflate(parser, root, attachToRoot);
    } finally {
        parser.close();
    }
}

public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {
    synchronized (mConstructorArgs) {
        ...
        root.addView(temp, params); //将R.layout.activity_main添加到ContentView中
        ...
    }
}

可以看到activity_main.xml已经加载到了Activity里面。

2、AppCompatActivity加载XML文件的过程

上一小节已经看过了Activity加载布局文件的过程，但是开发中，我们遇到AppCompatActivity的情况显然更多，接下来就看看AppCompatActivity和Activity加载布局文件的过程有何不同。

1. 初始化PhoneWIndow的mDecor和mDecorContentParent属性

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

//AppCompatActivity.java#setContentView
public void setContentView(@LayoutRes int layoutResID) {
    initViewTreeOwners();
    getDelegate().setContentView(layoutResID);
}

//AppCompatActivity.java#getDelegate
private AppCompatDelegate mDelegate;
...
public AppCompatDelegate getDelegate() {
    if (mDelegate == null) {
        mDelegate = AppCompatDelegate.create(this, this); //当mDelegate为null时，创建mDelegate实例并返回
    }
    return mDelegate;
}

//AppCompatDelegate.java#create
public abstract class AppCompatDelegate {
    ...
    public static AppCompatDelegate create(@NonNull Activity activity,
                                           @Nullable AppCompatCallback callback) {
        return new AppCompatDelegateImpl(activity, callback); //(1)
    }
    ...
}

看到这里发现AppCompatActivityt并不是通过PhoneWindow设置布局的，而是通过AppCompatDelegate的实现类AppCompatDelegateImpl。

接下来我们来看看AppCompatDelegateImpl.java#setContentView是如何加载基础布局的。

//AppCompatDelegateImpl.java#setContentView
public void setContentView(View v) {
    ensureSubDecor(); //初始化根布局
    ViewGroup contentParent = mSubDecor.findViewById(android.R.id.content); //获取ContentView
    contentParent.removeAllViews();
    contentParent.addView(v);
    mAppCompatWindowCallback.getWrapped().onContentChanged();
}

//AppCompatDelegateImpl.java#ensureSubDecor
ViewGroup mSubDecor; //mSubDecor可以对标Activity的mDecor
,,,
private void ensureSubDecor() {   
    if (!mSubDecorInstalled) {
        //mSubDecor的初始化
        mSubDecor = createSubDecor();
        ...
		onSubDecorInstalled(mSubDecor);
        ...
    }
}

//AppCompatDelegateImpl.java#createSubDecor
private ViewGroup createSubDecor() {   
    ...
    mWindow.getDecorView();
    ...        
}

//PhoneWindow.java#getDecorView
public final @NonNull View getDecorView() {
    if (mDecor == null || mForceDecorInstall) {
        installDecor(); //初始化mDecor和mDecorContentParent
    }
    return mDecor;
}

我们看到AppCompatDelegateImpl也调用了PhoneWindow#installDecor方法来加载基础布局。

不过AppCompatDelegateImpl并没有直接使用installDecor的结果，而是在加载基础布局后，又做了一些操作。

我们继续看AppCompatDelegateImpl#createSubDecor方法。

2. 初始化AppCompatDelegateImpl的mSubDecor属性

//AppCompatDelegateImpl.java#createSubDecor
private ViewGroup createSubDecor() {
    //获取当前应用主题中的数据，根据主题加载对应的xml文件，然后赋值给mSubDecor
    TypedArray a = mContext.obtainStyledAttributes(R.styleable.AppCompatTheme);
    ...
    mWindow.getDecorView(); //用和Activity的方式同样的方式加载基础布局
   
    final LayoutInflater inflater = LayoutInflater.from(mContext);
    ViewGroup subDecor = null;
    
    if (!mWindowNoTitle) {
        if (mIsFloating) {
            //如果我们是浮动的，请膨胀对话框标题装饰
            subDecor = (ViewGroup) inflater.inflate(
                R.layout.abc_dialog_title_material, null);

            //浮动窗口永远不能有操作栏，重置标志
            mHasActionBar = mOverlayActionBar = false;
        } else if (mHasActionBar) {
            ...
            //现在使用主题上下文膨胀视图并将其设置为内容视图
            subDecor = (ViewGroup) LayoutInflater.from(themedContext)
                        .inflate(R.layout.abc_screen_toolbar, null);
            ...
        } 
    } else {
            if (mOverlayActionMode) {
                subDecor = (ViewGroup) inflater.inflate(
                    R.layout.abc_screen_simple_overlay_action_mode, null);
            } else {
                subDecor = (ViewGroup) inflater.inflate(R.layout.abc_screen_simple, null); //(1)
            }
        }
    }
    
    if (subDecor == null) {
        //如果subDecor为null，则抛出异常
        throw new IllegalArgumentException(...);
    }
    
    ...
    return subDecor;
}

①这里选择一个简单的xml做介绍，详见本节附录一

我们看到在PhoneWindow加载了基础布局后，进行了subDecor的创建，并将subDecor返回，单看这些，subDecor和AppCompatActivity并没有关联上。

其实在subDecor创建之后，AppCompatDelegateImpl#createSubDecor还对subDecor做了一些操作，操作完成后才返回subDecor。

我们来看看AppCompatDelegateImpl#createSubDecor在subDecor创建成功之后做了什么？

//AppCompatDelegateImpl.java#createSubDecor
private ViewGroup createSubDecor() {
    ...
	subDecor = ...;  //创建subDecor
    ...   
    final ContentFrameLayout contentView = (ContentFrameLayout) subDecor.findViewById(
        R.id.action_bar_activity_content); //(1)

    final ViewGroup windowContentView = (ViewGroup) mWindow.findViewById(android.R.id.content); //(2)
    
    if (windowContentView != null) {
        //可能已经将视图添加到窗口的内容视图中，因此我们需要将它们迁移到我们的内容视图中
        //------------ (3) ---------------
        while (windowContentView.getChildCount() > 0) {
            final View child = windowContentView.getChildAt(0);
            windowContentView.removeViewAt(0);
            contentView.addView(child);
        }

        //更改我们的内容 FrameLayout 以使用android.R.id.content id.对片段有用。
        //------------ (4) ---------------
        windowContentView.setId(View.NO_ID);
        contentView.setId(android.R.id.content);

        //装饰内容可能有一个前景可绘制对象集（windowContentOvelay）。删除它，因为我们自己处理它
        if (windowContentView instanceof FrameLayout) {
            ((FrameLayout) windowContentView).setForeground(null);(5)
        }
    }

    //现在使用装饰设置窗口的内容视图
    mWindow.setContentView(subDecor); //(6)
   	...
    return subDecor;
}

//View.javaNO_ID
/**
* 用于标记没有 ID 的视图。
*/
public static final int NO_ID = -1; //(7)

① 获取subDecor加载的布局文件的ContentView，详见本节附录一。

② 获取当前PhoneWindow加载的基础布局文件中的ContentView。

③ 这段代码将PhoneWindow的ContentView中的所有子控件全部转移到subDecor中，转移后当前PhoneWIndow内的ContentView被清空。(这里注意，当前还未加载R.layout.activity_main，所以PhoneWindowd的ContentView可能是个空布局，这时就没必要转移，即直接跳过while循环。)

④ 这里进行了移花接木，将windowContentView的id设置为View.NO_ID（删除了id，见⑦），再将contentView的ID设为android.R.id.content，完成了id的替换，这时候通过findViewById(R.id.content)找到的就不是原来的windowContentView，而是subDecor的contentView，当然这里还差一个将subDecor绑定到PhoneWindow中的操作，这时候到步骤⑥了。

⑤ 设置windowContentView的setForeground为null，也就是windowContentView跳过绘制过程，这时没有id有无法绘制的windowContentView相当于一个空View。

⑥ 将subDecor绑定到PhoneWindow。

我们看看subDecor是如何绑定到PhoneWindow上的？

//AppCompatDelegateImpl.java#createSubDecor
private ViewGroup createSubDecor() {
    ...
	mWindow.setContentView(subDecor);
    ...
}

//PhoneWindow.java#setContentView
public void setContentView(View view) {
	setContentView(view, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
}

//PhoneWindow.java#setContentView
public void setContentView(View view, ViewGroup.LayoutParams params) {
 	...
	mContentParent.addView(view, params); 
    ...
}

我们看到这时候subDecor就加到了原先的ContentView下面，现在的根布局结构如图：

图2-2

3.加载自定义布局

这时候我们的AppCompatDelegateImpl#createSubDecor方法就看得差不多了，我们接着回到AppCompatDelegateImpl#ensureSubDecor。

//AppCompatDelegateImpl.java#ensureSubDecor
private void ensureSubDecor() {
     if (!mSubDecorInstalled) {
         mSubDecor = createSubDecor();
         ...
         onSubDecorInstalled(mSubDecor);
         mSubDecorInstalled = true;
         ...
     }
}

//AppCompatDelegateImpl.java#onSubDecorInstalled
void onSubDecorInstalled(ViewGroup subDecor) {}

这里有个onSubDecorInstalled方法，他是一个空方法，该方法主要用来重写的，一般没有特殊需求，我们不会重写它。

调用完onSubDecorInstalled方法，mSubDecorInstalled就被设置为true了，这时候ensureSubDecor方法再被调用就会直接被跳过。

从名字也可以看出来，ensureSubDecor方法是为了确保subDecor已经初始化，也就是说很多必须使用subDecor的地方，都需要调用该方法来保证subDecor已经初始化了。

class AppCompatDelegateImpl extends AppCompatDelegate
        implements MenuBuilder.Callback, LayoutInflater.Factory2 {
    public void onPostCreate(Bundle savedInstanceState) {
        // Make sure that the sub decor is installed
        ensureSubDecor();
    }
    ...
    private void initWindowDecorActionBar() {
        ensureSubDecor();
        ...
	}
    ...
    public <T extends View> T findViewById(@IdRes int id) {
        ensureSubDecor();
        return (T) mWindow.findViewById(id);
    }
    ...  
    @Override
    public void setContentView(View v) {
        ensureSubDecor();
        ViewGroup contentParent = mSubDecor.findViewById(android.R.id.content);
        contentParent.removeAllViews();
        contentParent.addView(v);
        mAppCompatWindowCallback.getWrapped().onContentChanged();
    }

    @Override
    public void setContentView(int resId) {
        ensureSubDecor();
        ViewGroup contentParent = mSubDecor.findViewById(android.R.id.content);
        contentParent.removeAllViews();
        LayoutInflater.from(mContext).inflate(resId, contentParent);
        mAppCompatWindowCallback.getWrapped().onContentChanged();
    }

    @Override
    public void setContentView(View v, ViewGroup.LayoutParams lp) {
        ensureSubDecor();
        ViewGroup contentParent = mSubDecor.findViewById(android.R.id.content);
        contentParent.removeAllViews();
        contentParent.addView(v, lp);
        mAppCompatWindowCallback.getWrapped().onContentChanged();
    }

    @Override
    public void addContentView(View v, ViewGroup.LayoutParams lp) {
        ensureSubDecor();
        ViewGroup contentParent = mSubDecor.findViewById(android.R.id.content);
        contentParent.addView(v, lp);
        mAppCompatWindowCallback.getWrapped().onContentChanged();
    }
}

我们重点看AppCompatDelegateImpl#setContentView方法，可以看到他把subDecor的ContentView的子空间全部清空了，然后将传进来的View添加到了ContentView里面，也就是让我们传进来的View替换了原先ContentView的布局。AppCompatDelegateImpl#addContentView的逻辑类似，只不过不会清空原先的View，也就是在原有的基础上加上了传进来的View。

我们回忆一下AppCompatDelegateImpl#setContentView的调用方。

public class AppCompatActivity extends FragmentActivity implements AppCompatCallback,
        TaskStackBuilder.SupportParentable, ActionBarDrawerToggle.DelegateProvider {
	...
    @Override
    public void setContentView(@LayoutRes int layoutResID) {
        initViewTreeOwners();
        getDelegate().setContentView(layoutResID);
    }

    @Override
    public void setContentView(View view) {
        initViewTreeOwners();
        getDelegate().setContentView(view);
    }

    @Override
    public void setContentView(View view, ViewGroup.LayoutParams params) {
        initViewTreeOwners();
        getDelegate().setContentView(view, params);
    }

    @Override
    public void addContentView(View view, ViewGroup.LayoutParams params) {
        initViewTreeOwners();
        getDelegate().addContentView(view, params);
    }
	...
}

这时候我们又回到MainActivity了。

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

再捋一下AppCompatActivity加载资源ID的路线。

//AppCompatActivity.java#setContentView
public void setContentView(@LayoutRes int layoutResID) {
        initViewTreeOwners();
        getDelegate().setContentView(layoutResID);
}

//AppCompatDelegateImpl.java#setContentView
public void setContentView(int resId) {
    ...
    LayoutInflater.from(mContext).inflate(resId, contentParent);
    ...
}

//LayoutInflater#inflate
public View inflate(@LayoutRes int resource, @Nullable ViewGroup root) {
    return inflate(resource, root, root != null);
}

其实AppCompatActivity主要就是在Activity加载XML的基础上添加了SubDecor，其他的大差不差。

附录一：简单根布局abc_screen_simple.xml


<androidx.appcompat.widget.FitWindowsLinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/action_bar_root"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:fitsSystemWindows="true">

    <androidx.appcompat.widget.ViewStubCompat
        android:id="@+id/action_mode_bar_stub"
        android:inflatedId="@+id/action_mode_bar"
        android:layout="@layout/abc_action_mode_bar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

    <include layout="@layout/abc_screen_content_include" />

androidx.appcompat.widget.FitWindowsLinearLayout>


<merge xmlns:android="http://schemas.android.com/apk/res/android">
    <androidx.appcompat.widget.ContentFrameLayout
            android:id="@id/action_bar_activity_content"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:foregroundGravity="fill_horizontal|top"
            android:foreground="?android:attr/windowContentOverlay" />
merge>

3、UI绘制过程

现在XML已经加载好了，接下来谈谈UI具体的绘制过程，既然说到了绘制过程，那么肯定有一个生命周期是绕不开的也就是onResume。

我们先看看ActivityThread的handleResumeActivity方法。

（PS：这里笔者猜测ActivityThread#handleResumeActivity的调用方应该在TransactionExecutor.java#performLifecycleSequence，可以在上面的创建Activity实例小节中找到TransactionExecutor.java#executeCallbacks方法，不过之后的代码在小节中没有出现。可以自行依照executeCallbacks->cycleToPath->performLifecycleSequence的路径查找，该方法里面可以看到各种ActivityThread.java#handleXXXActivity生命周期方法的调用，笔者本来想要写入附录，但因为出现了很多疑问，所以暂且搁置，如果有机会，笔者会在了解过Activity整体的生命周期流程之后，再单独拿一篇出来讲讲Activity所有生命周期的流程。当然因为水平有限可能写的不好，这里只能恳请路过的大佬帮忙指点一二。）

//ActivityThread.java#handleResumeActivity
public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
            boolean isForward, String reason) {
    ...
    //待办事项 将 resumeArgs 推送到活动中以供考虑 跳过以下步骤进行双重恢复和 r.mFinish = true
    if (!performResumeActivity(r, finalStateRequest, reason)) { //这里会执行Activity的onResume方法
        return;
    }
    ...
    //获取Activity
	final Activity a = r.activity;
    ...    
    if (r.window == null && !a.mFinished && willBeVisible) {
        	//获取到Activity的PhoneWindow
            r.window = r.activity.getWindow();
			//获取到PhoneWindow的基础布局，也就是最外层的DecorView                                                            
            View decor = r.window.getDecorView();
            decor.setVisibility(View.INVISIBLE);
			//获取到Activity的WindowManager对象                                                            
            ViewManager wm = a.getWindowManager();
			//获取到Activity的window的LayoutParams
            WindowManager.LayoutParams l = r.window.getAttributes();
			//把decorView从Activity记录类中拿出来交给Activity                                                            
            a.mDecor = decor;
			...
            if (r.mPreserveWindow) {
                a.mWindowAdded = true;
                r.mPreserveWindow = false;
                //通常，ViewRoot 使用 addView->ViewRootImpl#setView 中的活动设置回调。
                //如果我们要重用装饰视图，则必须通知视图根目录回调可能已更改。
                ViewRootImpl impl = decor.getViewRootImpl();
                if (impl != null) {
                    impl.notifyChildRebuilt();
                }
            }
            if (a.mVisibleFromClient) {
                if (!a.mWindowAdded) {
                    a.mWindowAdded = true;
                    //调用绘制方法
                    wm.addView(decor, l); //* 重点
                } else {
                    //该活动将更早地获得此 {@link LayoutParams} 更改的回调。但是，届时不会设置装
                    //饰（在此方法中设置），因此不会执行任何操作。此调用可确保回调与装饰集一起发生。
                    a.onWindowAttributesChanged(l);
                }
            }
            ...
    }	
	...        
}

这里看完代码会发现Activity的onResume方法，其实是在UI绘制之前调用的，这点需要注意，一不小心就可能翻车。

关于这个坑，笔者再推荐一篇不错的博客：源码详细解析Activity生命周期onResume中Handler.Post(Runnable)和View.Post(Runnable)的UI效果差异原因

1. 调用Activity的onResume方法

接下来我们来看看Activity的onResume生命周期是如何被调用的。

//ActivityThread.java#handleResumeActivity
public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
            boolean isForward, String reason) {
    ...
    if (!performResumeActivity(r, finalStateRequest, reason)) { //这里会执行Activity的onResume方法
        return;
    }
}

//ActivityThread.java#performResumeActivity
public boolean performResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
                                     String reason) {
    ...
    r.activity.performResume(r.startsNotResumed, reason);
    ...
}

//Activity.java#performResume
final void performResume(boolean followedByPause, String reason) {
    ...
    mInstrumentation.callActivityOnResume(this);
    ...
}

//Instrumentation.java#callActivityOnResume
public void callActivityOnResume(Activity activity) {
    activity.mResumed = true;
    activity.onResume();
	...
}

现在我们Activity的onResume方法已经被调用了，接着就来看看Activity的显示流程。

（PS：这里performResumeActivity方法里面调用的不只是onResume方法，在此之前，如果Activity是重用的会先调用OnNewIntent方法，接着会判断Activity此前是否经历过onStop方法，如果有则会触发onRestart方法，然后调用onStart。这部分也会一并写到后面关于Activity生命周期流程的文章中。）

2. ViewRootImpl进行UI绘制的过程

(1) View绘制三大流程的入口

接下来我们来看看UI具体的绘制过程。

我们回到ActivityThread#handleResumeActivity方法，接着看看之ViewManager#addView方法是怎么来的。

//ActivityThread.java#handleResumeActivity
public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
            boolean isForward, String reason) {
    ...
    final Activity a = r.activity;
    ...
	ViewManager wm = a.getWindowManager();
    ...
    wm.addView(decor, l);
    ...
}

//Activity.java#getWindowManager
public WindowManager getWindowManager() {
    return mWindowManager;
}

//Activity.java#mWindowManager
private Window mWindow;
private WindowManager mWindowManager;
...
final void attach(Context context, ActivityThread aThread, ...) {
    ...
    mWindowManager = mWindow.getWindowManager();
    ...
}

//Window.java#getWindowManager
public WindowManager getWindowManager() {
    return mWindowManager;
}

//Window.java#mWindowManager
private WindowManager mWindowManager;
...
public void setWindowManager(WindowManager wm, IBinder appToken, String appName,
                             boolean hardwareAccelerated) {
    mAppToken = appToken;
    mAppName = appName;
    mHardwareAccelerated = hardwareAccelerated;
    if (wm == null) {
        wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
    }
    mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this);
}

//WindowManagerImpl.java#createLocalWindowManager
public WindowManagerImpl createLocalWindowManager(Window parentWindow) {
    return new WindowManagerImpl(mContext, parentWindow, mWindowContextToken);
}

可以看到wm.addView方法中，wm变量其实是WindowManager的实现类WindowManagerImpl的对象。

看一下他的addView做了什么？

//WindowManagerImpl.java#addView 
public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
    applyTokens(params);
    mGlobal.addView(view, params, mContext.getDisplayNoVerify(), mParentWindow,
                    mContext.getUserId());
} 

//WindowManagerGlobal.java#addView
@UnsupportedAppUsage
private final Object mLock = new Object();

@UnsupportedAppUsage
private final ArrayList<View> mViews = new ArrayList<View>();
@UnsupportedAppUsage
private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();
@UnsupportedAppUsage
private final ArrayList<WindowManager.LayoutParams> mParams =
    new ArrayList<WindowManager.LayoutParams>();
private final ArraySet<View> mDyingViews = new ArraySet<View>();
...
public void addView(View view, ViewGroup.LayoutParams params,
            Display display, Window parentWindow, int userId) {
    ...    
	ViewRootImpl root;
    View panelParentView = null;

    synchronized (mLock) {
        ...        
        if (windowlessSession == null) {
            root = new ViewRootImpl(view.getContext(), display);
        } else {
            root = new ViewRootImpl(view.getContext(), display, windowlessSession);
        }

        view.setLayoutParams(wparams);
        //这三个集合里面储存着应用中所有Activity的基础属性
        mViews.add(view);
        mRoots.add(root);
        mParams.add(wparams);

        //最后执行此操作，因为它会触发消息以开始执行操作
        try {
            root.setView(view, wparams, panelParentView, userId); //* 重点
        } catch (RuntimeException e) {
            //清理BadTokenException 或 InvalidDisplayException。
            if (index >= 0) {
                removeViewLocked(index, true);
            }
            throw e;
        }
    }
}

//ViewRootImpl.java#setView
View mView;
...
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView,
            int userId) {
    ...
    mView = view; //将DecorView赋值给mView
    ...
    //安排第一个布局之前添加到窗口管理器，以确保我们在从系统接收任何其他事件之前进行重新布局。
    //和View的requestLayout方法类似，它会重新进行测量->布局->绘制的过程
    requestLayout();
    ...
    view.assignParent(this); //(1)
    ...
}

//ViewRootImpl.java#requestLayout
public void requestLayout() {
    if (!mHandlingLayoutInLayoutRequest) {
        //检查线程
        checkThread(); // (2)
        mLayoutRequested = true;
        //调度遍历
        scheduleTraversals();
    }
} 

//ViewRootImpl.java#scheduleTraversals
final TraversalRunnable mTraversalRunnable = new TraversalRunnable();
...
void scheduleTraversals() {
    if (!mTraversalScheduled) {
        mTraversalScheduled = true;
        mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
        //调用线程mTraversalRunnable
        mChoreographer.postCallback(
            Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
        notifyRendererOfFramePending();
        pokeDrawLockIfNeeded();
    }
}

//ViewRootImpl$TraversalRunnable.java#run
final class TraversalRunnable implements Runnable {
    @Override
    public void run() {
        //执行调度
        doTraversal();
    }
}

//ViewRootImpl.java#doTraversal
void doTraversal() {
    if (mTraversalScheduled) {
        mTraversalScheduled = false;
        mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);

        if (mProfile) {
            Debug.startMethodTracing("ViewAncestor");
        }

        performTraversals(); //View绘制的测量、放置、绘制三大流程，就是在这里发生的

        if (mProfile) {
            Debug.stopMethodTracing();
            mProfile = false;
        }
    }
}

//ViewRootImpl.java#performTraversals   
private void performTraversals() {
    //缓存mView，也就是DecorView，因为它在下面使用了很多...  
    final View host = mView;
    ...
    //询问Host想要多大 这里是绘制的开始
    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
    ...
    performLayout(lp, mWidth, mHeight);
    ...
    performDraw()
    ...
}

①这里是将RootViewImpl添加为DecorView的父布局，详见附录一。

① 这里是线程检查，也就是检查是否为UI线程，详见附录二。

可以看到先测量、再布局、最后绘制，这个流程的顺序是由ViewRootImpl.java#performTraversals 方法确定的。

接下来我们就来具体看看这三个流程的调用。

(2) View绘制三大流程之onMeasure方法

//ViewRootImpl.java#performMeasure   
private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
    if (mView == null) {
        return;
    }
    Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
    try {
        //调用DecorView的measure方法，这里会层层传递，测量整个Activity里面的所有View
        mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
}

 public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
     ...
     onMeasure(widthMeasureSpec, heightMeasureSpec);
     ...
 }

(3) View绘制三大流程之onLayout方法

//ViewRootImpl.java#performLayout
private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
            int desiredWindowHeight) {
    ...
    final View host = mView; 
    ...
    host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
}

public void layout(int l, int t, int r, int b) {
    ...
    onLayout(changed, l, t, r, b);
    ...
}

(4) View绘制三大流程之onDraw方法

//ViewRootImpl.java#performDraw
private boolean performDraw() {
    ...
    boolean canUseAsync = draw(fullRedrawNeeded, usingAsyncReport && mSyncBuffer);
    ...
}

//ViewRootImpl.java#draw
private boolean draw(boolean fullRedrawNeeded, boolean forceDraw) {
    ...
    if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset,
                      scalingRequired, dirty, surfaceInsets)) {
        return false;
    } 
    ...
}

//ViewRootImpl.java#drawSoftware
 private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
            boolean scalingRequired, Rect dirty, Rect surfaceInsets) {
     //使用软件渲染器绘制。
     final Canvas canvas;
     ...
     canvas = mSurface.lockCanvas(dirty);
     ...
     mView.draw(canvas);
     ...
 }

//ViewRootImpl.java#draw
public void draw(Canvas canvas) {
    ...
    onDraw(canvas);
    ,,,
}

附录一：将ViewRootImpl添加为DecorView的父布局

ViewRootImpl在setView中会被添加为根布局DecorView的父亲，下面看看添加的流程。

//ViewRootImpl.java# setView
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView,
                    int userId) {
    ...
    requestLayout();
    ...
    view.assignParent(this); //为DecorView分配父布局
    ...
}

//View.java#assignParent
protected ViewParent mParent;
...
/**
* 调用方负责在必要时调用 requestLayout。（这允许 addViewInLayout 不请求新布局。）
*/
void assignParent(ViewParent parent) {
    if (mParent == null) {
        mParent = parent;
    } else if (parent == null) {
        mParent = null;
    } else {
        throw new RuntimeException("view " + this + " being added, but"
                                   + " it already has a parent");
    }
}

/**
* 视图层次结构的顶部，在视图和窗口管理器之间实现所需的协议。这在很大程度上是WindowManagerGlobal的内部实现细节
*/
public final class ViewRootImpl implements ViewParent,
        View.AttachInfo.Callbacks, ThreadedRenderer.DrawCallbacks,
        AttachedSurfaceControl {
	...     
}

可以看到ViewRootImpl是整个布局结构的根节点，它管理整颗View树的测量、布局、绘制等过程，是View和WindowManger之间的沟通的桥梁。

值得一提的是，ViewRootImpl本身并不是View，只是实现了ViewParent接口，所以DecorView依旧是最顶层的View，是所有View的祖先节点。

附录二：UI线程检查

我们应该对UI线程都不陌生，那么UI线程究竟是怎么判断的？我们来看看ViewRootImpl.java的checkThread方法。

//ViewRootImpl.java#checkThread
void checkThread() {
    if (mThread != Thread.currentThread()) {
        throw new CalledFromWrongThreadException(
        "Only the original thread that created a view hierarchy can touch its views.");
    }
}

//ViewRootImpl.java#mThread
final Thread mThread;
...
public ViewRootImpl(@UiContext Context context, Display display, IWindowSession session,
            boolean useSfChoreographer) {
    ...
    mThread = Thread.currentThread();
    ...
}

可以看到UI线程，其实就是创建ViewRootImpl的线程，在回到上面讲的启动主线程的Looper。

这时候对比一下，就可以发现主线程是APP进程的第一个线程，而UI线程是创建ViewRootImpl的线程，也就是说两者不一定相同，这也就意味着在子线程修改UI，或者说让子线程成为UI线程，其实也是可行的。有兴趣的可以转到这里你不知道的，Android子线程中的UI操作
那么再换个思路，我们已经找到ViewRootImpl是在ActivityThead#onResume方法之后才初始化的，那么在此之前，UI不受ViewRootImpl控制，也就是说，不会有UI线程安全的问题，那么这就意味着我们在这段时间内是可以使用子线程修改UI的，当然这时候UI还没有绘制，相关内容可以转到这里震惊！Android子线程也能修改UI？

你可能感兴趣的:(Android,Framework学习之路,ui,android,java)

Android和IOS应用开发-Flutter应用让屏幕在 app 运行期间保持常亮的方法江上清风山间明月 Flutter android ios flutter KeepAlive 屏幕常亮 wakelock 熄屏
文章目录Flutter应用让屏幕在app运行期间保持常亮的方法方法一：使用系统插件方法二：使用Widgets注意事项Flutter应用让屏幕在app运行期间保持常亮的方法在Flutter开发中，可以使用以下两种方法让屏幕在app运行期间保持常亮：方法一：使用系统插件Flutter社区中已经有很多相关插件可供使用，比如wakelock:https://pub.dev/packages/wakeloc
数据结构奇妙旅程之深入解析快速排序山间漫步人生路数据结构排序算法算法
快速排序（QuickSort）是一种高效的排序算法，它使用了分治法的策略来将一个数组排序。其基本思想是选择一个基准元素，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比基准元素小，另一部分的所有数据都比基准元素大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。工作原理选择基准：从待排序的序列中选一个元素作为基准（pivo
android 自定义曲线图,Android自定义View——贝赛尔曲线 weixin_39767513 android 自定义曲线图
个人博客：haichenyi.com。感谢关注本文针对有一定自定义View的童鞋，最好对贝赛尔曲线有辣么一丢丢了解，不了解也没关系。花5分钟看一下GcsSloop的安卓自定义View进阶-Path之贝塞尔曲线。本文的最终效果图：最终效果图.gif思路首先他是一个只有上半部分的正弦形状的水波纹，很规则。其次，他这个正弦图左右在移动。然后，就是它这个自定义View，上下也在移动，是慢慢增加的最后，优化
Mac命令行查找SDK/JDK安装位置 iblade Linux macos java 开发语言
要在命令行中查询AndroidSDKPlatformTools的安装位置，可以使用以下步骤：使用which命令：在命令行中执行以下命令：whichadb这将输出adb命令的安装路径，通常情况下，它会在AndroidSDK的platform-tools目录下。手动查找：如果whichadb没有输出，可以手动查找AndroidSDK的安装位置。通常情况下，AndroidSDK的默认安装路径是在用户的h
美团自动配送车2024春季招聘 | 社招专场美团技术团队
关于美团自动配送团队美团自动配送以自研L4级自动驾驶软硬件技术为核心，与美团即时零售业务结合，形成满足公开道路、校园、社区、工业园区等室外全场景下的自动配送整体解决方案。美团自动配送团队成立于2016年，团队成员来自于Waymo、Cruise、Pony.ai、泛亚等自动驾驶行业头部公司，自动驾驶技术团队博士占比高达30%，依靠视觉、激光等传感器，实时感知预测周围环境，通过高精地图定位和智能决策规划
下载Android源码赛非斯
repoinit-uhttps://mirrors.tuna.tsinghua.edu.cn/git/AOSP/platform/manifest-bandroid-10.0.0_r411.首先下载repo：a）终端运行gitclonegit://codeaurora.org/tools/repo.gitb）mkdir~/binc）拷贝repo到~/bin下面，修改repo权限，chmoda+x~
华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）华为OD题库华为od 链表 java
须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
学习JavaEE的日子 Day32 线程池 A 北枝学习JavaEE 学习 java-ee java 线程池
Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
llama.cpp 编译安装@Ubuntu skywalk8163 项目实践人工智能 llama ubuntu linux 人工智能
在Kylin和Ubuntu编译llama.cpp，具体参考：llama模型c语言推理@FreeBSD-CSDN博客现在代码并编译：gitclonehttps://github.com/ggerganov/llama.cppcdllama.cppmkdirbuildcdbuildcmake..cmake--build.--configRelease#可选安装makeinstall#或可选添加路径ex
使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】还算善良_ 私有代码库工具类 java list 数据结构
packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？ AaronWang94 shiro java java 安全开发语言
请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？大龄下岗程序员 mysql java mysql spring
Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
3、JavaWeb-Ajax/Axios-前端工程化-Element 所谓远行Misnearch #JavaWeb 前端 ajax elementui java 前端框架
P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
docker怎么端口映射 Lance_mu docker 容器运维
1、默认固定的端口#Web服务器：WebApache或Nginx通常使用80端口HTTP：80HTTPS：443#数据库服务器MySQL：3306PostgreSQL：5432MongoDB：27017Redis：6379#邮件服务器SMTP：25POP3：110IMAP：143#其他服务SSH：22FTP：21DNS（域名解析）：53代理服务器Squid：3128版本控制系统Git：9418(S
flutter 修改app名字和图标肥肥呀呀呀 flutter
一、修改名字在Android中修改应用程序名称：在AndroidManifest.xml文件中修改应用程序名称：打开Flutter项目中的android/app/src/main/AndroidManifest.xml文件。找到标签，然后在android:label属性中修改应用程序的名称，例如：android:label="YourNewAppName"。在strings.xml文件中修改应用程
eclipse导入项目 warning报错 org.springframework.ide.eclipse.core.springnature zhangfeng1133 ide eclipse java
报错org.springframework.ide.eclipse.core.springnature报错信息"org.springframework.ide.eclipse.core.springnature"通常表示EclipseIDE中与Spring框架集成的插件出现了问题。这个错误可能是因为SpringIDE插件没有正确安装或配置，或者Eclipse的更新过程中出现了问题。解决方法：确认S
【鸿蒙HarmonyOS开发笔记】ArkUI常用组件介绍汇总（更新中）温、鸿蒙HarmonyOS开发笔记学习记录 harmonyos 笔记华为
概述此文总结开发中用到的一些常用组件，便于查阅，此文持续更新，闲的没事就更线性布局（Row/Column）不多介绍了，最常用的布局组件，两者除了方向不一样，别的都一样方便起见下面只写Column常用属性排列方向上的间距：spaceColumn({space:20}){Row().width('90%').height(50).backgroundColor(0xF5DEB3)Row().width
枚举使用笔记万变不离其宗_8 项目笔记笔记
1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
webpack.prod.js（webpack生产环境配置文件）门板_ webpack javascript 前端
生产环境：只打包不运行本地服务器对于在config目录下的webpack.prod.js1.在根目录下运行npxwebpack--config./config/webpack.prod.js2.在package.json文件中配置"build":"npxwebpack--config./config/webpack.prod.js"constpath=require('path')constESL
Python dict字符串转json对象，小数精度丢失问题朝如青丝暮成雪 json python
一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
java实体中返回前端的double类型四舍五入（格式化）婲落ヽ紅顏誶 java
根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
Element-UI中el-time-picker时间选择器无法选择爱健身的小刘同学 bug Element Vue系列 javascript 前端 elementui
前言前几天开发时，在做一个时间选择时，遇到了无法选中时间的问题在网络上找了解决方法，特此记录一下解决方法我的代码结构营业时间时间选择不上的原因是因为初始值问题很有可能是最开始赋值为空数组了所以有3个解决方法1.设置为nullbusinessTimeInfo:null2.设置当前时间businessTimeInfo:[newDate(newDate()),newDate(newDate())]（默认
Java中HashMap底层数据结构及主要参数? 山间漫步人生路 java 数据结构开发语言
在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
Android 系统应用 pk8签名文件转jks或keystore教程蜗牛、Z AOSP android Framework android aosp 系统应用开发
一、介绍签名文件对于我们在做应用开发中，经常遇到，且签名文件不仅仅是保护应用安全，还会涉及到应用与底层之间的数据共享和API文件等问题。在Android中，签名文件同样也存在这个问题。但是android中又区分系统应用和普通应用。系统应用可以通过android:sharedUserId="android.uid.system"同享系统uid，可以获取更高的权限。所以在做系统应用开发的时候，经常需要
Java学习笔记01 .wsy. 日常 java 学习笔记
1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
Java回溯知识点（含面试大厂题和源码）一成码农 java 面试开发语言
回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
Azkaban各种类型的Job编写 __元昊__
一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
java基础相关面试题详细总结。。。。。96 java 开发语言
1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
javascript 日期转换为时间戳，时间戳转换为日期的函数 cdcdhj javascript学习日记 javascript 开发语言 ecmascript
日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-
Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法杰哥在此 Java系列 java jvm 算法面试
Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
github中多个平台共存 jackyrong github
在个人电脑上，如何分别链接比如oschina,github等库呢，一般教程之列的，默认 ssh链接一个托管的而已，下面讲解如何放两个文件 1）设置用户名和邮件地址 $ git config --global user.name "xx" $ git config --global user.email "[email protected]"
ip地址与整数的相互转换(javascript) alxw4616 JavaScript
//IP转成整型 function ip2int(ip){ var num = 0; ip = ip.split("."); num = Number(ip[0]) * 256 * 256 * 256 + Number(ip[1]) * 256 * 256 + Number(ip[2]) * 256 + Number(ip[3]); n
读书笔记-jquey+数据库+css chengxuyuancsdn html jquery oracle
1、grouping ,group by rollup, GROUP BY GROUPING SETS区别 2、$("#totalTable tbody>tr td:nth-child(" + i + ")").css({"width":tdWidth, "margin":"0px", &q
javaSE javaEE javaME == API下载 Array_06 java
oracle下载各种API文档： http://www.oracle.com/technetwork/java/embedded/javame/embed-me/documentation/javame-embedded-apis-2181154.html JavaSE文档： http://docs.oracle.com/javase/8/docs/api/ JavaEE文档： ht
shiro入门学习 cugfy java Web 框架
声明本文只适合初学者，本人也是刚接触而已，经过一段时间的研究小有收获，特来分享下希望和大家互相交流学习。首先配置我们的web.xml代码如下，固定格式，记死就成 <filter> <filter-name>shiroFilter</filter-name> &nbs
Array添加删除方法 357029540 js
刚才做项目前台删除数组的固定下标值时，删除得不是很完整，所以在网上查了下，发现一个不错的方法，也提供给需要的同学。 //给数组添加删除 Array.prototype.del = function(n){
navigation bar 更改颜色张亚雄 IO
今天郁闷了一下午，就因为objective-c默认语言是英文，我写的中文全是一些乱七八糟的样子，到不是乱码，但是，前两个自字是粗体，后两个字正常体，这可郁闷死我了，问了问大牛，人家告诉我说更改一下字体就好啦，比如改成黑体，哇塞，茅塞顿开。翻书看，发现，书上有介绍怎么更改表格中文字字体的，代码如下
unicode转换成中文 adminjun unicode 编码转换
在Java程序中总会出现\u6b22\u8fce\u63d0\u4ea4\u5fae\u535a\u641c\u7d22\u4f7f\u7528\u53cd\u9988\uff0c\u8bf7\u76f4\u63a5这个的字符，这是unicode编码，使用时有时候不会自动转换成中文就需要自己转换了使用下面的方法转换一下即可。 /** * unicode 转换成中文
一站式 Java Web 框架 firefly aijuans Java Web
Firefly是一个高性能一站式Web框架。涵盖了web开发的主要技术栈。包含Template engine、IOC、MVC framework、HTTP Server、Common tools、Log、Json parser等模块。 firefly-2.0_07修复了模版压缩对javascript单行注释的影响，并新增了自定义错误页面功能。更新日志：增加自定义系统错误页面功能
设计模式——单例模式 ayaoxinchao 设计模式
定义 Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。” 分析从定义中可以看出单例的要点有三个：一是某个类只能有一个实例；二是必须自行创建这个实例；三是必须自行向系统提供这个实例。 &nb
Javascript 多浏览器兼容性问题及解决方案 BigBird2012 JavaScript
不论是网站应用还是学习js,大家很注重ie与firefox等浏览器的兼容性问题，毕竟这两中浏览器是占了绝大多数。一、document.formName.item(”itemName”) 问题问题说明：IE下，可以使用 document.formName.item(”itemName”) 或 document.formName.elements ["elementName&quo
JUnit-4.11使用报java.lang.NoClassDefFoundError: org/hamcrest/SelfDescribing错误 bijian1013 junit4.11 单元测试
下载了最新的JUnit版本，是4.11，结果尝试使用发现总是报java.lang.NoClassDefFoundError: org/hamcrest/SelfDescribing这样的错误，上网查了一下，一般的解决方案是，换一个低一点的版本就好了。还有人说，是缺少hamcrest的包。去官网看了一下，如下发现：
[Zookeeper学习笔记之二]Zookeeper部署脚本 bit1129 zookeeper
Zookeeper伪分布式安装脚本(此脚本在一台机器上创建Zookeeper三个进程，即创建具有三个节点的Zookeeper集群。这个脚本和zookeeper的tar包放在同一个目录下，脚本中指定的名字是zookeeper的3.4.6版本，需要根据实际情况修改)： #!/bin/bash #!!!Change the name!!! #The zookeepe
【Spark八十】Spark RDD API二 bit1129 spark
coGroup package spark.examples.rddapi import org.apache.spark.{SparkConf, SparkContext} import org.apache.spark.SparkContext._ object CoGroupTest_05 { def main(args: Array[String]) { v
Linux中编译apache服务器modules文件夹缺少模块(.so)的问题 ronin47 modules
在modules目录中只有httpd.exp，那些so文件呢？我尝试在fedora core 3中安装apache 2. 当我解压了apache 2.0.54后使用configure工具并且加入了 --enable-so 或者 --enable-modules=so (两个我都试过了) 去make并且make install了。我希望在/apache2/modules/目录里有各种模块，
Java基础-克隆 BrokenDreams java基础
Java中怎么拷贝一个对象呢？可以通过调用这个对象类型的构造器构造一个新对象，然后将要拷贝对象的属性设置到新对象里面。Java中也有另一种不通过构造器来拷贝对象的方式，这种方式称为克隆。 Java提供了java.lang.
读《研磨设计模式》-代码笔记-适配器模式-Adapter bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 适配器模式解决的主要问题是，现有的方法接口与客户要求的方法接口不一致 * 可以这样想，我们要写这样一个类（Adapter）: * 1.这个类要符合客户的要求 ---> 那显然要
HDR图像PS教程集锦&心得 cherishLC PS
HDR是指高动态范围的图像，主要原理为提高图像的局部对比度。软件有photomatix和nik hdr efex。一、教程叶明在知乎上的回答： http://www.zhihu.com/question/27418267/answer/37317792 大意是修完后直方图最好是等值直方图，方法是HDR软件调一遍，再结合不透明度和蒙版细调。二、心得 1、去除阴影部分的
maven-3.3.3 mvn archetype 列表 crabdave ArcheType
maven-3.3.3 mvn archetype 列表可以参考最新的：http://repo1.maven.org/maven2/archetype-catalog.xml [INFO] Scanning for projects... [INFO]
linux shell 中文件编码查看及转换方法 daizj shell 中文乱码 vim 文件编码
一、查看文件编码。在打开文件的时候输入:set fileencoding 即可显示文件编码格式。二、文件编码转换 1、在Vim中直接进行转换文件编码,比如将一个文件转换成utf-8格式 &
MySQL--binlog日志恢复数据 dcj3sjt126com binlog
恢复数据的重要命令如下 mysql> flush logs; 默认的日志是mysql-bin.000001，现在刷新了重新开启一个就多了一个mysql-bin.000002
数据库中数据表数据迁移方法 dcj3sjt126com sql
刚开始想想好像挺麻烦的，后来找到一种方法了，就SQL中的 INSERT 语句，不过内容是现从另外的表中查出来的，其实就是 MySQL中INSERT INTO SELECT的使用下面看看如何使用语法：MySQL中INSERT INTO SELECT的使用 1. 语法介绍有三张表a、b、c，现在需要从表b
Java反转字符串 dyy_gusi java 反转字符串
前几天看见一篇文章，说使用Java能用几种方式反转一个字符串。首先要明白什么叫反转字符串，就是将一个字符串到过来啦，比如"倒过来念的是小狗"反转过来就是”狗小是的念来过倒“。接下来就把自己能想到的所有方式记录下来了。 1、第一个念头就是直接使用String类的反转方法，对不起，这样是不行的，因为Stri
UI设计中我们为什么需要设计动效 gcq511120594 UI linux
随着国际大品牌苹果和谷歌的引领，最近越来越多的国内公司开始关注动效设计了，越来越多的团队已经意识到动效在产品用户体验中的重要性了，更多的UI设计师们也开始投身动效设计领域。但是说到底，我们到底为什么需要动效设计？或者说我们到底需要什么样的动效？做动效设计也有段时间了，于是尝试用一些案例，从产品本身出发来说说我所思考的动效设计。一、加强体验舒适度嗯，就是让用户更加爽更加爽的用
JBOSS服务部署端口冲突问题 HogwartsRow java 应用服务器 jboss server EJB3
服务端口冲突问题的解决方法，一般修改如下三个文件中的部分端口就可以了。 1、jboss5/server/default/conf/bindingservice.beans/META-INF/bindings-jboss-beans.xml 2、./server/default/deploy/jbossweb.sar/server.xml 3、.
第三章 Redis/SSDB+Twemproxy安装与使用 jinnianshilongnian ssdb reids twemproxy
目前对于互联网公司不使用Redis的很少，Redis不仅仅可以作为key-value缓存，而且提供了丰富的数据结果如set、list、map等，可以实现很多复杂的功能；但是Redis本身主要用作内存缓存，不适合做持久化存储，因此目前有如SSDB、ARDB等，还有如京东的JIMDB，它们都支持Redis协议，可以支持Redis客户端直接访问；而这些持久化存储大多数使用了如LevelDB、RocksD
ZooKeeper原理及使用 liyonghui160com
ZooKeeper是Hadoop Ecosystem中非常重要的组件，它的主要功能是为分布式系统提供一致性协调(Coordination)服务，与之对应的Google的类似服务叫Chubby。今天这篇文章分为三个部分来介绍ZooKeeper，第一部分介绍ZooKeeper的基本原理，第二部分介绍ZooKeeper
程序员解决问题的60个策略 pda158 框架工作单元测试
根本的指导方针 1. 首先写代码的时候最好不要有缺陷。最好的修复方法就是让 bug 胎死腹中。良好的单元测试强制数据库约束使用输入验证框架避免未实现的“else”条件在应用到主程序之前知道如何在孤立的情况下使用日志 2. print 语句。往往额外输出个一两行将有助于隔离问题。 3. 切换至详细的日志记录。详细的日
Create the Google Play Account sillycat Google
Create the Google Play Account Having a Google account, pay 25$, then you get your google developer account. References: http://developer.android.com/distribute/googleplay/start.html https://p
JSP三大指令 vikingwei jsp
JSP三大指令一个jsp页面中，可以有0~N个指令的定义！ 1. page --> 最复杂：<%@page language="java" info="xxx"...%> * pageEncoding和contentType： > pageEncoding：它