Android Advanced: In-depth understanding of the Android window management framework mechanism

[[423965]]

Preface

WindowManagerService is a window management service located in the Framework layer. Its responsibility is to manage all windows in the system, that is, Windows. In general, a Window is a display area on a mobile phone, that is, the drawing canvas Surface in Android. The process of adding a Window is the process of applying for a Surface, and the manager of the entire process is WindowManagerService.

Today we will analyze the knowledge points related to window WMS;

1. Window-related concepts

1. WindowManagerService concept

(1) WindowManagerService concept

The window management service of the Framework layer is responsible for managing all windows in the Android system. The window management service inherits IWindowManager.Stub and the Binder server, so the interaction between WM and WMS is also an IPC process. The main things that WMS does are as follows:

• Z-ordered maintenance functions
• Input method management
• AddWindow/RemoveWindow
• Layerout
• Token management, AppToken
• Active Window Management (FocusWindow)
• Event App Management (FocusApp)
• Transition Animation
• System message collection thread
• System message distribution thread

(2)WindowManager

The interface for applications to interact with the window management service WindowManagerService;

(3)PhoneWindowManager

Implemented various window strategies and defined window-related strategies, such as telling WMS what the Z-Order value of a certain type of Window is, helping WMS correct unreasonable window properties, monitoring the screen rotation status for WMS, and pre-processing some system key events;

(4)Choreographer

The user controls window animation, screen selection and other operations. It has the ability to obtain Vsync synchronization events from the display subsystem, so that it can notify the rendering action at the right time to avoid screen tearing caused by screen redrawing during the rendering process. WMS uses Choreographer to drive the rendering of all window animations, screen rotation animations, and wallpaper animations;

(5)DisplayContent

Used to describe information related to multi-screen output;

Group windows according to their display positions. Windows belonging to the same DisplayContent will be displayed on the same screen. Each DisplayContent corresponds to a unique ID. When adding a window, you can specify this ID to determine which screen it will be displayed on;

DisplayContent is a very isolated concept. Two windows in different DisplayContents will not have any coupling in layout, display order, and animation processing;

(6)WindowState

Describes the state information of the window and communicates with WindowManagerService. Generally, one window corresponds to one WindowState. It is used to represent all the properties of a window;

(7)WindowToken

• Window Token, used for Binder communication; it is also an identifier;
• When sorting windows in Zorder, windows belonging to the same WindowToken will be arranged together, and some properties defined in it will affect all windows belonging to this WindowToken, which shows the close connection between windows belonging to the same WindowToken;
• When an application component needs a new window, it must provide a WindowToken to identify itself, and the type of the window must be consistent with the type of the WindowToken it holds;
• When creating a system-type window, you do not need to provide a valid Token. WMS will implicitly declare a WindowToken for it. It seems that anyone can add a system-level window. Does Android ignore security for the convenience of internal use? No, the purpose of mPolicy.checkAddPermission() at the beginning of the addWindow() function is just that. It requires the client to have SYSTEM_ALERT_WINDOW or INTERNAL_SYSTEM_WINDOW permissions to create a system;

(8)Session

The App process establishes a connection with the WMS by establishing a Session proxy object to communicate with the Session object;

(9)SurfaceFlinger

SurfaceFlinger is responsible for managing the frame buffer of the Android system. The display screen of the Android device is abstracted as a frame buffer, and the SurfaceFlinger service in the Android system draws the user interface in the application by writing content to this frame buffer.

(10)InputManager

Manage the input event channel (InputChannel) of each window and dispatch events to the channel;

(11)Animator

The manager of all window animations (WindowStateAnimator object). Driven by Choreographer, all animations are rendered one by one;

2. Window

