arduino复制代码watch com.xxl.rpc.remoting.net.impl.netty_http.server.NettyHttpServerHandler channelRead0 '{params}' -x 2

csharp复制代码[2024-02-21T18:02:00.026Z] "POST / HTTP/1.1" 200 - via_upstream - "-" 626 176 1 0 "-" "-" "d9313e61-6530-4c08-aae2-fd864930ea31" "ebc-portal.ebc-bpm.svc.cluster.local" "10.64.195.45:7666" inbound|7666|| 127.0.0.6:48733 10.64.195.45:7666 10.64.217.207:45584 - default
[2024-02-21T18:02:30.055Z] "POST / HTTP/1.1" 503 UC upstream_reset_before_response_started{connection_termination} - "-" 159 95 90031 - "-" "-" "3de88bd6-41cf-4078-a381-3542b460dd90" "ebc-portal.ebc-bpm.svc.cluster.local" "10.64.195.45:7666" inbound|7666|| 127.0.0.6:48733 10.64.195.45:7666 10.64.217.207:45584 - default
[2024-02-21T18:04:00.087Z] "POST / HTTP/1.1" 200 - via_upstream - "-" 626 176 1 0 "-" "-" "25dac8f9-8364-42bd-8fdd-d08285ed1632" "ebc-portal.ebc-bpm.svc.cluster.local" "10.64.195.45:7666" inbound|7666|| 127.0.0.6:39739 10.64.195.45:7666 10.64.217.207:45584 - default
[2024-02-21T18:04:00.088Z] "POST / HTTP/1.1" 0 DC downstream_remote_disconnect - "-" 159 0 1 - "-" "-" "bfa7dcee-123f-4582-9368-84edcb8476c7" "ebc-portal.ebc-bpm.svc.cluster.local" "10.64.195.45:7666" inbound|7666|| 127.0.0.6:39739 10.64.195.45:7666 10.64.217.207:45584 - default

lua复制代码2024-02-21T18:02:30.846361Z debug envoy router [C32432][S12678816626782510759] cluster 'inbound|7666||' match for URL '/'
2024-02-21T18:02:30.846396Z debug envoy router [C32432][S12678816626782510759] router decoding headers:
':authority', 'ebc-portal.ebc-bpm.svc.cluster.local'
':path', '/'
':method', 'POST'
':scheme', 'http'
'content-length', '159'
'x-forwarded-proto', 'http'
'x-request-id', 'ab261a30-679c-403d-be2b-12b161810f28'
2024-02-21T18:02:30.846434Z debug envoy router [C32432][S12678816626782510759] pool ready
2024-02-21T18:02:30.846469Z debug envoy http [C32432][S12678816626782510759] request end stream
2024-02-21T18:04:00.877035Z debug envoy router [C32432][S12678816626782510759] upstream reset: reset reason: connection termination, transport failure reason:
2024-02-21T18:04:00.877095Z debug envoy http [C32432][S12678816626782510759] Sending local reply with details upstream_reset_before_response_started{connection_termination}
2024-02-21T18:04:00.877148Z debug envoy http [C32432][S12678816626782510759] encoding headers via codec (end_stream=false):
':status', '503'
'content-length', '95'
'content-type', 'text/plain'
'date', 'Mon, 21 Feb 2024 18:04:00 GMT'
'server', 'istio-envoy'

yaml复制代码apiVersion: networking.istio.io/v1beta1
kind: Sidecar
metadata:
  name: direct-xxl-job-my-app
  namespace: ebc-bpm
spec:
  # 入口流量设置
  ingress:
  # 直接转发到Pod容器的7679接口
  - defaultEndpoint: 127.0.0.1:7679
    port:
      name: direct-access-port
      number: 7679
      protocol: TCP
  # 对应的工作负载
  workloadSelector:
    labels:
      app: my-app

js复制代码/**
 * 伪代码，Taro的构建配置文件 https://docs.taro.zone/docs/config-detail
 * config/index.js
 */
module.exports =  {
  ...
  plugins: ['taro-plugin-xxx'],
  ...
};

scss复制代码# ActivityStarter
  private int executeRequest(Request request) {
        ......
        final ActivityRecord r = new ActivityRecord.Builder(mService)
                .setCaller(callerApp)
                .setLaunchedFromPid(callingPid)
                .setLaunchedFromUid(callingUid)
                .setLaunchedFromPackage(callingPackage)
                .setLaunchedFromFeature(callingFeatureId)
                .setIntent(intent)
                .setResolvedType(resolvedType)
                .setActivityInfo(aInfo)
                .setConfiguration(mService.getGlobalConfiguration())
                .setResultTo(resultRecord)
                .setResultWho(resultWho)
                .setRequestCode(requestCode)
                .setComponentSpecified(request.componentSpecified)
                .setRootVoiceInteraction(voiceSession != null)
                .setActivityOptions(checkedOptions)
                .setSourceRecord(sourceRecord)
                .build();
        ......
        // 继续执行startActivityUnchecked
        mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
                request.voiceInteractor, startFlags, true /* doResume */, checkedOptions,
                inTask, inTaskFragment, restrictedBgActivity, intentGrants);
        ......
  }

less复制代码# ActivityStarter
    private Task getOrCreateRootTask(ActivityRecord r, int launchFlags, Task task,
            ActivityOptions aOptions) {
        final boolean onTop =
                (aOptions == null || !aOptions.getAvoidMoveToFront()) && !mLaunchTaskBehind;
        final Task sourceTask = mSourceRecord != null ? mSourceRecord.getTask() : null;
        return mRootWindowContainer.getOrCreateRootTask(r, aOptions, task, sourceTask, onTop,
                mLaunchParams, launchFlags);
    }
// onTop 表示是否要移到到当前栈顶，那肯定是要的，新启动的Activity当前要再最上面，这里 aOptions 为null，所以为true
// sourceTask 表示从哪里启动的，当前launch所在的Task 就是sourceTask

# RootWindowContainer
    Task getOrCreateRootTask(@Nullable ActivityRecord r, @Nullable ActivityOptions options,
            @Nullable Task candidateTask, boolean onTop) {
        return getOrCreateRootTask(r, options, candidateTask, null /* sourceTask */, onTop,
                null /* launchParams */, 0 /* launchFlags */);
    }
    Task getOrCreateRootTask(@Nullable ActivityRecord r,
            @Nullable ActivityOptions options, @Nullable Task candidateTask,
            @Nullable Task sourceTask, boolean onTop,
            @Nullable LaunchParamsController.LaunchParams launchParams, int launchFlags) {
            ......
            final int activityType = resolveActivityType(r, options, candidateTask);
            if (taskDisplayArea != null) {
                if (canLaunchOnDisplay(r, taskDisplayArea.getDisplayId())) {
                    // 重点*1. 传递到TaskDisplayArea
                    return taskDisplayArea.getOrCreateRootTask(r, options, candidateTask,
                            sourceTask, launchParams, launchFlags, activityType, onTop);
                } else {
                    taskDisplayArea = null;
                }
            }
            ......
    }
// 经过同名调用后，逻辑进入到  TaskDisplayArea

# TaskDisplayArea
    Task getOrCreateRootTask(int windowingMode, int activityType, boolean onTop,
            @Nullable Task candidateTask, @Nullable Task sourceTask,
            @Nullable ActivityOptions options, int launchFlags) {
            if(....) {
                // 拿到之前创建的Task
                return candidateTask.getRootTask();
            }
            ......// 第一次显示所以是新建Task
            return new Task.Builder(mAtmService)
                .setWindowingMode(windowingMode)
                .setActivityType(activityType)
                .setOnTop(onTop)
                .setParent(this)  // 主要这个this被设置为Parent。所以直接挂载到了DefaultTaskDisplayArea下
                .setSourceTask(sourceTask)
                .setActivityOptions(options)
                .setLaunchFlags(launchFlags)
                .build();
    }
// 看方法名是获取或创建Task, 这边是新启动的Activity所以需要创建Task。如果是以默认启动方式打开应用内的另一个Activity，就走的是上面的 return candidateTask.getRootTask();
接下来就是真正触发Task的创建。
// 另外设置的parent就是层级结构树应用所在的名为“DefaultTaskDisplayArea”的TaskDisplayArea
# Task
    # Task.Builder
        Task build() {
            if (mParent != null && mParent instanceof TaskDisplayArea) {
                validateRootTask((TaskDisplayArea) mParent);
            }

            if (mActivityInfo == null) {
                mActivityInfo = new ActivityInfo();
                mActivityInfo.applicationInfo = new ApplicationInfo();
            }

            mUserId = UserHandle.getUserId(mActivityInfo.applicationInfo.uid);
            mTaskAffiliation = mTaskId;
            mLastTimeMoved = System.currentTimeMillis();
            mNeverRelinquishIdentity = true;
            mCallingUid = mActivityInfo.applicationInfo.uid;
            mCallingPackage = mActivityInfo.packageName;
            mResizeMode = mActivityInfo.resizeMode;
            mSupportsPictureInPicture = mActivityInfo.supportsPictureInPicture();
            if (mActivityOptions != null) {
                mRemoveWithTaskOrganizer = mActivityOptions.getRemoveWithTaskOranizer();
            }
            // 重点* 1. 创建task
            final Task task = buildInner();
            task.mHasBeenVisible = mHasBeenVisible;

            // Set activity type before adding the root task to TaskDisplayArea, so home task can
            // be cached, see TaskDisplayArea#addRootTaskReferenceIfNeeded().
            if (mActivityType != ACTIVITY_TYPE_UNDEFINED) {
                task.setActivityType(mActivityType);
            }
            // 重点* 2. 入栈 这里的 mOnTop为true
            if (mParent != null) {
                if (mParent instanceof Task) {
                    final Task parentTask = (Task) mParent;
                    parentTask.addChild(task, mOnTop ? POSITION_TOP : POSITION_BOTTOM,
                            (mActivityInfo.flags & FLAG_SHOW_FOR_ALL_USERS) != 0);
                } else {
                    mParent.addChild(task, mOnTop ? POSITION_TOP : POSITION_BOTTOM);
                }
            }

            // Set windowing mode after attached to display area or it abort silently.
            if (mWindowingMode != WINDOWING_MODE_UNDEFINED) {
                task.setWindowingMode(mWindowingMode, true /* creating */);
            }
            // 返回
            return task;
        }

        // 创建
        Task buildInner() {
            return new Task(mAtmService, mTaskId, mIntent, mAffinityIntent, mAffinity,
                    mRootAffinity, mRealActivity, mOrigActivity, mRootWasReset, mAutoRemoveRecents,
                    mAskedCompatMode, mUserId, mEffectiveUid, mLastDescription, mLastTimeMoved,
                    mNeverRelinquishIdentity, mLastTaskDescription, mLastSnapshotData,
                    mTaskAffiliation, mPrevAffiliateTaskId, mNextAffiliateTaskId, mCallingUid,
                    mCallingPackage, mCallingFeatureId, mResizeMode, mSupportsPictureInPicture,
                    mRealActivitySuspended, mUserSetupComplete, mMinWidth, mMinHeight,
                    mActivityInfo, mVoiceSession, mVoiceInteractor, mCreatedByOrganizer,
                    mLaunchCookie, mDeferTaskAppear, mRemoveWithTaskOrganizer);
        }

java复制代码# ActivityStarer
    private void setNewTask(Task taskToAffiliate) {
        // 为true
        final boolean toTop = !mLaunchTaskBehind && !mAvoidMoveToFront;
        // 就是mTargetRootTask,也就是刚刚创建的Task
        final Task task = mTargetRootTask.reuseOrCreateTask(
                mNewTaskInfo != null ? mNewTaskInfo : mStartActivity.info,
                mNewTaskIntent != null ? mNewTaskIntent : mIntent, mVoiceSession,
                mVoiceInteractor, toTop, mStartActivity, mSourceRecord, mOptions);
        task.mTransitionController.collectExistenceChange(task);
        // ActivityRecord的挂载
        addOrReparentStartingActivity(task, "setTaskFromReuseOrCreateNewTask");
        // 需要注意这里的日志打印
        ProtoLog.v(WM_DEBUG_TASKS, "Starting new activity %s in new task %s",
                mStartActivity, mStartActivity.getTask());

        // mLaunchTaskBehind 为false，所以taskToAffiliate 为null 
        if (taskToAffiliate != null) {
            mStartActivity.setTaskToAffiliateWith(taskToAffiliate);
        }
    }

less复制代码# ActivityStarer
    private void addOrReparentStartingActivity(@NonNull Task task, String reason) {
        //  newParent = task 都是刚刚创建的Task
        TaskFragment newParent = task;
        ......
        if (mStartActivity.getTaskFragment() == null
                || mStartActivity.getTaskFragment() == newParent) {
            // 重点， 将 ActivityRecord挂在到新创建的Task中，并且是顶部
            newParent.addChild(mStartActivity, POSITION_TOP);
        } else {
            mStartActivity.reparent(newParent, newParent.getChildCount() /* top */, reason);
        }
    }

java复制代码#  WindowManagerService

    public int addWindow(Session session, IWindow client, LayoutParams attrs, int viewVisibility,
            int displayId, int requestUserId, InsetsVisibilities requestedVisibilities,
            InputChannel outInputChannel, InsetsState outInsetsState,
            InsetsSourceControl[] outActiveControls) {
                ......// token处理
                // 创建WindowState
                final WindowState win = new WindowState(this, session, client, token, parentWindow,
                            appOp[0], attrs, viewVisibility, session.mUid, userId,
                            session.mCanAddInternalSystemWindow);
                ......
                // 7. 窗口添加进容器
                win.attach();
                ......
                win.mToken.addWindow(win);
                ......
            }

typescript复制代码# ActivityRecord
    @Override
    void addWindow(WindowState w) {
        super.addWindow(w);
        ......
    }

scss复制代码# WindowToken
    void addWindow(final WindowState win) {
        ProtoLog.d(WM_DEBUG_FOCUS,
                "addWindow: win=%s Callers=%s", win, Debug.getCallers(5));

        if (win.isChildWindow()) {
            // Child windows are added to their parent windows.
            return;
        }
        // This token is created from WindowContext and the client requests to addView now, create a
        // surface for this token.
        // 真正添加进子容器，调用的是WindowContainer的方法
        if (!mChildren.contains(win)) {
            ProtoLog.v(WM_DEBUG_ADD_REMOVE, "Adding %s to %s", win, this);
            // 定义在WindowContainer中，其实就是挂载到父容器下了
            addChild(win, mWindowComparator);
            mWmService.mWindowsChanged = true;
            // TODO: Should we also be setting layout needed here and other places?
        }
    }