• Represents the concept of a window, which is the direct manager of all Views. Any view is presented through Window (click events are handled by Window->DecorView->View; Activity's setContentView is handled by Window at the bottom layer)
• Window is an abstract class, and its concrete implementation is PhoneWindow;
• Creating a Window requires creating it through WindowManager;
• WindowManager is the entrance for the outside world to access Window;
• The specific implementation of Window is located in WindowManagerService;
• The interaction between WindowManager and WindowManagerService is completed through IPC inter-process communication;
• An abstract base class that defines window styles and behaviors, used to add a top-level View to WindowManager. Its implementation class is PhoneWindow.
• Each Window needs to specify a Type (application window, child window, system window). The window corresponding to Activity is the application window; PhoneWindow, ContextMenu, and OptionMenu are commonly used child windows; Toast and system warning prompt boxes (such as ANR) are system windows, and many application floating windows are also system windows;

3. Surface

• In Android, a window occupies a Surface exclusively. Surface is actually a canvas. Applications draw content on Surface through Canvas or OpenGL.
• After drawing on the Surface, SurfaceFlinger mixes the contents of multiple Surfaces in Z-order and outputs them to FrameBuffer, thus displaying the Android page to the user;
• Each window has a Surface to display its own UI, so a role is needed to manage the windows in a unified way. At this time, WMS came into being. WMS allocates Surface to all windows, manages the z-order, position, size, and entry and exit animation of windows, and is also a transfer station for input system;
• Layout system: calculates and manages the position and hierarchy of windows;
• Animation system: Renders window animations based on calculations by the layout system;

4. Window Type

• Application window: The level range is 1~99
• Subwindow: The level range is 1000~1999
• System window: The level range is 2000~2999

5. Window flags display properties

 // Window feature flags
 public   int flags;
 // When the window is visible to the user, allow the screen to be locked
 public   static final int FLAG_ALLOW_LOCK_WHILE_SCREEN_ON = 0x00000001;
 // Darken everything behind the window
 public   static final int FLAG_DIM_BEHIND = 0x00000002;
 // Everything behind the window is blurred
 public   static final int FLAG_BLUR_BEHIND = 0x00000004;
 // The window cannot get focus
 public   static final int FLAG_NOT_FOCUSABLE = 0x00000008;
 // The window does not accept touch screen events
 public   static final int FLAG_NOT_TOUCHABLE = 0x00000010;
 //Allow click events from this window to be passed to the window behind the current window, even if the window can get focus
 public   static final int FLAG_NOT_TOUCH_MODAL = 0x00000020;
 // When the phone is in sleep mode, if the screen is pressed, this window will be the first to receive the touch event
 public   static final int FLAG_TOUCHABLE_WHEN_WAKING = 0x00000040;
 // When the window is visible to the user, the screen is always on
 public   static final int FLAG_KEEP_SCREEN_ON = 0x00000080;
 // Make the window fill the entire screen without leaving any borders
 public   static final int FLAG_LAYOUT_IN_SCREEN = 0x00000100;
 // Allow the window to exceed the entire phone screen
 public   static final int FLAG_LAYOUT_NO_LIMITS = 0x00000200;
 //Window full name display
 public   static final int FLAG_FULLSCREEN = 0x00000400;
 // Restore window non-full screen display
 public   static final int FLAG_FORCE_NOT_FULLSCREEN = 0x00000800;
 // Enable window jitter
 public   static final int FLAG_DITHER = 0x00001000;
 //Secure content window. Screen capture is not allowed when this window is displayed.
 public   static final int FLAG_SECURE = 0x00002000;
 // A special mode in which layout parameters are used to perform scaling when compositing the surface to the screen.
 public   static final int FLAG_SCALED = 0x00004000;
 public   static final int FLAG_IGNORE_CHEEK_PRESSES = 0x00008000;
 public   static final int FLAG_LAYOUT_INSET_DECOR = 0x00010000;
 public   static final int FLAG_ALT_FOCUSABLE_IM = 0x00020000;
 // Receive a single special MotionEvent for touches occurring outside the window.
 // Instead of receiving the full down/up/up gesture, only the position of the first down gesture will be received as ACTION_OUTSIDE.
 public   static final int FLAG_WATCH_OUTSIDE_TOUCH = 0x00040000;
 // Display this window when the screen is locked
 public   static final int FLAG_SHOW_WHEN_LOCKED = 0x00080000;
 // The system's wallpaper is displayed behind this window
 public   static final int FLAG_SHOW_WALLPAPER = 0x00100000;
 // When the window is displayed, the system will treat it as a user activity event to light up the phone screen
 public   static final int FLAG_TURN_SCREEN_ON = 0x00200000;
 // This window is displayed and the keyboard disappears
 public   static final int FLAG_DISMISS_KEYGUARD = 0x00400000;
 // When the window can accept the touch screen, let the signal be sent to the window behind because it is outside the window
 // The touch screen can support split touch
 public   static final int FLAG_SPLIT_TOUCH = 0x00800000;
 // Hardware acceleration for this window. This flag must be set before the content view of the activity or dialog.
 public   static final int FLAG_HARDWARE_ACCELERATED = 0x01000000;
 // Let the window fill the entire phone screen without leaving any borders
 public   static final int FLAG_LAYOUT_IN_OVERSCAN = 0x02000000;
 // Transparent status bar
 public   static final int FLAG_TRANSLUCENT_STATUS = 0x04000000;
 // Transparent navigation bar
 public   static final int FLAG_TRANSLUCENT_STATUS = 0x04000000;

2. Window Adding Process

 public final class WindowManagerGlobal {
 public void addView( View   view , ViewGroup.LayoutParams params,
                Display display, Window parentWindow) {
 //Check the validity of the parameters
 ...
 //ViewRootImpl encapsulates the interaction between View and WindowManager
            ViewRootImpl root;
 View panelParentView = null ;
            synchronized (mLock) {
                // Start watching for system property changes.
                if (mSystemPropertyUpdater == null ) {
                    mSystemPropertyUpdater = new Runnable() {
                        @Override public void run() {
                            synchronized (mLock) {
 for ( int i = mRoots. size () - 1; i >= 0; --i) {  
                                    mRoots.get(i).loadSystemProperties();
                                }
 }
 }
 };
                    SystemProperties.addChangeCallback(mSystemPropertyUpdater);
 }
 int   index = findViewLocked( view , false );
                if ( index >= 0) {
                    if (mDyingViews. contains ( view )) {
                        // Don 't wait for MSG_DIE to make it's way through root's queue.
                        mRoots.get( index ).doDie();
 } else {
                        throw new IllegalStateException( "View " + view  
                                + " has already been added to the window manager." );
 }
                    // The previous removeView() had not completed executing. Now it has.
 }
                // If this is a panel window, then find the window it is being
                // attached to   for future reference.
                if (wparams.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&
                        wparams.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
 final int   count = mViews.size () ;
 for ( int i = 0; i < count ; i++) {
                        if (mRoots.get(i).mWindow.asBinder() == wparams.token) {
                            panelParentView = mViews.get(i);
 }
 }
 }
 //Build ViewRootImpl through context
                root = new ViewRootImpl( view .getContext(), display);
 view .setLayoutParams(wparams);
 //mViews stores all View objects corresponding to Window
                mViews.add ( view );
 //mRoots stores the ViewRootImpl objects corresponding to all Windows
                mRoots.add (root);
 //mParams stores the WindowManager.LayoutParams objects corresponding to all Windows
                mParams.add (wparams);
 }
            // do this last because it fires off messages to start doing things
 try {
 //Call ViewRootImpl.setView() method to complete the addition of Window and update the interface
                root.setView( view , wparams, panelParentView);
            } catch (RuntimeException e) {
                // BadTokenException or InvalidDisplayException, clean up.
                synchronized (mLock) {
 final int   index = findViewLocked( view , false );
                    if ( index >= 0) {
                        removeViewLocked( index , true );
 }
 }
 throw e;
 }
 }
 }

There are three important member variables in this method:

• mViews stores all View objects corresponding to Windows;
• mRoots stores the ViewRootImpl objects corresponding to all Windows;
• mParams stores the WindowManager.LayoutParams objects corresponding to all Windows;
• Here we mention a class ViewRootImpl that we are not very familiar with. It is actually an encapsulation class that encapsulates the interaction between View and WindowManager. It is a bridge for communication between View and WindowManagerService.
• Finally, the ViewRootImpl.setView() method is called to complete the addition of Window and update the interface;

Let's look at the implementation of this method

 public final class ViewRootImpl implements ViewParent,
 View .AttachInfo.Callbacks, ThreadedRenderer.HardwareDrawCallbacks {
 public void setView( View   view , WindowManager.LayoutParams attrs, View panelParentView) {
            synchronized (this) {
                if (mView == null ) {
                    mView = view ;
 //Parameter verification and preprocessing
 ...
                    // Schedule the first layout -before- adding to the window
                    // manager, to make sure we do the relayout before receiving
                    // any other events from the system.
 //1. Call requestLayout() to complete the request for asynchronous drawing of the interface
                    requestLayout();
                    if ((mWindowAttributes.inputFeatures
                            & WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
                        mInputChannel = new InputChannel();
 }
                    mForceDecorViewVisibility = (mWindowAttributes.privateFlags
                            & PRIVATE_FLAG_FORCE_DECOR_VIEW_VISIBILITY) != 0;
 try {
                        mOrigWindowType = mWindowAttributes.type;
                        mAttachInfo.mRecomputeGlobalAttributes = true ;
                        collectViewAttributes();
 //2. Create WindowSession and request WindowManagerService through WindowSession to complete the process of adding Window
 //This is an IPC process.
                        res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                                getHostVisibility(), mDisplay.getDisplayId(),
                                mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                                mAttachInfo.mOutsets, mInputChannel);
                    } catch (RemoteException e) {
                        mAdded = false ;
                        mView = null ;
                        mAttachInfo.mRootView = null ;
                        mInputChannel = null ;
                        mFallbackEventHandler.setView( null );
                        unscheduleTraversals();
                        setAccessibilityFocus( null , null );
                        throw new RuntimeException( "Adding window failed" , e);
                    } finally {
                        if (restore) {
                            attrs.restore();
 }
 }
 ...
 }
 }
 }

• Call requestLayout() to complete the request for asynchronous drawing of the interface. requestLayout() will call scheduleTraversals() to complete the drawing of the View. The scheduleTraversals() method submits a TraversalRunnable to the work queue to execute the drawing of the View. The TraversalRunnable finally calls the performTraversals() method to complete the actual drawing operation. We are already familiar with the performTraversals() method;
• Create WindowSession and request WindowManagerService through WindowSession to complete the process of adding Window. This is an IPC process. WindowManagerService is the actual window manager. It is responsible for the creation, deletion and update of windows. It is also responsible for the stacking sorting and size calculation of windows.

Implementation of performTraversals() method:

• Get the Surface object for graphics drawing;
• Call the performMeasure() method to measure the size of each View in the view tree;
• Call the performLayout() method to calculate the position of each View in the view tree and perform layout;
• Call the performMeasure() method to draw each View in the view tree;

Cross-process communication between WindowManager and WindowManagerService. All services in Android are designed based on the C/S structure. The system layer provides services and the application layer uses services. The same is true for WindowManager.

The communication of WindowManagerService is done through WindowSession;

First, call ServiceManager.getService("window") to get WindowManagerService. This method returns an IBinder object. Then call IWindowManager.Stub.asInterface() to convert WindowManagerService into an IWindowManager object.

Then call the openSession() method to establish a communication session with WindowManagerService to facilitate subsequent cross-process communication. This communication session is the WindowSession we will use later;

Basically all Android system services are implemented in this way, which is an IPC process based on AIDL;

 public final class WindowManagerGlobal {
 public   static IWindowSession getWindowSession() {
        synchronized (WindowManagerGlobal.class) {
            if (sWindowSession == null ) {
 try {
                    InputMethodManager imm = InputMethodManager.getInstance();
 //Get the WindowManagerService object and convert it to IWindowManager type
                    IWindowManager windowManager = getWindowManagerService();
 //Call the openSession() method to establish a communication session with WindowManagerService to facilitate subsequent
 //Cross-process communication.
                    sWindowSession = windowManager.openSession(
                            new IWindowSessionCallback.Stub() {
                                @Override
 public void onAnimatorScaleChanged( float scale) {
                                    ValueAnimator.setDurationScale(scale);
                                }
                            },
                            imm.getClient(), imm.getInputContext());
                } catch (RemoteException e) {
                    throw e.rethrowFromSystemServer();
 }
 }
 return sWindowSession;
 }
 }
 public   static IWindowManager getWindowManagerService() {
        synchronized (WindowManagerGlobal.class) {
            if (sWindowManagerService == null ) {
 //Call ServiceManager.getService( "window" ) to get WindowManagerService. This method returns an IBinder object.
 //Then call the IWindowManager.Stub.asInterface() method to convert the WindowManagerService to an IWindowManager object
                sWindowManagerService = IWindowManager.Stub.asInterface(
                        ServiceManager.getService( "window" ));
 try {
                    if (sWindowManagerService != null ) {
                        ValueAnimator.setDurationScale(sWindowManagerService.getCurrentAnimatorScale());
 }
                } catch (RemoteException e) {
                    throw e.rethrowFromSystemServer();
 }
 }
 return sWindowManagerService;
 }
 }
 }

3. Window deletion process

The Window deletion process is also completed in WindowManagerGlobal

 public final class WindowManagerGlobal {
 public void removeView( View   view , boolean immediate) {
 if ( view == null ) {
            throw new IllegalArgumentException( "view must not be null" );
 }
        synchronized (mLock) {
 //1. Find the index of the View to be deleted
 int   index = findViewLocked( view , true );
 View curView = mRoots.get( index ).getView();
 //2. Call removeViewLocked() to complete the deletion of View , removeViewLocked() method
 //Continue to call ViewRootImpl.die() method to complete the deletion of View .
            removeViewLocked( index , immediate);
            if (curView == view ) {
 return ;
 }
            throw new IllegalStateException( "Calling with view " + view  
                    + " but the ViewAncestor is attached to " + curView);
 }
 }
    private void removeViewLocked( int   index , boolean immediate) {
        ViewRootImpl root = mRoots.get( index );
 View   view = root.getView();
 if ( view != null ) {
            InputMethodManager imm = InputMethodManager.getInstance();
            if (imm != null ) {
                imm.windowDismissed(mViews.get( index ).getWindowToken());
 }
 }
        boolean deferred = root.die(immediate);
 if ( view != null ) {
 view .assignParent( null );
 if (deferred) {
                mDyingViews.add ( view );
 }
 }
 }
 }

Let's take a look at the implementation of the ViewRootImpl.die() method;

 public final class ViewRootImpl implements ViewParent,
 View .AttachInfo.Callbacks, ThreadedRenderer.HardwareDrawCallbacks {
      boolean die(boolean immediate) {
            // Make sure we do execute immediately if we are in the middle of a traversal or the damage
            // done by dispatchDetachedFromWindow will cause havoc on   return .
 //Determine whether to perform asynchronous or synchronous deletion based on the immediate parameter
            if (immediate && !mIsInTraversal) {
 doDie();
 return   false ;
 }
            if (!mIsDrawing) {
                destroyHardwareRenderer();
 } else {
                Log.e(mTag, "Attempting to destroy the window while drawing!\n" +
 " window=" + this + ", title=" + mWindowAttributes.getTitle());
 }
 //If it is asynchronous deletion, sending a message MSG_DIE to delete the View will return directly
            mHandler.sendEmptyMessage(MSG_DIE);
 return   true ;
 }
 void doDie() {
 checkThread();
            if (LOCAL_LOGV) Log.v(mTag, "DIE in " + this + " of " + mSurface);
            synchronized (this) {
                if (mRemoved) {
 return ;
 }
                mRemoved = true ;
 if (mAdded) {
 //Call dispatchDetachedFromWindow() to complete the deletion of View
                    dispatchDetachedFromWindow();
 }
                if (mAdded && !mFirst) {
                    destroyHardwareRenderer();
                    if (mView != null ) {
 int viewVisibility = mView.getVisibility();
                        boolean viewVisibilityChanged = mViewVisibility != viewVisibility;
                        if (mWindowAttributesChanged || viewVisibilityChanged) {
                            // If layout params have been changed, first give them
                            // to the window manager to make sure it has the correct
                            // animation info.
                            try {
                                if ((relayoutWindow(mWindowAttributes, viewVisibility, false )
                                        & WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME) != 0) {
                                    mWindowSession.finishDrawing(mWindow);
                                }
                            } catch (RemoteException e) {
 }
 }
                        mSurface.release();
 }
 }
                mAdded = false ;
 }
 //Refresh the data and remove the related information of the currently removed View from the three lists we mentioned above: mRoots, mParms and mViews.
            WindowManagerGlobal.getInstance().doRemoveView(this);
 }
        void dispatchDetachedFromWindow() {
 //1. Call back the View 's dispatchDetachedFromWindow method to notify that the View has been removed from the Window
                if (mView != null && mView.mAttachInfo != null ) {
                    mAttachInfo.mTreeObserver.dispatchOnWindowAttachedChange( false );
                    mView.dispatchDetachedFromWindow();
 }
                mAccessibilityInteractionConnectionManager.ensureNoConnection();
                mAccessibilityManager.removeAccessibilityStateChangeListener(
                        mAccessibilityInteractionConnectionManager);
                mAccessibilityManager.removeHighTextContrastStateChangeListener(
                        mHighContrastTextManager);
                removeSendWindowContentChangedCallback();
                destroyHardwareRenderer();
                setAccessibilityFocus( null , null );
                mView.assignParent( null );
                mView = null ;
                mAttachInfo.mRootView = null ;
                mSurface.release();
                if (mInputQueueCallback != null && mInputQueue != null ) {
                    mInputQueueCallback.onInputQueueDestroyed(mInputQueue);
                    mInputQueue.dispose();
                    mInputQueueCallback = null ;
                    mInputQueue = null ;
 }
                if (mInputEventReceiver != null ) {
                    mInputEventReceiver.dispose();
                    mInputEventReceiver = null ;
 }
 //Call WindowSession.remove() method, which is also an IPC process, and finally calls
 //WindowManagerService.removeWindow() method to remove Window.
 try {
                    mWindowSession.remove(mWindow);
                } catch (RemoteException e) {
 }
                // Dispose the input channel after removing the window so the Window Manager
                // doesn't interpret the input channel being closed as an abnormal termination.
                if (mInputChannel != null ) {
                    mInputChannel.dispose();
                    mInputChannel = null ;
 }
                mDisplayManager.unregisterDisplayListener(mDisplayListener);
                unscheduleTraversals();
 }
 }

Window deletion process:

• Find the index of the View to be deleted (mViews.indexOf(view));
• Call removeViewLocked() to complete the deletion of View, and continue to call the removeViewLocked() method; ViewRootImpl.die() method to complete the deletion of View;
• The ViewRootImpl.die() method determines whether to perform asynchronous or synchronous deletion based on the immediate parameter. If it is asynchronous deletion, it will send a message MSG_DIE to delete the View and return directly. If it is synchronous deletion, it will call the doDie() method;
• The doDie() method calls dispatchDetachedFromWindow() to complete the deletion of View. In this method, the dispatchDetachedFromWindow method of View is first called back to notify that the View has been removed from the Window, and then the WindowSession.remove() method is called. This is also an IPC process. Finally, the WindowManagerService.removeWindow() method is called to remove the Window.

4. Window update process

 public final class WindowManagerGlobal {
 public void updateViewLayout( View   view , ViewGroup.LayoutParams params) {
 if ( view == null ) {
            throw new IllegalArgumentException( "view must not be null" );
 }
        if (!(params instanceof WindowManager.LayoutParams)) {
            throw new IllegalArgumentException( "Params must be WindowManager.LayoutParams" );
 }
        final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;
 //Update the View 's LayoutParams parameters
 view .setLayoutParams(wparams);
        synchronized (mLock) {
 //Find the index of Viewd and update the parameters in mParams
 int   index = findViewLocked( view , true );
            ViewRootImpl root = mRoots.get( index );
            mParams.remove( index );
            mParams.add ( index , wparams);
 //Call ViewRootImpl.setLayoutParams() to complete the layout.
            root.setLayoutParams(wparams, false );
 }
 }
 }
 Let's take a look at the implementation of the ViewRootImpl.setLayoutParams() method.
 public final class ViewRootImpl implements ViewParent,
   void setLayoutParams(WindowManager.LayoutParams attrs, boolean newView) {
           synchronized (this) {
 //Parameter preprocessing
 ...
 //If it is a new View , call requestLayout() to redraw
 if (newView) {
                   mSoftInputMode = attrs.softInputMode;
                   requestLayout();
 }
               // Don't lose the mode we last auto-computed.
               if ((attrs.softInputMode & WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST)
                       == WindowManager.LayoutParams.SOFT_INPUT_ADJUST_UNSPECIFIED) {
                   mWindowAttributes.softInputMode = (mWindowAttributes.softInputMode
                           & ~WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST)
                           | (oldSoftInputMode & WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST);
 }
               mWindowAttributesChanged = true ;
 //If it is not a new View , call requestLayout() to redraw
               scheduleTraversals();
 }
 }
 }

Window update process:

• Update the LayoutParams parameters of View, find the index of View, and update the parameters in mParams;
• Call ViewRootImpl.setLayoutParams() method to complete the re-layout work, and scheduleTraversals() will be called in the setLayoutParams() method;
• Decode and redraw, the subsequent process of scheduleTraversals() is the measure, layout and draw process of View;

Summarize

What is the essence of Window? In fact, Window is an abstract concept, that is, it does not actually exist, it exists in the form of View, each Window corresponds to a View and a ViewRootImpl, and Window and View are connected through ViewRootImpl. By extension, we can understand that WindowManagerService actually manages View rather than Window, which manages which View should be displayed on the top layer in the current state, and SurfaceFlinger drawing is also View;