java复制代码    public int addWindow(Session session, IWindow client, LayoutParams attrs, int viewVisibility,
            int displayId, int requestUserId, InsetsVisibilities requestedVisibilities,
            InputChannel outInputChannel, InsetsState outInsetsState,
            InsetsSourceControl[] outActiveControls) {
            ......
            // 系统应用获取不到token
            WindowToken token = displayContent.getWindowToken(
                    hasParent ? parentWindow.mAttrs.token : attrs.token);
            ......
            if (token == null) {
                ......
                } else {
                    final IBinder binder = attrs.token != null ? attrs.token : client.asBinder();
                    token = new WindowToken.Builder(this, binder, type)
                            .setDisplayContent(displayContent)
                            .setOwnerCanManageAppTokens(session.mCanAddInternalSystemWindow)
                            .setRoundedCornerOverlay(isRoundedCornerOverlay)
                            .build();
                }
            }
            // 创建WindowState
                final WindowState win = new WindowState(this, session, client, token, parentWindow,
                            appOp[0], attrs, viewVisibility, session.mUid, userId,
                            session.mCanAddInternalSystemWindow);
            ......
            // 窗口添加进容器
            win.attach();
            ......
            win.mToken.addWindow(win);
            ......

java复制代码# WindowToken
    protected WindowToken(WindowManagerService service, IBinder _token, int type,
            boolean persistOnEmpty, DisplayContent dc, boolean ownerCanManageAppTokens,
            boolean roundedCornerOverlay, boolean fromClientToken, @Nullable Bundle options) {
        super(service);
        token = _token;
        windowType = type;
        ......
        if (dc != null) {
            // 添加token
            dc.addWindowToken(token, this);
        }
    }

scss复制代码# DisplayContent
    DisplayAreaPolicy mDisplayAreaPolicy;

    void addWindowToken(IBinder binder, WindowToken token) {
        ......
        // 放入集合
        mTokenMap.put(binder, token);

        if (token.asActivityRecord() == null) {
            ......
            // 找到对应的位置挂载
            final DisplayArea.Tokens da = findAreaForToken(token).asTokens();
            da.addChild(token);
        }
    }

    DisplayArea findAreaForToken(WindowToken windowToken) {
        // 根据type查找
        return findAreaForWindowType(windowToken.getWindowType(), windowToken.mOptions,
                windowToken.mOwnerCanManageAppTokens, windowToken.mRoundedCornerOverlay);
    }

    DisplayArea findAreaForWindowType(int windowType, Bundle options,
            boolean ownerCanManageAppToken, boolean roundedCornerOverlay) {
        // 应用类型
        if (windowType >= FIRST_APPLICATION_WINDOW && windowType <= LAST_APPLICATION_WINDOW) {
            return mDisplayAreaPolicy.getTaskDisplayArea(options);
        }
        // 输入法窗口
        if (windowType == TYPE_INPUT_METHOD || windowType == TYPE_INPUT_METHOD_DIALOG) {
            return getImeContainer();
        }
        // 其他类型
        return mDisplayAreaPolicy.findAreaForWindowType(windowType, options,
                ownerCanManageAppToken, roundedCornerOverlay);
    }

scala复制代码# DisplayAreaPolicyBuilder

   static class Result extends DisplayAreaPolicy {
        final BiFunction<Integer, Bundle, RootDisplayArea> mSelectRootForWindowFunc;
        ......
        @Override
        public DisplayArea.Tokens findAreaForWindowType(int type, Bundle options,
                boolean ownerCanManageAppTokens, boolean roundedCornerOverlay) {
            return mSelectRootForWindowFunc.apply(type, options).findAreaForWindowTypeInLayer(type,
                    ownerCanManageAppTokens, roundedCornerOverlay);
        }
        ......
   }

java复制代码// 根据type 找到在容器树的位置， 如果是应用或者输入法都走不到这
# RootDisplayArea
    // 这个就是层级树的
    private DisplayArea.Tokens[] mAreaForLayer;
    @Nullable
    DisplayArea.Tokens findAreaForWindowTypeInLayer(int windowType, boolean ownerCanManageAppTokens,
            boolean roundedCornerOverlay) {
        // 获取到type
        int windowLayerFromType = mWmService.mPolicy.getWindowLayerFromTypeLw(windowType,
                ownerCanManageAppTokens, roundedCornerOverlay);
        if (windowLayerFromType == APPLICATION_LAYER) {
            throw new IllegalArgumentException(
                    "There shouldn't be WindowToken on APPLICATION_LAYER");
        }
        // 根据type查找对应的位置
        return mAreaForLayer[windowLayerFromType];
    }

less复制代码# DisplayAreaPolicyBuilder.HierarchyBuilder

        private final RootDisplayArea mRoot;

        private void build(@Nullable List<HierarchyBuilder> displayAreaGroupHierarchyBuilders) {
            ......// 层级树的构建
            // 通知根节点已经完成了所有DisplayArea的添加 （将displayAreaForLayer保存在RootDisplayArea成员变量roomAreaForLayer中，供后面逻辑使用）
            mRoot.onHierarchyBuilt(mFeatures, displayAreaForLayer, featureAreas);
        }

ini复制代码# RootDisplayArea
    private DisplayArea.Tokens[] mAreaForLayer;

    void onHierarchyBuilt(ArrayList<Feature> features, DisplayArea.Tokens[] areaForLayer,
            Map<Feature, List<DisplayArea<WindowContainer>>> featureToDisplayAreas) {
        if (mHasBuiltHierarchy) {
            throw new IllegalStateException("Root should only build the hierarchy once");
        }
        mHasBuiltHierarchy = true;
        mFeatures = Collections.unmodifiableList(features);
        // 赋值
        mAreaForLayer = areaForLayer;
        mFeatureToDisplayAreas = featureToDisplayAreas;
    }

typescript复制代码# WindowManagerService
    RootWindowContainer mRoot;

    private void doDump(FileDescriptor fd, PrintWriter pw, String[] args, boolean useProto) {
        ......
            // containers
            } else if ("containers".equals(cmd)) {
                synchronized (mGlobalLock) {
                    mRoot.dumpChildrenNames(pw, " ");
                    pw.println(" ");
                    mRoot.forAllWindows(w -> {pw.println(w);}, true /* traverseTopToBottom */);
                }
                return;
            } else if ("trace".equals(cmd)) {
        ......
    }
    //  打印的name
    @Override
    String getName() {
        return "ROOT";
    }

scss复制代码# ConfigurationContainer
    public void dumpChildrenNames(PrintWriter pw, String prefix) {
        final String childPrefix = prefix + " ";
        pw.println(getName()
                + " type=" + activityTypeToString(getActivityType())
                + " mode=" + windowingModeToString(getWindowingMode())
                + " override-mode=" + windowingModeToString(getRequestedOverrideWindowingMode())
                + " requested-bounds=" + getRequestedOverrideBounds().toShortString()
                + " bounds=" + getBounds().toShortString());
        for (int i = getChildCount() - 1; i >= 0; --i) {
            final E cc = getChildAt(i);
            // 打印 # 加角标
            pw.print(childPrefix + "#" + i + " ");
            cc.dumpChildrenNames(pw, childPrefix);
        }
    }

csharp复制代码# WindowManagerService
    // The root of the device window hierarchy.
    RootWindowContainer mRoot;
    // WMS构造函数
    private WindowManagerService(......) {
        ......
        mRoot = new RootWindowContainer(this);
        ......
    }

ini复制代码# RootWindowContainer
    void setWindowManager(WindowManagerService wm) {
        mWindowManager = wm;
        mDisplayManager = mService.mContext.getSystemService(DisplayManager.class);
        mDisplayManager.registerDisplayListener(this, mService.mUiHandler);
        mDisplayManagerInternal = LocalServices.getService(DisplayManagerInternal.class);

        final Display[] displays = mDisplayManager.getDisplays();
        //  遍历每个屏幕
        for (int displayNdx = 0; displayNdx < displays.length; ++displayNdx) {
            final Display display = displays[displayNdx];
            // 重点*1：为每一个 Display 挂载一个 DisplayContent 节点
            final DisplayContent displayContent = new DisplayContent(display, this);
            addChild(displayContent, POSITION_BOTTOM);
            if (displayContent.mDisplayId == DEFAULT_DISPLAY) {
                mDefaultDisplay = displayContent;
            }
        }
    
        // 重点*2  TaskDisplayArea相关
        final TaskDisplayArea defaultTaskDisplayArea = getDefaultTaskDisplayArea();
        defaultTaskDisplayArea.getOrCreateRootHomeTask(ON_TOP);
        positionChildAt(POSITION_TOP, defaultTaskDisplayArea.mDisplayContent,
                false /* includingParents */);
    }

scss复制代码# DisplayContent
    // 2个参数为Display和跟容器
    DisplayContent(Display display, RootWindowContainer root) {
        ......
        // 创建事务
        final Transaction pendingTransaction = getPendingTransaction();
        // 重点开始构建层级树
        configureSurfaces(pendingTransaction);
        // 执行事务
        pendingTransaction.apply();
        ......
    }

    private void configureSurfaces(Transaction transaction) {
        // 构建一个SurfaceControl
        final SurfaceControl.Builder b = mWmService.makeSurfaceBuilder(mSession)
                .setOpaque(true)
                .setContainerLayer()
                .setCallsite("DisplayContent");
        // 设置名字后构建 （Display 0 name="XXX"）
        mSurfaceControl = b.setName(getName()).setContainerLayer().build();

        // 重点* 设置策略并构建显示区域层次结构
        if (mDisplayAreaPolicy == null) {
            // WMS的getDisplayAreaPolicyProvider方法按返回 DisplayAreaPolicy.Provider
            // 然后其 instantiate的实现 目前只有DisplayAreaPolicy的内部类DefaultProvider
            
            mDisplayAreaPolicy = mWmService.getDisplayAreaPolicyProvider().instantiate(
                    mWmService, this /* content */, this /* root */,
                    mImeWindowsContainer);
        }
        // 事务相关设置
        transaction
                .setLayer(mSurfaceControl, 0)
                .setLayerStack(mSurfaceControl, mDisplayId)
                .show(mSurfaceControl)
                .setLayer(mOverlayLayer, Integer.MAX_VALUE)
                .show(mOverlayLayer);
    }

csharp复制代码# DisplayContent
    String getName() {
        return "Display " + mDisplayId + " name=\"" + mDisplayInfo.name + "\"";
    }

shell复制代码  #0 Display 0 name="Built-in Screen"

scss复制代码# DisplayAreaPolicy.Provider
        @Override
        public DisplayAreaPolicy instantiate(WindowManagerService wmService,
                DisplayContent content, RootDisplayArea root,
                DisplayArea.Tokens imeContainer) {

            // 重点*1. 创建一个名为 "DefaultTaskDisplayArea" 的对象作为应用窗口的默认容器（第三个参数Feature为FEATURE_DEFAULT_TASK_CONTAINER）
            final TaskDisplayArea defaultTaskDisplayArea = new TaskDisplayArea(content, wmService,
                    "DefaultTaskDisplayArea", FEATURE_DEFAULT_TASK_CONTAINER);
            final List<TaskDisplayArea> tdaList = new ArrayList<>();
            //  实际上只有1个元素
            tdaList.add(defaultTaskDisplayArea);

            // Define the features that will be supported under the root of the whole logical
            // display. The policy will build the DisplayArea hierarchy based on this.
            // 传递RootDisplayArea（DisplayContent）构建出一个层级树的数据结构
            final HierarchyBuilder rootHierarchy = new HierarchyBuilder(root);
            // Set the essential containers (even if the display doesn't support IME).
            // 设置输入法容器
            rootHierarchy.setImeContainer(imeContainer).setTaskDisplayAreas(tdaList);

            // 这个条件满足，肯定是被信任的
            if (content.isTrusted()) {
                // 重点* 2 配置层级的支持的Feature
                configureTrustedHierarchyBuilder(rootHierarchy, wmService, content);
            }

            // Instantiate the policy with the hierarchy defined above. This will create and attach
            // all the necessary DisplayAreas to the root.
            // 重点* 3 真正开始构建层级树
            return new DisplayAreaPolicyBuilder().setRootHierarchy(rootHierarchy).build(wmService);
        }

less复制代码# DisplayAreaPolicy.Provider
        private void configureTrustedHierarchyBuilder(HierarchyBuilder rootHierarchy,
                WindowManagerService wmService, DisplayContent content) {
            // WindowedMagnification should be on the top so that there is only one surface
            // to be magnified.
            rootHierarchy.addFeature(new Feature.Builder(wmService.mPolicy, "WindowedMagnification",
                    FEATURE_WINDOWED_MAGNIFICATION)
                    .upTo(TYPE_ACCESSIBILITY_MAGNIFICATION_OVERLAY)
                    .except(TYPE_ACCESSIBILITY_MAGNIFICATION_OVERLAY)
                    // Make the DA dimmable so that the magnify window also mirrors the dim layer.
                    .setNewDisplayAreaSupplier(DisplayArea.Dimmable::new)
                    .build());
            if (content.isDefaultDisplay) {
                // Only default display can have cutout.
                // See LocalDisplayAdapter.LocalDisplayDevice#getDisplayDeviceInfoLocked.
                rootHierarchy.addFeature(new Feature.Builder(wmService.mPolicy, "HideDisplayCutout",
                        FEATURE_HIDE_DISPLAY_CUTOUT)
                        .all()
                        .except(TYPE_NAVIGATION_BAR, TYPE_NAVIGATION_BAR_PANEL, TYPE_STATUS_BAR,
                                TYPE_NOTIFICATION_SHADE)
                        .build())
                        .addFeature(new Feature.Builder(wmService.mPolicy, "OneHanded",
                                FEATURE_ONE_HANDED)
                                .all()
                                .except(TYPE_NAVIGATION_BAR, TYPE_NAVIGATION_BAR_PANEL,
                                        TYPE_SECURE_SYSTEM_OVERLAY)
                                .build());
            }
            rootHierarchy
                    .addFeature(new Feature.Builder(wmService.mPolicy, "FullscreenMagnification",
                            FEATURE_FULLSCREEN_MAGNIFICATION)
                            .all()
                            .except(TYPE_ACCESSIBILITY_MAGNIFICATION_OVERLAY, TYPE_INPUT_METHOD,
                                    TYPE_INPUT_METHOD_DIALOG, TYPE_MAGNIFICATION_OVERLAY,
                                    TYPE_NAVIGATION_BAR, TYPE_NAVIGATION_BAR_PANEL)
                            .build())
                    .addFeature(new Feature.Builder(wmService.mPolicy, "ImePlaceholder",
                            FEATURE_IME_PLACEHOLDER)
                            .and(TYPE_INPUT_METHOD, TYPE_INPUT_METHOD_DIALOG)
                            .build());
    }

ini复制代码# DisplayAreaPolicy.Feature.Builder
            Builder(WindowManagerPolicy policy, String name, int id) {
                mPolicy = policy;
                mName = name;
                mId = id;
                mLayers = new boolean[mPolicy.getMaxWindowLayer() + 1];
            }

php复制代码# DisplayAreaOrganizer
    /**
     * Display area that can be magnified in
     * ......
     */
    public static final int FEATURE_WINDOWED_MAGNIFICATION = FEATURE_SYSTEM_FIRST + 4;

    /**
     * Display area for hiding display cutout feature
     * @hide
     */
    public static final int FEATURE_HIDE_DISPLAY_CUTOUT = FEATURE_SYSTEM_FIRST + 6;

    /**
     * Display area for one handed feature
     */
    public static final int FEATURE_ONE_HANDED = FEATURE_SYSTEM_FIRST + 3;

    /**
     * Display area that can be magnified in
     * ......
     */
    public static final int FEATURE_FULLSCREEN_MAGNIFICATION = FEATURE_SYSTEM_FIRST + 5;

    /**
     * Display area that the IME container can be placed in. Should be enabled on every root
     * hierarchy if IME container may be reparented to that hierarchy when the IME target changed.
     * @hide
     */
    public static final int FEATURE_IME_PLACEHOLDER = FEATURE_SYSTEM_FIRST + 7;

typescript复制代码# DisplayAreaPolicy.Feature.Builder

     Builder all() {
        Arrays.fill(mLayers, true);
        return this;
    }

    Builder and(int... types) {
        for (int i = 0; i < types.length; i++) {
            int type = types[i];
            set(type, true);
        }
        return this;
    }

    Builder except(int... types) {
        for (int i = 0; i < types.length; i++) {
            int type = types[i];
            set(type, false);
        }
        return this;
    }

    Builder upTo(int typeInclusive) {
        // 根据传入的type计算到图层
        final int max = layerFromType(typeInclusive, false);
        for (int i = 0; i < max; i++) {
            mLayers[i] = true;
        }
        set(typeInclusive, true);
        return this;
    
    }
    private void set(int type, boolean value) {
        mLayers[layerFromType(type, true)] = value;
        ......
    }

    private int layerFromType(int type, boolean internalWindows) {
        return mPolicy.getWindowLayerFromTypeLw(type, internalWindows);
    }

    Feature build() {
        // 默认为true
        if (mExcludeRoundedCorner) {
            // Always put the rounded corner layer to the top most layer.
            mLayers[mPolicy.getMaxWindowLayer()] = false;
        }
        return new Feature(mName, mId, mLayers.clone(), mNewDisplayAreaSupplier);
    }

kotlin复制代码# WindowManagerPolicy
    default int getWindowLayerFromTypeLw(int type, boolean canAddInternalSystemWindow,
            boolean roundedCornerOverlay) {
        // Always put the rounded corner layer to the top most.
        // 第二个参数为false,这里忽略
        if (roundedCornerOverlay && canAddInternalSystemWindow) {
            return getMaxWindowLayer();
        }
        // 根据这2个type名字也知道表示 APP图层，对应的值是1-99，如果处于这直接就返回APPLICATION_LAYER =2
        if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {
            return APPLICATION_LAYER;
        }
        // 然后开始根据各个WindowType，去返回其在层级树中所在的图层
        switch (type) {
            case TYPE_WALLPAPER:
                // wallpaper is at the bottom, though the window manager may move it.
                return  1;
            case TYPE_PRESENTATION:
            case TYPE_PRIVATE_PRESENTATION:
            case TYPE_DOCK_DIVIDER:
            case TYPE_QS_DIALOG:
            case TYPE_PHONE:
                return  3;
            case TYPE_SEARCH_BAR:
                return  4;
            case TYPE_INPUT_CONSUMER:
                return  5;
            case TYPE_SYSTEM_DIALOG:
                return  6;
            case TYPE_TOAST:
                // toasts and the plugged-in battery thing
                return  7;
            case TYPE_PRIORITY_PHONE:
                // SIM errors and unlock.  Not sure if this really should be in a high layer.
                return  8;
            case TYPE_SYSTEM_ALERT:
                // like the ANR / app crashed dialogs
                // Type is deprecated for non-system apps. For system apps, this type should be
                // in a higher layer than TYPE_APPLICATION_OVERLAY.
                return  canAddInternalSystemWindow ? 12 : 9;
            case TYPE_APPLICATION_OVERLAY:
                return  11;
            case TYPE_INPUT_METHOD:
                // on-screen keyboards and other such input method user interfaces go here.
                return  13;
            case TYPE_INPUT_METHOD_DIALOG:
                // on-screen keyboards and other such input method user interfaces go here.
                return  14;
            case TYPE_STATUS_BAR:
                return  15;
            case TYPE_STATUS_BAR_ADDITIONAL:
                return  16;
            case TYPE_NOTIFICATION_SHADE:
                return  17;
            case TYPE_STATUS_BAR_SUB_PANEL:
                return  18;
            case TYPE_KEYGUARD_DIALOG:
                return  19;
            case TYPE_VOICE_INTERACTION_STARTING:
                return  20;
            case TYPE_VOICE_INTERACTION:
                // voice interaction layer should show above the lock screen.
                return  21;
            case TYPE_VOLUME_OVERLAY:
                // the on-screen volume indicator and controller shown when the user
                // changes the device volume
                return  22;
            case TYPE_SYSTEM_OVERLAY:
                // the on-screen volume indicator and controller shown when the user
                // changes the device volume
                return  canAddInternalSystemWindow ? 23 : 10;
            case TYPE_NAVIGATION_BAR:
                // the navigation bar, if available, shows atop most things
                return  24;
            case TYPE_NAVIGATION_BAR_PANEL:
                // some panels (e.g. search) need to show on top of the navigation bar
                return  25;
            case TYPE_SCREENSHOT:
                // screenshot selection layer shouldn't go above system error, but it should cover
                // navigation bars at the very least.
                return  26;
            case TYPE_SYSTEM_ERROR:
                // system-level error dialogs
                return  canAddInternalSystemWindow ? 27 : 9;
            case TYPE_MAGNIFICATION_OVERLAY:
                // used to highlight the magnified portion of a display
                return  28;
            case TYPE_DISPLAY_OVERLAY:
                // used to simulate secondary display devices
                return  29;
            case TYPE_DRAG:
                // the drag layer: input for drag-and-drop is associated with this window,
                // which sits above all other focusable windows
                return  30;
            case TYPE_ACCESSIBILITY_OVERLAY:
                // overlay put by accessibility services to intercept user interaction
                return  31;
            case TYPE_ACCESSIBILITY_MAGNIFICATION_OVERLAY:
                return 32;
            case TYPE_SECURE_SYSTEM_OVERLAY:
                return  33;
            case TYPE_BOOT_PROGRESS:
                return  34;
            case TYPE_POINTER:
                // the (mouse) pointer layer
                return  35;
            default:
                Slog.e("WindowManager", "Unknown window type: " + type);
                return 3;
        }
    }

less复制代码# DisplayAreaPolicy.Provider
        private void configureTrustedHierarchyBuilder(HierarchyBuilder rootHierarchy,
                WindowManagerService wmService, DisplayContent content) {
            // WindowedMagnification should be on the top so that there is only one surface
            // to be magnified.
            rootHierarchy.addFeature(new Feature.Builder(wmService.mPolicy, "WindowedMagnification",
                    FEATURE_WINDOWED_MAGNIFICATION)
                    .upTo(TYPE_ACCESSIBILITY_MAGNIFICATION_OVERLAY) // 0-32
                    .except(TYPE_ACCESSIBILITY_MAGNIFICATION_OVERLAY)// 32
                    // Make the DA dimmable so that the magnify window also mirrors the dim layer.
                    .setNewDisplayAreaSupplier(DisplayArea.Dimmable::new)
                    .build()); // 0-31
            if (content.isDefaultDisplay) {
                // Only default display can have cutout.
                // See LocalDisplayAdapter.LocalDisplayDevice#getDisplayDeviceInfoLocked.
                rootHierarchy.addFeature(new Feature.Builder(wmService.mPolicy, "HideDisplayCutout",
                        FEATURE_HIDE_DISPLAY_CUTOUT)
                        .all() //  0-36
                        .except(TYPE_NAVIGATION_BAR, TYPE_NAVIGATION_BAR_PANEL, TYPE_STATUS_BAR,
                                TYPE_NOTIFICATION_SHADE)//  24 25  15  17
                        .build())// 0-14   16  18-23 26-35
                        .addFeature(new Feature.Builder(wmService.mPolicy, "OneHanded",
                                FEATURE_ONE_HANDED)
                                .all()
                                .except(TYPE_NAVIGATION_BAR, TYPE_NAVIGATION_BAR_PANEL,
                                        TYPE_SECURE_SYSTEM_OVERLAY)//24  25  33
                                .build());// 0-23   26-32  34-35
            }
            rootHierarchy
                    .addFeature(new Feature.Builder(wmService.mPolicy, "FullscreenMagnification",
                            FEATURE_FULLSCREEN_MAGNIFICATION)
                            .all() // 0-36
                            .except(TYPE_ACCESSIBILITY_MAGNIFICATION_OVERLAY, TYPE_INPUT_METHOD,
                                    TYPE_INPUT_METHOD_DIALOG, TYPE_MAGNIFICATION_OVERLAY,
                                    TYPE_NAVIGATION_BAR, TYPE_NAVIGATION_BAR_PANEL)// 32  13   14  28  24 25
                            .build())// 0-12 15-23  26-27 29-31 33-35
                    .addFeature(new Feature.Builder(wmService.mPolicy, "ImePlaceholder",
                            FEATURE_IME_PLACEHOLDER)
                            .and(TYPE_INPUT_METHOD, TYPE_INPUT_METHOD_DIALOG)// 13-14
                            .build());// 13-14
        }
    }

csharp复制代码# HierarchyBuilder
    private final ArrayList<DisplayAreaPolicyBuilder.Feature> mFeatures = new ArrayList<>();

        HierarchyBuilder addFeature(DisplayAreaPolicyBuilder.Feature feature) {
            mFeatures.add(feature);
            return this;
        }

ini复制代码# DisplayAreaPolicyBuilder
    DisplayAreaPolicyBuilder setRootHierarchy(HierarchyBuilder rootHierarchyBuilder) {
        mRootHierarchyBuilder = rootHierarchyBuilder;
        return this;
    }

scss复制代码# DisplayAreaPolicyBuilder
    // 这个可以忽略，没有值
    private final ArrayList<HierarchyBuilder> mDisplayAreaGroupHierarchyBuilders =
            new ArrayList<>();

    Result build(WindowManagerService wmService) {
        //  对输入参数进行验证，确保它们是有效的
        validate();

        // Attach DA group roots to screen hierarchy before adding windows to group hierarchies.
        // 重点：构建层级树
        mRootHierarchyBuilder.build(mDisplayAreaGroupHierarchyBuilders);
        // 因为mDisplayAreaGroupHierarchyBuilders没有值，后面的都可以忽略
        ......
        return new Result(wmService, mRootHierarchyBuilder.mRoot, displayAreaGroupRoots,
                mSelectRootForWindowFunc);
    }

ini复制代码# DisplayAreaPolicyBuilder.PendingArea

    static class PendingArea {
        final int mMinLayer; // 最小层级
        final ArrayList<PendingArea> mChildren = new ArrayList<>();// 有Children说明也是一个容器
        final Feature mFeature; //  当前支持的Feature
        final PendingArea mParent; // 有父亲
        int mMaxLayer; // 最大层级
        // 从这几个成员变量其实能感觉到和上一篇画的层级树的图有点那味了
        @Nullable DisplayArea mExisting; // 当前存在的容器
        boolean mSkipTokens = false; // 只有输入法和应用会为true

        PendingArea(Feature feature, int minLayer, PendingArea parent) {
            mMinLayer = minLayer;
            mFeature = feature;
            mParent = parent;
        }
        ......
    }

ini复制代码# DisplayAreaPolicyBuilder.HierarchyBuilder

        private final RootDisplayArea mRoot;

        private void build(@Nullable List<HierarchyBuilder> displayAreaGroupHierarchyBuilders) {
            final WindowManagerPolicy policy = mRoot.mWmService.mPolicy;
            // 定义最大层级数  37 = 36+1 
            final int maxWindowLayerCount = policy.getMaxWindowLayer() + 1;
            // 存储每个窗口层级对应的 DisplayArea.Tokens,一共37个，后续窗口挂载也是在这个数据结构上找
            // 在方法底部执行instantiateChildren的时候调用
            final DisplayArea.Tokens[] displayAreaForLayer =
                    new DisplayArea.Tokens[maxWindowLayerCount];

            // 存储每个特性对应的 DisplayArea 列表
            // mFeatures就是在configureTrustedHierarchyBuilder配置的Feature大小，很明显一共是5个
            final Map<Feature, List<DisplayArea<WindowContainer>>> featureAreas =
                    new ArrayMap<>(mFeatures.size());
            for (int i = 0; i < mFeatures.size(); i++) {
                // 为每个feature，创建其对应的DisplayArea列表
                featureAreas.put(mFeatures.get(i), new ArrayList<>());
            }
            // 到这里featureAreas里一共是5个值，key就是上节提到的5个Feature，value目前就是个空的List

            // -------构建PendingArea树----
            // *1 创建 PendingArea 数组，用于临时存储每个窗口层级对应的 PendingArea，也是37个
            // 后面需要关注这个areaForLayer成员的变化
            PendingArea[] areaForLayer = new PendingArea[maxWindowLayerCount];
            // 先创建个PendingArea 再让areaForLayer的37个数据都默认为root的PendingArea
            // 注意第一个参数feature为null
            final PendingArea root = new PendingArea(null, 0, null);
            Arrays.fill(areaForLayer, root);

            // 2. 构建Features的树
            // mFeatures.size为5，所以有5个大循环
            final int size = mFeatures.size();
            for (int i = 0; i < size; i++) {
                // 拿到当前需要处理的Feature
                final Feature feature = mFeatures.get(i);
                PendingArea featureArea = null;
                // 内部循环，37次
                for (int layer = 0; layer < maxWindowLayerCount; layer++) {
                    // 如果这个层级，支持当前Feature
                    if (feature.mWindowLayers[layer]) {
                        //判断是否复用 PendingArea （同一个feature才复用，否则创建新的）
                        if (featureArea == null || featureArea.mParent != areaForLayer[layer]) {
                            // 创建新的 PendingArea，作为上一层级的子节点，用于当前层级，并且双向奔赴，设置为各自的孩子或者父亲
                            // 注意第一个参数feature
                            featureArea = new PendingArea(feature, layer, areaForLayer[layer]);
                            areaForLayer[layer].mChildren.add(featureArea);
                        }
                        areaForLayer[layer] = featureArea;
                    } else {
                        // 如果该特性不应用于当前窗口层级，则featureArea置为空。用于上面if的判断
                        featureArea = null;
                    }
                }
            }
            // 到这里，areaForLayer这个37层就按照feature分类，有自己对应的PendingArea了。


            // 3. 构建叶子节点相关的PendingArea，注意还是操作areaForLayer数组，但是操作的是内部元素的mChildren的值

            // 定义一个叶子节点用的 PendingArea
            PendingArea leafArea = null;
            int leafType = LEAF_TYPE_TOKENS;// 定义leafType
           
            for (int layer = 0; layer < maxWindowLayerCount; layer++) {
                //  获取每层的type，从这看type是和所在层级有关系的
                int type = typeOfLayer(policy, layer);
                // // 检查是否可以复用前一个层级的 Tokens，和前面的循环类似
                if (leafArea == null || leafArea.mParent != areaForLayer[layer]
                        || type != leafType) {
                    // 创建PendingArea，注意参数,featur为null
                    leafArea = new PendingArea(null /* feature */, layer, areaForLayer[layer]);
                    // 注意是添加到孩子，而不是跟上一次循环直接修改areaForLayer
                    areaForLayer[layer].mChildren.add(leafArea);
                    leafType = type;
                    // 应用类型处理
                    if (leafType == LEAF_TYPE_TASK_CONTAINERS) {
                        // 添加 TaskDisplayArea 到应用程序层级
                        addTaskDisplayAreasToApplicationLayer(areaForLayer[layer]);
                         // 添加 DisplayAreaGroup 到应用程序层级
                        addDisplayAreaGroupsToApplicationLayer(areaForLayer[layer],
                                displayAreaGroupHierarchyBuilders);
                        // 跳过创建 Tokens，即不创建 Tokens，即使没有 Task
                        leafArea.mSkipTokens = true;
                    } else if (leafType == LEAF_TYPE_IME_CONTAINERS) {
                        // 输入法处理
                        leafArea.mExisting = mImeContainer;
                         // 跳过
                        leafArea.mSkipTokens = true;
                    }
                }
                leafArea.mMaxLayer = layer;
            }
            // 计算根节点的最大层级
            root.computeMaxLayer();
            // -------构建DisplayAreas树----
            // 4. 根据之前定义的PendingArea生成最后的 DisplayAreas 树
            // 注意参数
            // We built a tree of PendingAreas above with all the necessary info to represent the
            // hierarchy, now create and attach real DisplayAreas to the root.
            root.instantiateChildren(mRoot, displayAreaForLayer, 0, featureAreas);

            // 通知根节点已经完成了所有DisplayArea的添加 （将displayAreaForLayer保存在RootDisplayArea成员变量roomAreaForLayer中，供后面逻辑使用）
            mRoot.onHierarchyBuilt(mFeatures, displayAreaForLayer, featureAreas);
        }

php复制代码# DisplayAreaPolicyBuilder.HierarchyBuilder
        private static final int LEAF_TYPE_TASK_CONTAINERS = 1; // APP
        private static final int LEAF_TYPE_IME_CONTAINERS = 2; // 输入法
        private static final int LEAF_TYPE_TOKENS = 0; // 默认

csharp复制代码# DisplayAreaPolicyBuilder.HierarchyBuilder

        private static int typeOfLayer(WindowManagerPolicy policy, int layer) {
            if (layer == APPLICATION_LAYER) {
                return LEAF_TYPE_TASK_CONTAINERS;
            } else if (layer == policy.getWindowLayerFromTypeLw(TYPE_INPUT_METHOD)
                    || layer == policy.getWindowLayerFromTypeLw(TYPE_INPUT_METHOD_DIALOG)) {
                return LEAF_TYPE_IME_CONTAINERS;
            } else {
                return LEAF_TYPE_TOKENS;
            }
        }

ini复制代码# DisplayAreaPolicyBuilder.HierarchyBuilder
    private final ArrayList<TaskDisplayArea> mTaskDisplayAreas = new ArrayList<>();

    HierarchyBuilder setTaskDisplayAreas(List<TaskDisplayArea> taskDisplayAreas) {
        mTaskDisplayAreas.clear();
        mTaskDisplayAreas.addAll(taskDisplayAreas);
        return this;
    }
    private void addTaskDisplayAreasToApplicationLayer(PendingArea parentPendingArea) {
        // 已知长度为1，
        final int count = mTaskDisplayAreas.size();
            
        for (int i = 0; i < count; i++) {
            PendingArea leafArea =
                    new PendingArea(null /* feature */, APPLICATION_LAYER, parentPendingArea);
            // 所以就是把“DefaultTaskDisplayArea”这个设置为mExisting
            leafArea.mExisting = mTaskDisplayAreas.get(i);
            leafArea.mMaxLayer = APPLICATION_LAYER;
            // parentPendingArea.mChildren本来为大家都一样的Leaf，又添加了一个DefaultTaskDisplayArea
            parentPendingArea.mChildren.add(leafArea);
        }
    }

scss复制代码# DisplayAreaPolicyBuilder.PendingArea

        void instantiateChildren(DisplayArea<DisplayArea> parent, DisplayArea.Tokens[] areaForLayer,
                int level, Map<Feature, List<DisplayArea<WindowContainer>>> areas) {
            // 1. 子区域按照它们的最小层级进行升序排列
            mChildren.sort(Comparator.comparingInt(pendingArea -> pendingArea.mMinLayer));
            // 2. 遍历孩子将PendingArea转换成DisplayArea
            for (int i = 0; i < mChildren.size(); i++) {
                final PendingArea child = mChildren.get(i);
                final DisplayArea area = child.createArea(parent, areaForLayer);
                if (area == null) {
                    // TaskDisplayArea and ImeContainer can be set at different hierarchy, so it can
                    // be null.
                    continue;
                }
                // 将返回的area设置为孩子,第一次执行的时候root就是DisplayContent
                parent.addChild(area, WindowContainer.POSITION_TOP);
                if (child.mFeature != null) {
                    // 让Feature对应的容器里添加创建的DisplayArea
                    areas.get(child.mFeature).add(area);
                }
                // 开始迭代构建
                child.instantiateChildren(area, areaForLayer, level + 1, areas);
            }
        }

typescript复制代码# DisplayAreaPolicyBuilder.PendingArea
        @Nullable
        private DisplayArea createArea(DisplayArea<DisplayArea> parent,
                DisplayArea.Tokens[] areaForLayer) {
            // 只有输入法和应用层mExisting有值
            if (mExisting != null) {
                if (mExisting.asTokens() != null) { 
                    // 只有输入法满足
                    // Store the WindowToken container for layers
                    fillAreaForLayers(mExisting.asTokens(), areaForLayer);
                }
                // 然后将mExisting作为结果返回
                return mExisting;
            }
            // mSkipTokens为true则返回，应用和IME创建的PendingArea
            if (mSkipTokens) {
                return null;
            }
            // 2. 定义DisplayArea的type
            DisplayArea.Type type;
            if (mMinLayer > APPLICATION_LAYER) {
                type = DisplayArea.Type.ABOVE_TASKS;
            } else if (mMaxLayer < APPLICATION_LAYER) {
                type = DisplayArea.Type.BELOW_TASKS;
            } else {
                type = DisplayArea.Type.ANY;
            }
            
            if (mFeature == null) {
                // // 3. 构建返回的leaf    注意第三个参数格式
                final DisplayArea.Tokens leaf = new DisplayArea.Tokens(parent.mWmService, type,
                        "Leaf:" + mMinLayer + ":" + mMaxLayer);
                fillAreaForLayers(leaf, areaForLayer); // 给对应覆盖的层级都需要赋值
                return leaf;
            } else {
                // 对有Feature的PendingArea返回构建
                return mFeature.mNewDisplayAreaSupplier.create(parent.mWmService, type,
                        mFeature.mName + ":" + mMinLayer + ":" + mMaxLayer, mFeature.mId);
            }
        }

ini复制代码# DisplayAreaPolicyBuilder.PendingArea
        private void fillAreaForLayers(DisplayArea.Tokens leaf, DisplayArea.Tokens[] areaForLayer) {
            for (int i = mMinLayer; i <= mMaxLayer; i++) {
                areaForLayer[i] = leaf;
            }
        }

arduino复制代码# DisplayAreaPolicyBuilder
    static class Feature {
        private final String mName;
        private final int mId;
        private final boolean[] mWindowLayers;
        private final NewDisplayAreaSupplier mNewDisplayAreaSupplier;
        // 构造函数
        private Feature(String name, int id, boolean[] windowLayers,
            NewDisplayAreaSupplier newDisplayAreaSupplier) {
            mName = name;
            mId = id;
            mWindowLayers = windowLayers;
            mNewDisplayAreaSupplier = newDisplayAreaSupplier;
        }
            static class Builder {
            ......
            // 默认为DisplayArea对象
            private NewDisplayAreaSupplier mNewDisplayAreaSupplier = DisplayArea::new;
            private boolean mExcludeRoundedCorner = true;
                Feature build() {
                ......
                return new Feature(mName, mId, mLayers.clone(), mNewDisplayAreaSupplier);
            }
            }
    }
     /** Supplier interface to provide a new created {@link DisplayArea}. */
    interface NewDisplayAreaSupplier {
        DisplayArea create(WindowManagerService wms, DisplayArea.Type type, String name,
                int featureId);
    }

ruby复制代码# 原始大字符串
SET user:1:description "Very long description..."
# 分割后的小字符串片段
SET user:1:description:part1 "Very long"
SET user:1:description:part2 " description..."

ruby复制代码# 使用压缩算法
SET user:1:description "Compressed description..." ZSTD

ruby复制代码# 使用Hash
HSET user:1:info description "Very long description..."

ruby复制代码# 定期清理字符串数据
DEL user:1:description:old

ruby复制代码# 原始大列表
LPUSH user:1:activity_log item1
LPUSH user:1:activity_log item2
LPUSH user:1:activity_log item3
# 分割后的小列表
LPUSH user:1:activity_log:part1 item1
LPUSH user:1:activity_log:part1 item2
LPUSH user:1:activity_log:part2 item3

ruby复制代码# 定期修剪列表
LTRIM user:1:activity_log 0 99

ruby复制代码# 使用有序集合
ZADD user:1:activity_log timestamp1 item1
ZADD user:1:activity_log timestamp2 item2

bash复制代码# 使用Stream
XADD user:1:activity_log * type item1
XADD user:1:activity_log * type item2

ruby复制代码# 原始大集合
SADD user:1:interests interest1
SADD user:1:interests interest2
SADD user:1:interests interest3
# 分割后的小集合
SADD user:1:interests:part1 interest1
SADD user:1:interests:part2 interest2
SADD user:1:interests:part2 interest3

ruby复制代码# 使用有序集合
ZADD user:1:interests 1 interest1
ZADD user:1:interests 2 interest2
ZADD user:1:interests 3 interest3

ruby复制代码# 使用HyperLogLog
PFADD user:1:interests interest1 interest2 interest3

ruby复制代码# 定期清理集合元素
SREM user:1:interests unwanted_interest

sql复制代码# 原始大哈希
HSET user:1 name John
HSET user:1 email john@example.com
HSET user:1 age 30
# 分组后的哈希
HSET user:1:info name John
HSET user:1:info email john@example.com
HSET user:1:info age 30

sql复制代码# 原始大哈希
HSET user:1 name John
HSET user:1 email john@example.com
HSET user:1 age 30
# 分散后的哈希
HSET user:1:info name John
HSET user:1:contact email john@example.com
HSET user:1:profile age 30

ruby复制代码# 使用多个哈希键
HSET user:1:info name John
HSET user:1:contact email john@example.com
HSET user:1:profile age 30

ruby复制代码# 定期清理不需要的字段
HDEL user:1:info unwanted_field

ruby复制代码# 原始大有序集合
ZADD user:1:scores 100 "Alice"
ZADD user:1:scores 200 "Bob"
ZADD user:1:scores 300 "Charlie"
# 分割后的小有序集合
ZADD user:1:scores:part1 100 "Alice"
ZADD user:1:scores:part2 200 "Bob"
ZADD user:1:scores:part3 300 "Charlie"

ruby复制代码# 按分数范围存储
ZADD user:1:scores:0to100 100 "Alice"
ZADD user:1:scores:101to200 200 "Bob"
ZADD user:1:scores:201to300 300 "Charlie"

ruby复制代码# 定期修剪有序集合
ZREMRANGEBYRANK user:1:scores 0 99

ruby复制代码# 使用哈希或字符串
HSET user:1:info score 100

ini复制代码// N 为 Redis 实例个数，M 为 N 的 2倍
const M = N * 2
//生成随机数
random = GenRandom(0, M)
//构造备份新 Key
bakHotKey = hotKey + "_" + random
data = redis.GET(bakHotKey)
if data == NULL {
    data = redis.GET(hotKey)
    if data == NULL {
        data = GetFromDB()
        // 可以利用原子锁来写入数据保证数据一致性
        redis.SET(hotKey, data, expireTime)
        redis.SET(bakHotKey, data, expireTime + GenRandom(0, 5))
    } else {
        redis.SET(bakHotKey, data, expireTime + GenRandom(0, 5))
    }
}