Skytoby
Skytoby

Android刷新机制-View绘制原理

Posted on

Android刷新机制-View绘制原理

Posted on

一、概述

本文将从startActivity开始讲解Android屏幕刷新机制，前面的文章有分析过startActivity的启动过程，这里将重点分析WMS相关的过程，从而了解Android屏幕刷新机制原理。前面介绍的startActivity启动过程的流程图如下：

startActivity

二、View的绘制过程

从启动过程中的performLaunchActivity开始分析，View真正的绘制是在Activity中的onResume方法中。

2.1 AT.performLaunchActivity

[->ActivityThread.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
       ... 
       //创建Application
       Application app = r.packageInfo.makeApplication(false, mInstrumentation);
       ...
       //见2.2节
       activity.attach(appContext, this, getInstrumentation(), r.token,
                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
                        r.embeddedID, r.lastNonConfigurationInstances, config,
                        r.referrer, r.voiceInteractor, window, r.configCallback);
       ...
        if (r.isPersistable()) {
             mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
        } else {
             mInstrumentation.callActivityOnCreate(activity, r.state);
        }
        ...        
       return activity;
 }

2.2 Activity.attach

[->Activity.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
final void attach(Context context, ActivityThread aThread,
           Instrumentation instr, IBinder token, int ident,
           Application application, Intent intent, ActivityInfo info,
           CharSequence title, Activity parent, String id,
           NonConfigurationInstances lastNonConfigurationInstances,
           Configuration config, String referrer, IVoiceInteractor voiceInteractor,
           Window window, ActivityConfigCallback activityConfigCallback) {
       attachBaseContext(context);

       mFragments.attachHost(null /*parent*/);
       //创建PhoneWindow
       mWindow = new PhoneWindow(this, window, activityConfigCallback);
       mWindow.setWindowControllerCallback(this);
       mWindow.setCallback(this);
       mWindow.setOnWindowDismissedCallback(this);
       mWindow.getLayoutInflater().setPrivateFactory(this);
       if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
           mWindow.setSoftInputMode(info.softInputMode);
       }
       if (info.uiOptions != 0) {
           mWindow.setUiOptions(info.uiOptions);
       }
       mUiThread = Thread.currentThread();

       mMainThread = aThread;
       mInstrumentation = instr;
       mToken = token;
       mIdent = ident;
       mApplication = application;
       mIntent = intent;
       mReferrer = referrer;
       mComponent = intent.getComponent();
       mActivityInfo = info;
       mTitle = title;
       mParent = parent;
       mEmbeddedID = id;
       mLastNonConfigurationInstances = lastNonConfigurationInstances;
       if (voiceInteractor != null) {
           if (lastNonConfigurationInstances != null) {
               mVoiceInteractor = lastNonConfigurationInstances.voiceInteractor;
           } else {
               mVoiceInteractor = new VoiceInteractor(voiceInteractor, this, this,
                       Looper.myLooper());
           }
       }

       mWindow.setWindowManager(
               (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
               mToken, mComponent.flattenToString(),
               (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
       if (mParent != null) {
           mWindow.setContainer(mParent.getWindow());
       }
       mWindowManager = mWindow.getWindowManager();
       mCurrentConfig = config;

       mWindow.setColorMode(info.colorMode);

       setAutofillCompatibilityEnabled(application.isAutofillCompatibilityEnabled());
   }

这里比较重要的操作是创建PhoneWindow，PhoneWindow是window唯一的实现类。每一个Activity都有一个PhoneWindow对象，PhoneWindow对象中有一个DecorView实例，通过这个实例来进行View相关的操作。

window_decoreview

2.3 Activity.setContentView

[->Activity.java]

onCreate方法里面有一个setContentView

1
2
3
4
5
6
7
8
 public void setContentView(@LayoutRes int layoutResID) {
      getWindow().setContentView(layoutResID);
      initWindowDecorActionBar();
  }
 
public Window getWindow() {
      return mWindow;
  }

mWindow为上面创建的PhoneWindow对象，其类结构如下图所示

phonewindow

[->PhoneWindow.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public void setContentView(int layoutResID) {
       // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
       // decor, when theme attributes and the like are crystalized. Do not check the feature
       // before this happens.
       if (mContentParent == null) {
           installDecor();
       } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
           mContentParent.removeAllViews();
       }

       if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
           final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID,
                   getContext());
           transitionTo(newScene);
       } else {
           //加载布局
           mLayoutInflater.inflate(layoutResID, mContentParent);
       }
       mContentParent.requestApplyInsets();
       final Callback cb = getCallback();
       if (cb != null && !isDestroyed()) {
           cb.onContentChanged();
       }
       mContentParentExplicitlySet = true;
   }

2.3.1 installDecor

[->PhoneWindow.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
private void installDecor() {
       mForceDecorInstall = false;
       //如果mDecor没有初始化，则进行初始化
       if (mDecor == null) {
           mDecor = generateDecor(-1);
           mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
           mDecor.setIsRootNamespace(true);
           if (!mInvalidatePanelMenuPosted && mInvalidatePanelMenuFeatures != 0) {
               mDecor.postOnAnimation(mInvalidatePanelMenuRunnable);
           }
       } else {
           mDecor.setWindow(this);
       }
       //mContentParent为空则初始化
       if (mContentParent == null) {
           mContentParent = generateLayout(mDecor);

           // Set up decor part of UI to ignore fitsSystemWindows if appropriate.
           mDecor.makeOptionalFitsSystemWindows();

           final DecorContentParent decorContentParent = (DecorContentParent) mDecor.findViewById(
                   R.id.decor_content_parent);

           if (decorContentParent != null) {
               mDecorContentParent = decorContentParent;
               mDecorContentParent.setWindowCallback(getCallback());
               if (mDecorContentParent.getTitle() == null) {
                   mDecorContentParent.setWindowTitle(mTitle);
               }

               final int localFeatures = getLocalFeatures();
               for (int i = 0; i < FEATURE_MAX; i++) {
                   if ((localFeatures & (1 << i)) != 0) {
                       mDecorContentParent.initFeature(i);
                   }
               }

               mDecorContentParent.setUiOptions(mUiOptions);

               if ((mResourcesSetFlags & FLAG_RESOURCE_SET_ICON) != 0 ||
                       (mIconRes != 0 && !mDecorContentParent.hasIcon())) {
                   mDecorContentParent.setIcon(mIconRes);
               } else if ((mResourcesSetFlags & FLAG_RESOURCE_SET_ICON) == 0 &&
                       mIconRes == 0 && !mDecorContentParent.hasIcon()) {
                   mDecorContentParent.setIcon(
                           getContext().getPackageManager().getDefaultActivityIcon());
                   mResourcesSetFlags |= FLAG_RESOURCE_SET_ICON_FALLBACK;
               }
               if ((mResourcesSetFlags & FLAG_RESOURCE_SET_LOGO) != 0 ||
                       (mLogoRes != 0 && !mDecorContentParent.hasLogo())) {
                   mDecorContentParent.setLogo(mLogoRes);
               }

               // Invalidate if the panel menu hasn't been created before this.
               // Panel menu invalidation is deferred avoiding application onCreateOptionsMenu
               // being called in the middle of onCreate or similar.
               // A pending invalidation will typically be resolved before the posted message
               // would run normally in order to satisfy instance state restoration.
               PanelFeatureState st = getPanelState(FEATURE_OPTIONS_PANEL, false);
               if (!isDestroyed() && (st == null || st.menu == null) && !mIsStartingWindow) {
                   invalidatePanelMenu(FEATURE_ACTION_BAR);
               }
           } else {
               mTitleView = findViewById(R.id.title);
               if (mTitleView != null) {
                   if ((getLocalFeatures() & (1 << FEATURE_NO_TITLE)) != 0) {
                       final View titleContainer = findViewById(R.id.title_container);
                       if (titleContainer != null) {
                           titleContainer.setVisibility(View.GONE);
                       } else {
                           mTitleView.setVisibility(View.GONE);
                       }
                       mContentParent.setForeground(null);
                   } else {
                       mTitleView.setText(mTitle);
                   }
               }
           }

           if (mDecor.getBackground() == null && mBackgroundFallbackResource != 0) {
               mDecor.setBackgroundFallback(mBackgroundFallbackResource);
           }

           // Only inflate or create a new TransitionManager if the caller hasn't
           // already set a custom one.
           if (hasFeature(FEATURE_ACTIVITY_TRANSITIONS)) {
               if (mTransitionManager == null) {
                   final int transitionRes = getWindowStyle().getResourceId(
                           R.styleable.Window_windowContentTransitionManager,
                           0);
                   if (transitionRes != 0) {
                       final TransitionInflater inflater = TransitionInflater.from(getContext());
                       mTransitionManager = inflater.inflateTransitionManager(transitionRes,
                               mContentParent);
                   } else {
                       mTransitionManager = new TransitionManager();
                   }
               }

               mEnterTransition = getTransition(mEnterTransition, null,
                       R.styleable.Window_windowEnterTransition);
               mReturnTransition = getTransition(mReturnTransition, USE_DEFAULT_TRANSITION,
                       R.styleable.Window_windowReturnTransition);
               mExitTransition = getTransition(mExitTransition, null,
                       R.styleable.Window_windowExitTransition);
               mReenterTransition = getTransition(mReenterTransition, USE_DEFAULT_TRANSITION,
                       R.styleable.Window_windowReenterTransition);
               mSharedElementEnterTransition = getTransition(mSharedElementEnterTransition, null,
                       R.styleable.Window_windowSharedElementEnterTransition);
               mSharedElementReturnTransition = getTransition(mSharedElementReturnTransition,
                       USE_DEFAULT_TRANSITION,
                       R.styleable.Window_windowSharedElementReturnTransition);
               mSharedElementExitTransition = getTransition(mSharedElementExitTransition, null,
                       R.styleable.Window_windowSharedElementExitTransition);
               mSharedElementReenterTransition = getTransition(mSharedElementReenterTransition,
                       USE_DEFAULT_TRANSITION,
                       R.styleable.Window_windowSharedElementReenterTransition);
               if (mAllowEnterTransitionOverlap == null) {
                   mAllowEnterTransitionOverlap = getWindowStyle().getBoolean(
                           R.styleable.Window_windowAllowEnterTransitionOverlap, true);
               }
               if (mAllowReturnTransitionOverlap == null) {
                   mAllowReturnTransitionOverlap = getWindowStyle().getBoolean(
                           R.styleable.Window_windowAllowReturnTransitionOverlap, true);
               }
               if (mBackgroundFadeDurationMillis < 0) {
                   mBackgroundFadeDurationMillis = getWindowStyle().getInteger(
                           R.styleable.Window_windowTransitionBackgroundFadeDuration,
                           DEFAULT_BACKGROUND_FADE_DURATION_MS);
               }
               if (mSharedElementsUseOverlay == null) {
                   mSharedElementsUseOverlay = getWindowStyle().getBoolean(
                           R.styleable.Window_windowSharedElementsUseOverlay, true);
               }
           }
       }
   }

2.3.2 DecorView创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
protected DecorView generateDecor(int featureId) {
      // System process doesn't have application context and in that case we need to directly use
      // the context we have. Otherwise we want the application context, so we don't cling to the
      // activity.
      Context context;
      if (mUseDecorContext) {
          Context applicationContext = getContext().getApplicationContext();
          if (applicationContext == null) {
              context = getContext();
          } else {
              context = new DecorContext(applicationContext, getContext());
              if (mTheme != -1) {
                  context.setTheme(mTheme);
              }
          }
      } else {
          context = getContext();
      }
      return new DecorView(context, featureId, this, getAttributes());
  }

DecorView继承于FrameLayout，通过setContentView将Activity中的布局view添加DecorView中

2.3.3 generateLayout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
protected ViewGroup generateLayout(DecorView decor) {
        // Apply data from current theme.

        TypedArray a = getWindowStyle();

        if (false) {
            System.out.println("From style:");
            String s = "Attrs:";
            for (int i = 0; i < R.styleable.Window.length; i++) {
                s = s + " " + Integer.toHexString(R.styleable.Window[i]) + "="
                        + a.getString(i);
            }
            System.out.println(s);
        }

        mIsFloating = a.getBoolean(R.styleable.Window_windowIsFloating, false);
        int flagsToUpdate = (FLAG_LAYOUT_IN_SCREEN|FLAG_LAYOUT_INSET_DECOR)
                & (~getForcedWindowFlags());
        if (mIsFloating) {
            setLayout(WRAP_CONTENT, WRAP_CONTENT);
            setFlags(0, flagsToUpdate);
        } else {
            setFlags(FLAG_LAYOUT_IN_SCREEN|FLAG_LAYOUT_INSET_DECOR, flagsToUpdate);
        }

       ......

        if (params.windowAnimations == 0) {
            params.windowAnimations = a.getResourceId(
                    R.styleable.Window_windowAnimationStyle, 0);
        }

        // The rest are only done if this window is not embedded; otherwise,
        // the values are inherited from our container.
        if (getContainer() == null) {
            if (mBackgroundDrawable == null) {
                if (mBackgroundResource == 0) {
                    mBackgroundResource = a.getResourceId(
                            R.styleable.Window_windowBackground, 0);
                }
                if (mFrameResource == 0) {
                    mFrameResource = a.getResourceId(R.styleable.Window_windowFrame, 0);
                }
                mBackgroundFallbackResource = a.getResourceId(
                        R.styleable.Window_windowBackgroundFallback, 0);
                if (false) {
                    System.out.println("Background: "
                            + Integer.toHexString(mBackgroundResource) + " Frame: "
                            + Integer.toHexString(mFrameResource));
                }
            }
            if (mLoadElevation) {
                mElevation = a.getDimension(R.styleable.Window_windowElevation, 0);
            }
            mClipToOutline = a.getBoolean(R.styleable.Window_windowClipToOutline, false);
            mTextColor = a.getColor(R.styleable.Window_textColor, Color.TRANSPARENT);
        }

        // Inflate the window decor.

        int layoutResource;
        int features = getLocalFeatures();
        // System.out.println("Features: 0x" + Integer.toHexString(features));
        if ((features & (1 << FEATURE_SWIPE_TO_DISMISS)) != 0) {
            layoutResource = R.layout.screen_swipe_dismiss;
            setCloseOnSwipeEnabled(true);
        } else if ((features & ((1 << FEATURE_LEFT_ICON) | (1 << FEATURE_RIGHT_ICON))) != 0) {
            if (mIsFloating) {
                TypedValue res = new TypedValue();
                getContext().getTheme().resolveAttribute(
                        R.attr.dialogTitleIconsDecorLayout, res, true);
                layoutResource = res.resourceId;
            } else {
                layoutResource = R.layout.screen_title_icons;
            }
            // XXX Remove this once action bar supports these features.
            removeFeature(FEATURE_ACTION_BAR);
            // System.out.println("Title Icons!");
        } else if ((features & ((1 << FEATURE_PROGRESS) | (1 << FEATURE_INDETERMINATE_PROGRESS))) != 0
                && (features & (1 << FEATURE_ACTION_BAR)) == 0) {
            // Special case for a window with only a progress bar (and title).
            // XXX Need to have a no-title version of embedded windows.
            layoutResource = R.layout.screen_progress;
            // System.out.println("Progress!");
        } else if ((features & (1 << FEATURE_CUSTOM_TITLE)) != 0) {
            // Special case for a window with a custom title.
            // If the window is floating, we need a dialog layout
            if (mIsFloating) {
                TypedValue res = new TypedValue();
                getContext().getTheme().resolveAttribute(
                        R.attr.dialogCustomTitleDecorLayout, res, true);
                layoutResource = res.resourceId;
            } else {
                layoutResource = R.layout.screen_custom_title;
            }
            // XXX Remove this once action bar supports these features.
            removeFeature(FEATURE_ACTION_BAR);
        } else if ((features & (1 << FEATURE_NO_TITLE)) == 0) {
            // If no other features and not embedded, only need a title.
            // If the window is floating, we need a dialog layout
            if (mIsFloating) {
                TypedValue res = new TypedValue();
                getContext().getTheme().resolveAttribute(
                        R.attr.dialogTitleDecorLayout, res, true);
                layoutResource = res.resourceId;
            } else if ((features & (1 << FEATURE_ACTION_BAR)) != 0) {
                layoutResource = a.getResourceId(
                        R.styleable.Window_windowActionBarFullscreenDecorLayout,
                        R.layout.screen_action_bar);
            } else {
                layoutResource = R.layout.screen_title;
            }
            // System.out.println("Title!");
        } else if ((features & (1 << FEATURE_ACTION_MODE_OVERLAY)) != 0) {
            layoutResource = R.layout.screen_simple_overlay_action_mode;
        } else {
            // Embedded, so no decoration is needed.
            layoutResource = R.layout.screen_simple;
            // System.out.println("Simple!");
        }

        mDecor.startChanging();
        mDecor.onResourcesLoaded(mLayoutInflater, layoutResource);
        //找到contentview ID
        ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);
        if (contentParent == null) {
            throw new RuntimeException("Window couldn't find content container view");
        }

        if ((features & (1 << FEATURE_INDETERMINATE_PROGRESS)) != 0) {
            ProgressBar progress = getCircularProgressBar(false);
            if (progress != null) {
                progress.setIndeterminate(true);
            }
        }

        if ((features & (1 << FEATURE_SWIPE_TO_DISMISS)) != 0) {
            registerSwipeCallbacks(contentParent);
        }

        // Remaining setup -- of background and title -- that only applies
        // to top-level windows.
        //设置背景和title
        if (getContainer() == null) {
            final Drawable background;
            if (mBackgroundResource != 0) {
                background = getContext().getDrawable(mBackgroundResource);
            } else {
                background = mBackgroundDrawable;
            }
            mDecor.setWindowBackground(background);

            final Drawable frame;
            if (mFrameResource != 0) {
                frame = getContext().getDrawable(mFrameResource);
            } else {
                frame = null;
            }
            mDecor.setWindowFrame(frame);

            mDecor.setElevation(mElevation);
            mDecor.setClipToOutline(mClipToOutline);

            if (mTitle != null) {
                setTitle(mTitle);
            }

            if (mTitleColor == 0) {
                mTitleColor = mTextColor;
            }
            setTitleColor(mTitleColor);
        }

        mDecor.finishChanging();

        return contentParent;
    }

contentParent通过findviewById(com.android.internal.R.id.content)得到，后面通过mLayoutInflater.inflate(layoutResID, mContentParent)加载setContentView中的布局文件。

2.4 AT.handleResumeActivity

[->ActivityThread.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
          String reason) {
      // If we are getting ready to gc after going to the background, well
      // we are back active so skip it.
      unscheduleGcIdler();
      mSomeActivitiesChanged = true;

      // TODO Push resumeArgs into the activity for consideration
      //调用Activity的onResume方法
      final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
      if (r == null) {
          // We didn't actually resume the activity, so skipping any follow-up actions.
          return;
      }

      final Activity a = r.activity;

      if (localLOGV) {
          Slog.v(TAG, "Resume " + r + " started activity: " + a.mStartedActivity
                  + ", hideForNow: " + r.hideForNow + ", finished: " + a.mFinished);
      }

      final int forwardBit = isForward
              ? WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;

      // If the window hasn't yet been added to the window manager,
      // and this guy didn't finish itself or start another activity,
      // then go ahead and add the window.
      boolean willBeVisible = !a.mStartedActivity;
      if (!willBeVisible) {
          try {
              willBeVisible = ActivityManager.getService().willActivityBeVisible(
                      a.getActivityToken());
          } catch (RemoteException e) {
              throw e.rethrowFromSystemServer();
          }
      }
      if (r.window == null && !a.mFinished && willBeVisible) {
          r.window = r.activity.getWindow();
          View decor = r.window.getDecorView();
          decor.setVisibility(View.INVISIBLE);
          ViewManager wm = a.getWindowManager();
          WindowManager.LayoutParams l = r.window.getAttributes();
          a.mDecor = decor;
          l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
          l.softInputMode |= forwardBit;
          if (r.mPreserveWindow) {
              a.mWindowAdded = true;
              r.mPreserveWindow = false;
              // Normally the ViewRoot sets up callbacks with the Activity
              // in addView->ViewRootImpl#setView. If we are instead reusing
              // the decor view we have to notify the view root that the
              // callbacks may have changed.
              ViewRootImpl impl = decor.getViewRootImpl();
              if (impl != null) {
                  impl.notifyChildRebuilt();
              }
          }
          if (a.mVisibleFromClient) {
              if (!a.mWindowAdded) {
                  a.mWindowAdded = true;
                  wm.addView(decor, l);
              } else {
                  // The activity will get a callback for this {@link LayoutParams} change
                  // earlier. However, at that time the decor will not be set (this is set
                  // in this method), so no action will be taken. This call ensures the
                  // callback occurs with the decor set.
                  a.onWindowAttributesChanged(l);
              }
          }

          // If the window has already been added, but during resume
          // we started another activity, then don't yet make the
          // window visible.
      } else if (!willBeVisible) {
          if (localLOGV) Slog.v(TAG, "Launch " + r + " mStartedActivity set");
          r.hideForNow = true;
      }

      // Get rid of anything left hanging around.
      cleanUpPendingRemoveWindows(r, false /* force */);

      // The window is now visible if it has been added, we are not
      // simply finishing, and we are not starting another activity.
      // 窗口开始设置可见
      if (!r.activity.mFinished && willBeVisible && r.activity.mDecor != null && !r.hideForNow) {
          if (r.newConfig != null) {
              performConfigurationChangedForActivity(r, r.newConfig);
              if (DEBUG_CONFIGURATION) {
                  Slog.v(TAG, "Resuming activity " + r.activityInfo.name + " with newConfig "
                          + r.activity.mCurrentConfig);
              }
              r.newConfig = null;
          }
          if (localLOGV) Slog.v(TAG, "Resuming " + r + " with isForward=" + isForward);
          WindowManager.LayoutParams l = r.window.getAttributes();
          if ((l.softInputMode
                  & WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION)
                  != forwardBit) {
              l.softInputMode = (l.softInputMode
                      & (~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION))
                      | forwardBit;
              if (r.activity.mVisibleFromClient) {
                  ViewManager wm = a.getWindowManager();
                  View decor = r.window.getDecorView();
                  wm.updateViewLayout(decor, l);
              }
          }

          r.activity.mVisibleFromServer = true;
          mNumVisibleActivities++;
          if (r.activity.mVisibleFromClient) {
              //见2.5节
              r.activity.makeVisible();
          }
      }

      r.nextIdle = mNewActivities;
      mNewActivities = r;
      if (localLOGV) Slog.v(TAG, "Scheduling idle handler for " + r);
      Looper.myQueue().addIdleHandler(new Idler());
  }

2.5 Activity.makeVisible

[->Activity.java]

1
2
3
4
5
6
7
8
void makeVisible() {
      if (!mWindowAdded) {
          ViewManager wm = getWindowManager();
          wm.addView(mDecor, getWindow().getAttributes());
          mWindowAdded = true;
      }
      mDecor.setVisibility(View.VISIBLE);
 }

在 Activity.attach方法中进行的初始化

1
2
mWindow = new PhoneWindow(this, window, activityConfigCallback);
mWindowManager = mWindow.getWindowManager();

mWindowManager 在Window中初始化

1
mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this);

2.6 WMI.addView

[->WindowManagerImpl.java]

1
2
3
4
5
6
7
private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();
@Override
public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
       applyDefaultToken(params);
       //添加view
       mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
}

2.7 WMG.addView

[->WindowManagerGlobal.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
public void addView(View view, ViewGroup.LayoutParams params,
            Display display, Window parentWindow) {
        if (view == null) {
            throw new IllegalArgumentException("view must not be null");
        }
        if (display == null) {
            throw new IllegalArgumentException("display must not be null");
        }
        if (!(params instanceof WindowManager.LayoutParams)) {
            throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
        }

        final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
        if (parentWindow != null) {
            parentWindow.adjustLayoutParamsForSubWindow(wparams);
        } else {
            // If there's no parent, then hardware acceleration for this view is
            // set from the application's hardware acceleration setting.
            final Context context = view.getContext();
            if (context != null
                    && (context.getApplicationInfo().flags
                            & ApplicationInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
                wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
            }
        }

        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);
                    }
                }
            }
            
            root = new ViewRootImpl(view.getContext(), display);

            view.setLayoutParams(wparams);

            mViews.add(view);
            mRoots.add(root);
            mParams.add(wparams);

            // do this last because it fires off messages to start doing things
            try {
                //见2.8节
                root.setView(view, wparams, panelParentView);
            } catch (RuntimeException e) {
                // BadTokenException or InvalidDisplayException, clean up.
                if (index >= 0) {
                    removeViewLocked(index, true);
                }
                throw e;
            }
        }
    }

WindowManagerGlobal是WindowManagerImpl中的成员变量，其和ViewRootImpl，WindowSession关系图如下，WindowManager和WindowManagerService是通过Session进行通信的。具体可参考WMS启动分析

2.8 VRI.setView

[->ViewRootImpl.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
        synchronized (this) {
            if (mView == null) {
                mView = view;

                mAttachInfo.mDisplayState = mDisplay.getState();
                mDisplayManager.registerDisplayListener(mDisplayListener, mHandler);

                mViewLayoutDirectionInitial = mView.getRawLayoutDirection();
                mFallbackEventHandler.setView(view);
                mWindowAttributes.copyFrom(attrs);
                if (mWindowAttributes.packageName == null) {
                    mWindowAttributes.packageName = mBasePackageName;
                }
                attrs = mWindowAttributes;
                setTag();

                if (DEBUG_KEEP_SCREEN_ON && (mClientWindowLayoutFlags
                        & WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) != 0
                        && (attrs.flags&WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) == 0) {
                    Slog.d(mTag, "setView: FLAG_KEEP_SCREEN_ON changed from true to false!");
                }
                // Keep track of the actual window flags supplied by the client.
                mClientWindowLayoutFlags = attrs.flags;

                setAccessibilityFocus(null, null);

                if (view instanceof RootViewSurfaceTaker) {
                    mSurfaceHolderCallback =
                            ((RootViewSurfaceTaker)view).willYouTakeTheSurface();
                    if (mSurfaceHolderCallback != null) {
                        mSurfaceHolder = new TakenSurfaceHolder();
                        mSurfaceHolder.setFormat(PixelFormat.UNKNOWN);
                        mSurfaceHolder.addCallback(mSurfaceHolderCallback);
                    }
                }

                // Compute surface insets required to draw at specified Z value.
                // TODO: Use real shadow insets for a constant max Z.
                if (!attrs.hasManualSurfaceInsets) {
                    attrs.setSurfaceInsets(view, false /*manual*/, true /*preservePrevious*/);
                }

                CompatibilityInfo compatibilityInfo =
                        mDisplay.getDisplayAdjustments().getCompatibilityInfo();
                mTranslator = compatibilityInfo.getTranslator();

                // If the application owns the surface, don't enable hardware acceleration
                if (mSurfaceHolder == null) {
                    // While this is supposed to enable only, it can effectively disable
                    // the acceleration too.
                    enableHardwareAcceleration(attrs);
                    final boolean useMTRenderer = MT_RENDERER_AVAILABLE
                            && mAttachInfo.mThreadedRenderer != null;
                    if (mUseMTRenderer != useMTRenderer) {
                        // Shouldn't be resizing, as it's done only in window setup,
                        // but end just in case.
                        endDragResizing();
                        mUseMTRenderer = useMTRenderer;
                    }
                }

                boolean restore = false;
                if (mTranslator != null) {
                    mSurface.setCompatibilityTranslator(mTranslator);
                    restore = true;
                    attrs.backup();
                    mTranslator.translateWindowLayout(attrs);
                }
                if (DEBUG_LAYOUT) Log.d(mTag, "WindowLayout in setView:" + attrs);

                if (!compatibilityInfo.supportsScreen()) {
                    attrs.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
                    mLastInCompatMode = true;
                }

                mSoftInputMode = attrs.softInputMode;
                mWindowAttributesChanged = true;
                mWindowAttributesChangesFlag = WindowManager.LayoutParams.EVERYTHING_CHANGED;
                mAttachInfo.mRootView = view;
                mAttachInfo.mScalingRequired = mTranslator != null;
                mAttachInfo.mApplicationScale =
                        mTranslator == null ? 1.0f : mTranslator.applicationScale;
                if (panelParentView != null) {
                    mAttachInfo.mPanelParentWindowToken
                            = panelParentView.getApplicationWindowToken();
                }
                mAdded = true;
                int res; /* = WindowManagerImpl.ADD_OKAY; */

                // 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.
                //调用该方法进行view的绘制
                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();
                    //通过WindowSession和WindowManagerService进行通信，添加到显示
                    res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                            getHostVisibility(), mDisplay.getDisplayId(), mWinFrame,
                            mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                            mAttachInfo.mOutsets, mAttachInfo.mDisplayCutout, 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();
                    }
                }

                if (mTranslator != null) {
                    mTranslator.translateRectInScreenToAppWindow(mAttachInfo.mContentInsets);
                }
                mPendingOverscanInsets.set(0, 0, 0, 0);
                mPendingContentInsets.set(mAttachInfo.mContentInsets);
                mPendingStableInsets.set(mAttachInfo.mStableInsets);
                mPendingDisplayCutout.set(mAttachInfo.mDisplayCutout);
                mPendingVisibleInsets.set(0, 0, 0, 0);
                mAttachInfo.mAlwaysConsumeNavBar =
                        (res & WindowManagerGlobal.ADD_FLAG_ALWAYS_CONSUME_NAV_BAR) != 0;
                mPendingAlwaysConsumeNavBar = mAttachInfo.mAlwaysConsumeNavBar;
                if (DEBUG_LAYOUT) Log.v(mTag, "Added window " + mWindow);
                //根据结果进行相应的处理
                if (res < WindowManagerGlobal.ADD_OKAY) {
                    mAttachInfo.mRootView = null;
                    mAdded = false;
                    mFallbackEventHandler.setView(null);
                    unscheduleTraversals();
                    setAccessibilityFocus(null, null);
                    switch (res) {
                        case WindowManagerGlobal.ADD_BAD_APP_TOKEN:
                        case WindowManagerGlobal.ADD_BAD_SUBWINDOW_TOKEN:
                            throw new WindowManager.BadTokenException(
                                    "Unable to add window -- token " + attrs.token
                                    + " is not valid; is your activity running?");
                        case WindowManagerGlobal.ADD_NOT_APP_TOKEN:
                            throw new WindowManager.BadTokenException(
                                    "Unable to add window -- token " + attrs.token
                                    + " is not for an application");
                        case WindowManagerGlobal.ADD_APP_EXITING:
                            throw new WindowManager.BadTokenException(
                                    "Unable to add window -- app for token " + attrs.token
                                    + " is exiting");
                        case WindowManagerGlobal.ADD_DUPLICATE_ADD:
                            throw new WindowManager.BadTokenException(
                                    "Unable to add window -- window " + mWindow
                                    + " has already been added");
                        case WindowManagerGlobal.ADD_STARTING_NOT_NEEDED:
                            // Silently ignore -- we would have just removed it
                            // right away, anyway.
                            return;
                        case WindowManagerGlobal.ADD_MULTIPLE_SINGLETON:
                            throw new WindowManager.BadTokenException("Unable to add window "
                                    + mWindow + " -- another window of type "
                                    + mWindowAttributes.type + " already exists");
                        case WindowManagerGlobal.ADD_PERMISSION_DENIED:
                            throw new WindowManager.BadTokenException("Unable to add window "
                                    + mWindow + " -- permission denied for window type "
                                    + mWindowAttributes.type);
                        case WindowManagerGlobal.ADD_INVALID_DISPLAY:
                            throw new WindowManager.InvalidDisplayException("Unable to add window "
                                    + mWindow + " -- the specified display can not be found");
                        case WindowManagerGlobal.ADD_INVALID_TYPE:
                            throw new WindowManager.InvalidDisplayException("Unable to add window "
                                    + mWindow + " -- the specified window type "
                                    + mWindowAttributes.type + " is not valid");
                    }
                    throw new RuntimeException(
                            "Unable to add window -- unknown error code " + res);
                }

                if (view instanceof RootViewSurfaceTaker) {
                    mInputQueueCallback =
                        ((RootViewSurfaceTaker)view).willYouTakeTheInputQueue();
                }
                if (mInputChannel != null) {
                    if (mInputQueueCallback != null) {
                        mInputQueue = new InputQueue();
                        mInputQueueCallback.onInputQueueCreated(mInputQueue);
                    }
                    mInputEventReceiver = new WindowInputEventReceiver(mInputChannel,
                            Looper.myLooper());
                }

                view.assignParent(this);
                mAddedTouchMode = (res & WindowManagerGlobal.ADD_FLAG_IN_TOUCH_MODE) != 0;
                mAppVisible = (res & WindowManagerGlobal.ADD_FLAG_APP_VISIBLE) != 0;

                if (mAccessibilityManager.isEnabled()) {
                    mAccessibilityInteractionConnectionManager.ensureConnection();
                }

                if (view.getImportantForAccessibility() == View.IMPORTANT_FOR_ACCESSIBILITY_AUTO) {
                    view.setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_YES);
                }

                // Set up the input pipeline.
                CharSequence counterSuffix = attrs.getTitle();
                mSyntheticInputStage = new SyntheticInputStage();
                InputStage viewPostImeStage = new ViewPostImeInputStage(mSyntheticInputStage);
                InputStage nativePostImeStage = new NativePostImeInputStage(viewPostImeStage,
                        "aq:native-post-ime:" + counterSuffix);
                InputStage earlyPostImeStage = new EarlyPostImeInputStage(nativePostImeStage);
                InputStage imeStage = new ImeInputStage(earlyPostImeStage,
                        "aq:ime:" + counterSuffix);
                InputStage viewPreImeStage = new ViewPreImeInputStage(imeStage);
                InputStage nativePreImeStage = new NativePreImeInputStage(viewPreImeStage,
                        "aq:native-pre-ime:" + counterSuffix);

                mFirstInputStage = nativePreImeStage;
                mFirstPostImeInputStage = earlyPostImeStage;
                mPendingInputEventQueueLengthCounterName = "aq:pending:" + counterSuffix;
            }
        }
    }

2.9 VRI.requestLayout

[->ViewRootImpl.java]

1
2
3
4
5
6
7
8
@Override
 public void requestLayout() {
     if (!mHandlingLayoutInLayoutRequest) {
         checkThread();
         mLayoutRequested = true;
         scheduleTraversals();
     }
 }

2.9.1 VRI.scheduleTraversals

[->ViewRootImpl.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void scheduleTraversals() {
       if (!mTraversalScheduled) {
           mTraversalScheduled = true;
           mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
           //这里向Choreographer发送消息
           mChoreographer.postCallback(
                   Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
           if (!mUnbufferedInputDispatch) {
               scheduleConsumeBatchedInput();
           }
           notifyRendererOfFramePending();
           pokeDrawLockIfNeeded();
       }
   }

mTraversalRunnable实现如下：

1
2
3
4
5
6
final class TraversalRunnable implements Runnable {
       @Override
       public void run() {
           doTraversal();
       }
   }

这里向Choreographer发送一个Runnable消息，Choreographer主要作用是获取Vsync同步信号并控制应用主线程完成图像绘制的类。

2.9.2 Choreographer.postCallback

[->Choreographer.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public void postCallback(int callbackType, Runnable action, Object token) {
       postCallbackDelayed(callbackType, action, token, 0);
}

 private void postCallbackDelayedInternal(int callbackType,
           Object action, Object token, long delayMillis) {
      
       synchronized (mLock) {
           final long now = SystemClock.uptimeMillis();
           final long dueTime = now + delayMillis;
           //将action Runnable添加到mCallbackQueues队列
           mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);
            
           if (dueTime <= now) { //没有延迟
               scheduleFrameLocked(now);
           } else {
               //如果有延迟则发送并行消息
               Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
               msg.arg1 = callbackType;
               msg.setAsynchronous(true);
               mHandler.sendMessageAtTime(msg, dueTime);
           }
       }
   }

最后延迟和非延迟都会执行到scheduleFrameLocked方法

2.9.2.1 scheduleFrameLocked

[->Choreographer.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
private void scheduleFrameLocked(long now) {
        if (!mFrameScheduled) {
            mFrameScheduled = true;
            if (USE_VSYNC) {
                if (DEBUG_FRAMES) {
                    Log.d(TAG, "Scheduling next frame on vsync.");
                }

                // If running on the Looper thread, then schedule the vsync immediately,
                // otherwise post a message to schedule the vsync from the UI thread
                // as soon as possible.
                //如果是在同一线程
                if (isRunningOnLooperThreadLocked()) {
                    scheduleVsyncLocked();
                } else {
                    Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);
                    msg.setAsynchronous(true);
                    //插到最前面
                    mHandler.sendMessageAtFrontOfQueue(msg);
                }
            } else {
                final long nextFrameTime = Math.max(
                        mLastFrameTimeNanos / TimeUtils.NANOS_PER_MS + sFrameDelay, now);
                if (DEBUG_FRAMES) {
                    Log.d(TAG, "Scheduling next frame in " + (nextFrameTime - now) + " ms.");
                }
                Message msg = mHandler.obtainMessage(MSG_DO_FRAME);
                msg.setAsynchronous(true);
                mHandler.sendMessageAtTime(msg, nextFrameTime);
            }
        }
    }

USE_VSYNC默认是true,当前线程和Choreographer绑定的线程一致，调用scheduleVsyncLocked，否则通过mHandler发送消息，在Choreographer线程中处理。这两个分支最后都会执行scheduleVsyncLocked方法。

2.9.2.2 scheduleVsyncLocked

[->Choreographer.java]

1
2
3
private void scheduleVsyncLocked() {
    mDisplayEventReceiver.scheduleVsync();
}
2.9.2.3 scheduleVsync

[->DisplayEventReceiver.java]

1
2
3
4
5
6
7
8
public void scheduleVsync() {
       if (mReceiverPtr == 0) {
           Log.w(TAG, "Attempted to schedule a vertical sync pulse but the display event "
                   + "receiver has already been disposed.");
       } else {
           nativeScheduleVsync(mReceiverPtr);
       }
   }

这里调用到了native方法，这里主要是向底层注册Vsync信号，当底层有Vsync信号来时，会调用onVsync方法。后面文章会详细介绍Choreographer这里相关的操作。

2.9.2.4 FrameDisplayEventReceiver

[->FrameDisplayEventReceiver.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
private final class FrameDisplayEventReceiver extends DisplayEventReceiver
           implements Runnable {
       private boolean mHavePendingVsync;
       private long mTimestampNanos;
       private int mFrame;

       public FrameDisplayEventReceiver(Looper looper, int vsyncSource) {
           super(looper, vsyncSource);
       }

       @Override
       public void onVsync(long timestampNanos, int builtInDisplayId, int frame) {
           // Ignore vsync from secondary display.
           // This can be problematic because the call to scheduleVsync() is a one-shot.
           // We need to ensure that we will still receive the vsync from the primary
           // display which is the one we really care about.  Ideally we should schedule
           // vsync for a particular display.
           // At this time Surface Flinger won't send us vsyncs for secondary displays
           // but that could change in the future so let's log a message to help us remember
           // that we need to fix this.
           if (builtInDisplayId != SurfaceControl.BUILT_IN_DISPLAY_ID_MAIN) {
               Log.d(TAG, "Received vsync from secondary display, but we don't support "
                       + "this case yet.  Choreographer needs a way to explicitly request "
                       + "vsync for a specific display to ensure it doesn't lose track "
                       + "of its scheduled vsync.");
               scheduleVsync();
               return;
           }

           // Post the vsync event to the Handler.
           // The idea is to prevent incoming vsync events from completely starving
           // the message queue.  If there are no messages in the queue with timestamps
           // earlier than the frame time, then the vsync event will be processed immediately.
           // Otherwise, messages that predate the vsync event will be handled first.
           long now = System.nanoTime();
           if (timestampNanos > now) {
               Log.w(TAG, "Frame time is " + ((timestampNanos - now) * 0.000001f)
                       + " ms in the future!  Check that graphics HAL is generating vsync "
                       + "timestamps using the correct timebase.");
               timestampNanos = now;
           }

           if (mHavePendingVsync) {
               Log.w(TAG, "Already have a pending vsync event.  There should only be "
                       + "one at a time.");
           } else {
               mHavePendingVsync = true;
           }

           mTimestampNanos = timestampNanos;
           mFrame = frame;
           //发送该Runnable
           Message msg = Message.obtain(mHandler, this);
           msg.setAsynchronous(true);
           mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);
       }

       @Override
       public void run() {
           mHavePendingVsync = false;
           doFrame(mTimestampNanos, mFrame);
       }
   }

发送异步消息，最后会执行doFrame方法

2.9.2.5 doFrame

[->Choreographer.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
void doFrame(long frameTimeNanos, int frame) {
        final long startNanos;
        synchronized (mLock) {
            if (!mFrameScheduled) {
                return; // no work to do
            }

            if (DEBUG_JANK && mDebugPrintNextFrameTimeDelta) {
                mDebugPrintNextFrameTimeDelta = false;
                Log.d(TAG, "Frame time delta: "
                        + ((frameTimeNanos - mLastFrameTimeNanos) * 0.000001f) + " ms");
            }

            long intendedFrameTimeNanos = frameTimeNanos;
            startNanos = System.nanoTime();
            final long jitterNanos = startNanos - frameTimeNanos;
            //间隔时间大于1/60ms
            if (jitterNanos >= mFrameIntervalNanos) {
                final long skippedFrames = jitterNanos / mFrameIntervalNanos;
                if (skippedFrames >= SKIPPED_FRAME_WARNING_LIMIT) {
                    Log.i(TAG, "Skipped " + skippedFrames + " frames!  "
                            + "The application may be doing too much work on its main thread.");
                }
                final long lastFrameOffset = jitterNanos % mFrameIntervalNanos;
                if (DEBUG_JANK) {
                    Log.d(TAG, "Missed vsync by " + (jitterNanos * 0.000001f) + " ms "
                            + "which is more than the frame interval of "
                            + (mFrameIntervalNanos * 0.000001f) + " ms!  "
                            + "Skipping " + skippedFrames + " frames and setting frame "
                            + "time to " + (lastFrameOffset * 0.000001f) + " ms in the past.");
                }
                frameTimeNanos = startNanos - lastFrameOffset;
            }

            if (frameTimeNanos < mLastFrameTimeNanos) {
                if (DEBUG_JANK) {
                    Log.d(TAG, "Frame time appears to be going backwards.  May be due to a "
                            + "previously skipped frame.  Waiting for next vsync.");
                }
                scheduleVsyncLocked();
                return;
            }

            if (mFPSDivisor > 1) {
                long timeSinceVsync = frameTimeNanos - mLastFrameTimeNanos;
                if (timeSinceVsync < (mFrameIntervalNanos * mFPSDivisor) && timeSinceVsync > 0) {
                    scheduleVsyncLocked();
                    return;
                }
            }

            mFrameInfo.setVsync(intendedFrameTimeNanos, frameTimeNanos);
            mFrameScheduled = false;
            mLastFrameTimeNanos = frameTimeNanos;
        }

        try {
            Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Choreographer#doFrame");
            AnimationUtils.lockAnimationClock(frameTimeNanos / TimeUtils.NANOS_PER_MS);
            
            //这里开始执行四种类型的Callback
            mFrameInfo.markInputHandlingStart();
            doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos);

            mFrameInfo.markAnimationsStart();
            doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos);

            mFrameInfo.markPerformTraversalsStart();
            doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos);

            doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos);
        } finally {
            AnimationUtils.unlockAnimationClock();
            Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        }

        if (DEBUG_FRAMES) {
            final long endNanos = System.nanoTime();
            Log.d(TAG, "Frame " + frame + ": Finished, took "
                    + (endNanos - startNanos) * 0.000001f + " ms, latency "
                    + (startNanos - frameTimeNanos) * 0.000001f + " ms.");
        }
    }

这里主要是执行队列里面的任务，例如之前添加的mTraversalRunnable。

2.9.2.6 doCallbacks

[->Choreographer.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
void doCallbacks(int callbackType, long frameTimeNanos) {
       CallbackRecord callbacks;
       synchronized (mLock) {
           // We use "now" to determine when callbacks become due because it's possible
           // for earlier processing phases in a frame to post callbacks that should run
           // in a following phase, such as an input event that causes an animation to start.
           final long now = System.nanoTime();
           callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked(
                   now / TimeUtils.NANOS_PER_MS);
           if (callbacks == null) {
               return;
           }
           mCallbacksRunning = true;

           // Update the frame time if necessary when committing the frame.
           // We only update the frame time if we are more than 2 frames late reaching
           // the commit phase.  This ensures that the frame time which is observed by the
           // callbacks will always increase from one frame to the next and never repeat.
           // We never want the next frame's starting frame time to end up being less than
           // or equal to the previous frame's commit frame time.  Keep in mind that the
           // next frame has most likely already been scheduled by now so we play it
           // safe by ensuring the commit time is always at least one frame behind.
           if (callbackType == Choreographer.CALLBACK_COMMIT) {
               final long jitterNanos = now - frameTimeNanos;
               Trace.traceCounter(Trace.TRACE_TAG_VIEW, "jitterNanos", (int) jitterNanos);
               if (jitterNanos >= 2 * mFrameIntervalNanos) {
                   final long lastFrameOffset = jitterNanos % mFrameIntervalNanos
                           + mFrameIntervalNanos;
                   if (DEBUG_JANK) {
                       Log.d(TAG, "Commit callback delayed by " + (jitterNanos * 0.000001f)
                               + " ms which is more than twice the frame interval of "
                               + (mFrameIntervalNanos * 0.000001f) + " ms!  "
                               + "Setting frame time to " + (lastFrameOffset * 0.000001f)
                               + " ms in the past.");
                       mDebugPrintNextFrameTimeDelta = true;
                   }
                   frameTimeNanos = now - lastFrameOffset;
                   mLastFrameTimeNanos = frameTimeNanos;
               }
           }
       }
       try {
           Trace.traceBegin(Trace.TRACE_TAG_VIEW, CALLBACK_TRACE_TITLES[callbackType]);
           for (CallbackRecord c = callbacks; c != null; c = c.next) {
               if (DEBUG_FRAMES) {
                   Log.d(TAG, "RunCallback: type=" + callbackType
                           + ", action=" + c.action + ", token=" + c.token
                           + ", latencyMillis=" + (SystemClock.uptimeMillis() - c.dueTime));
               }
               //执行任务里面的run方法
               c.run(frameTimeNanos);
           }
       } finally {
           synchronized (mLock) {
               mCallbacksRunning = false;
               do {
                   final CallbackRecord next = callbacks.next;
                   recycleCallbackLocked(callbacks);
                   callbacks = next;
               } while (callbacks != null);
           }
           Trace.traceEnd(Trace.TRACE_TAG_VIEW);
       }
   }

2.9.3 VRI.doTraversal

[->ViewRootImpl.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void doTraversal() {
       if (mTraversalScheduled) {
           mTraversalScheduled = false;
           //去除屏障
           mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);

           if (mProfile) {
               Debug.startMethodTracing("ViewAncestor");
           }
           //见2.9.4节
           performTraversals();

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

2.9.4 VRI.performTraversals

[->ViewRootImpl.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
private void performTraversals() {
       // cache mView since it is used so much below...
       final View host = mView;

       if (DBG) {
           System.out.println("======================================");
           System.out.println("performTraversals");
           host.debug();
       }

       if (host == null || !mAdded)
           return;

       mIsInTraversal = true;
       mWillDrawSoon = true;
       boolean windowSizeMayChange = false;
       boolean newSurface = false;
       boolean surfaceChanged = false;
       WindowManager.LayoutParams lp = mWindowAttributes;

       int desiredWindowWidth;
       int desiredWindowHeight;

       final int viewVisibility = getHostVisibility();
       final boolean viewVisibilityChanged = !mFirst
               && (mViewVisibility != viewVisibility || mNewSurfaceNeeded
               // Also check for possible double visibility update, which will make current
               // viewVisibility value equal to mViewVisibility and we may miss it.
               || mAppVisibilityChanged);
       mAppVisibilityChanged = false;
       final boolean viewUserVisibilityChanged = !mFirst &&
               ((mViewVisibility == View.VISIBLE) != (viewVisibility == View.VISIBLE));

       WindowManager.LayoutParams params = null;
       if (mWindowAttributesChanged) {
           mWindowAttributesChanged = false;
           surfaceChanged = true;
           params = lp;
       }
       CompatibilityInfo compatibilityInfo =
               mDisplay.getDisplayAdjustments().getCompatibilityInfo();
       if (compatibilityInfo.supportsScreen() == mLastInCompatMode) {
           params = lp;
           mFullRedrawNeeded = true;
           mLayoutRequested = true;
           if (mLastInCompatMode) {
               params.privateFlags &= ~WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
               mLastInCompatMode = false;
           } else {
               params.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
               mLastInCompatMode = true;
           }
       }

       mWindowAttributesChangesFlag = 0;

       Rect frame = mWinFrame;
       if (mFirst) {
           mFullRedrawNeeded = true;
           mLayoutRequested = true;

           final Configuration config = mContext.getResources().getConfiguration();
           if (shouldUseDisplaySize(lp)) {
               // NOTE -- system code, won't try to do compat mode.
               Point size = new Point();
               mDisplay.getRealSize(size);
               desiredWindowWidth = size.x;
               desiredWindowHeight = size.y;
           } else {
               desiredWindowWidth = mWinFrame.width();
               desiredWindowHeight = mWinFrame.height();
           }

           // We used to use the following condition to choose 32 bits drawing caches:
           // PixelFormat.hasAlpha(lp.format) || lp.format == PixelFormat.RGBX_8888
           // However, windows are now always 32 bits by default, so choose 32 bits
           mAttachInfo.mUse32BitDrawingCache = true;
           mAttachInfo.mHasWindowFocus = false;
           mAttachInfo.mWindowVisibility = viewVisibility;
           mAttachInfo.mRecomputeGlobalAttributes = false;
           mLastConfigurationFromResources.setTo(config);
           mLastSystemUiVisibility = mAttachInfo.mSystemUiVisibility;
           // Set the layout direction if it has not been set before (inherit is the default)
           if (mViewLayoutDirectionInitial == View.LAYOUT_DIRECTION_INHERIT) {
               host.setLayoutDirection(config.getLayoutDirection());
           }
           host.dispatchAttachedToWindow(mAttachInfo, 0);
           mAttachInfo.mTreeObserver.dispatchOnWindowAttachedChange(true);
           dispatchApplyInsets(host);
       } else {
           desiredWindowWidth = frame.width();
           desiredWindowHeight = frame.height();
           if (desiredWindowWidth != mWidth || desiredWindowHeight != mHeight) {
               if (DEBUG_ORIENTATION) Log.v(mTag, "View " + host + " resized to: " + frame);
               mFullRedrawNeeded = true;
               mLayoutRequested = true;
               windowSizeMayChange = true;
           }
       }

       if (viewVisibilityChanged) {
           mAttachInfo.mWindowVisibility = viewVisibility;
           host.dispatchWindowVisibilityChanged(viewVisibility);
           if (viewUserVisibilityChanged) {
               host.dispatchVisibilityAggregated(viewVisibility == View.VISIBLE);
           }
           if (viewVisibility != View.VISIBLE || mNewSurfaceNeeded) {
               endDragResizing();
               destroyHardwareResources();
           }
           if (viewVisibility == View.GONE) {
               // After making a window gone, we will count it as being
               // shown for the first time the next time it gets focus.
               mHasHadWindowFocus = false;
           }
       }

       // Non-visible windows can't hold accessibility focus.
       if (mAttachInfo.mWindowVisibility != View.VISIBLE) {
           host.clearAccessibilityFocus();
       }

       // Execute enqueued actions on every traversal in case a detached view enqueued an action
       getRunQueue().executeActions(mAttachInfo.mHandler);

       boolean insetsChanged = false;

       boolean layoutRequested = mLayoutRequested && (!mStopped || mReportNextDraw);
       if (layoutRequested) {

           final Resources res = mView.getContext().getResources();

           if (mFirst) {
               // make sure touch mode code executes by setting cached value
               // to opposite of the added touch mode.
               mAttachInfo.mInTouchMode = !mAddedTouchMode;
               ensureTouchModeLocally(mAddedTouchMode);
           } else {
               if (!mPendingOverscanInsets.equals(mAttachInfo.mOverscanInsets)) {
                   insetsChanged = true;
               }
               if (!mPendingContentInsets.equals(mAttachInfo.mContentInsets)) {
                   insetsChanged = true;
               }
               if (!mPendingStableInsets.equals(mAttachInfo.mStableInsets)) {
                   insetsChanged = true;
               }
               if (!mPendingDisplayCutout.equals(mAttachInfo.mDisplayCutout)) {
                   insetsChanged = true;
               }
               if (!mPendingVisibleInsets.equals(mAttachInfo.mVisibleInsets)) {
                   mAttachInfo.mVisibleInsets.set(mPendingVisibleInsets);
                   if (DEBUG_LAYOUT) Log.v(mTag, "Visible insets changing to: "
                           + mAttachInfo.mVisibleInsets);
               }
               if (!mPendingOutsets.equals(mAttachInfo.mOutsets)) {
                   insetsChanged = true;
               }
               if (mPendingAlwaysConsumeNavBar != mAttachInfo.mAlwaysConsumeNavBar) {
                   insetsChanged = true;
               }
               if (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT
                       || lp.height == ViewGroup.LayoutParams.WRAP_CONTENT) {
                   windowSizeMayChange = true;

                   if (shouldUseDisplaySize(lp)) {
                       // NOTE -- system code, won't try to do compat mode.
                       Point size = new Point();
                       mDisplay.getRealSize(size);
                       desiredWindowWidth = size.x;
                       desiredWindowHeight = size.y;
                   } else {
                       Configuration config = res.getConfiguration();
                       desiredWindowWidth = dipToPx(config.screenWidthDp);
                       desiredWindowHeight = dipToPx(config.screenHeightDp);
                   }
               }
           }

           // Ask host how big it wants to be
           windowSizeMayChange |= measureHierarchy(host, lp, res,
                   desiredWindowWidth, desiredWindowHeight);
       }

       if (collectViewAttributes()) {
           params = lp;
       }
       if (mAttachInfo.mForceReportNewAttributes) {
           mAttachInfo.mForceReportNewAttributes = false;
           params = lp;
       }

       if (mFirst || mAttachInfo.mViewVisibilityChanged) {
           mAttachInfo.mViewVisibilityChanged = false;
           int resizeMode = mSoftInputMode &
                   WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST;
           // If we are in auto resize mode, then we need to determine
           // what mode to use now.
           if (resizeMode == WindowManager.LayoutParams.SOFT_INPUT_ADJUST_UNSPECIFIED) {
               final int N = mAttachInfo.mScrollContainers.size();
               for (int i=0; i<N; i++) {
                   if (mAttachInfo.mScrollContainers.get(i).isShown()) {
                       resizeMode = WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE;
                   }
               }
               if (resizeMode == 0) {
                   resizeMode = WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN;
               }
               if ((lp.softInputMode &
                       WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST) != resizeMode) {
                   lp.softInputMode = (lp.softInputMode &
                           ~WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST) |
                           resizeMode;
                   params = lp;
               }
           }
       }

       if (params != null) {
           if ((host.mPrivateFlags & View.PFLAG_REQUEST_TRANSPARENT_REGIONS) != 0) {
               if (!PixelFormat.formatHasAlpha(params.format)) {
                   params.format = PixelFormat.TRANSLUCENT;
               }
           }
           mAttachInfo.mOverscanRequested = (params.flags
                   & WindowManager.LayoutParams.FLAG_LAYOUT_IN_OVERSCAN) != 0;
       }

       if (mApplyInsetsRequested) {
           mApplyInsetsRequested = false;
           mLastOverscanRequested = mAttachInfo.mOverscanRequested;
           dispatchApplyInsets(host);
           if (mLayoutRequested) {
               // Short-circuit catching a new layout request here, so
               // we don't need to go through two layout passes when things
               // change due to fitting system windows, which can happen a lot.
               windowSizeMayChange |= measureHierarchy(host, lp,
                       mView.getContext().getResources(),
                       desiredWindowWidth, desiredWindowHeight);
           }
       }

       if (layoutRequested) {
           // Clear this now, so that if anything requests a layout in the
           // rest of this function we will catch it and re-run a full
           // layout pass.
           mLayoutRequested = false;
       }

       boolean windowShouldResize = layoutRequested && windowSizeMayChange
           && ((mWidth != host.getMeasuredWidth() || mHeight != host.getMeasuredHeight())
               || (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT &&
                       frame.width() < desiredWindowWidth && frame.width() != mWidth)
               || (lp.height == ViewGroup.LayoutParams.WRAP_CONTENT &&
                       frame.height() < desiredWindowHeight && frame.height() != mHeight));
       windowShouldResize |= mDragResizing && mResizeMode == RESIZE_MODE_FREEFORM;

       // If the activity was just relaunched, it might have unfrozen the task bounds (while
       // relaunching), so we need to force a call into window manager to pick up the latest
       // bounds.
       windowShouldResize |= mActivityRelaunched;

       // Determine whether to compute insets.
       // If there are no inset listeners remaining then we may still need to compute
       // insets in case the old insets were non-empty and must be reset.
       final boolean computesInternalInsets =
               mAttachInfo.mTreeObserver.hasComputeInternalInsetsListeners()
               || mAttachInfo.mHasNonEmptyGivenInternalInsets;

       boolean insetsPending = false;
       int relayoutResult = 0;
       boolean updatedConfiguration = false;

       final int surfaceGenerationId = mSurface.getGenerationId();

       final boolean isViewVisible = viewVisibility == View.VISIBLE;
       final boolean windowRelayoutWasForced = mForceNextWindowRelayout;
       if (mFirst || windowShouldResize || insetsChanged ||
               viewVisibilityChanged || params != null || mForceNextWindowRelayout) {
           mForceNextWindowRelayout = false;

           if (isViewVisible) {
               // If this window is giving internal insets to the window
               // manager, and it is being added or changing its visibility,
               // then we want to first give the window manager "fake"
               // insets to cause it to effectively ignore the content of
               // the window during layout.  This avoids it briefly causing
               // other windows to resize/move based on the raw frame of the
               // window, waiting until we can finish laying out this window
               // and get back to the window manager with the ultimately
               // computed insets.
               insetsPending = computesInternalInsets && (mFirst || viewVisibilityChanged);
           }

           if (mSurfaceHolder != null) {
               mSurfaceHolder.mSurfaceLock.lock();
               mDrawingAllowed = true;
           }

           boolean hwInitialized = false;
           boolean contentInsetsChanged = false;
           boolean hadSurface = mSurface.isValid();

           try {
               if (DEBUG_LAYOUT) {
                   Log.i(mTag, "host=w:" + host.getMeasuredWidth() + ", h:" +
                           host.getMeasuredHeight() + ", params=" + params);
               }

               if (mAttachInfo.mThreadedRenderer != null) {
                   // relayoutWindow may decide to destroy mSurface. As that decision
                   // happens in WindowManager service, we need to be defensive here
                   // and stop using the surface in case it gets destroyed.
                   if (mAttachInfo.mThreadedRenderer.pauseSurface(mSurface)) {
                       // Animations were running so we need to push a frame
                       // to resume them
                       mDirty.set(0, 0, mWidth, mHeight);
                   }
                   mChoreographer.mFrameInfo.addFlags(FrameInfo.FLAG_WINDOW_LAYOUT_CHANGED);
               }
               relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);

               if (DEBUG_LAYOUT) Log.v(mTag, "relayout: frame=" + frame.toShortString()
                       + " overscan=" + mPendingOverscanInsets.toShortString()
                       + " content=" + mPendingContentInsets.toShortString()
                       + " visible=" + mPendingVisibleInsets.toShortString()
                       + " stable=" + mPendingStableInsets.toShortString()
                       + " cutout=" + mPendingDisplayCutout.get().toString()
                       + " outsets=" + mPendingOutsets.toShortString()
                       + " surface=" + mSurface);

               // If the pending {@link MergedConfiguration} handed back from
               // {@link #relayoutWindow} does not match the one last reported,
               // WindowManagerService has reported back a frame from a configuration not yet
               // handled by the client. In this case, we need to accept the configuration so we
               // do not lay out and draw with the wrong configuration.
               if (!mPendingMergedConfiguration.equals(mLastReportedMergedConfiguration)) {
                   if (DEBUG_CONFIGURATION) Log.v(mTag, "Visible with new config: "
                           + mPendingMergedConfiguration.getMergedConfiguration());
                   performConfigurationChange(mPendingMergedConfiguration, !mFirst,
                           INVALID_DISPLAY /* same display */);
                   updatedConfiguration = true;
               }

               final boolean overscanInsetsChanged = !mPendingOverscanInsets.equals(
                       mAttachInfo.mOverscanInsets);
               contentInsetsChanged = !mPendingContentInsets.equals(
                       mAttachInfo.mContentInsets);
               final boolean visibleInsetsChanged = !mPendingVisibleInsets.equals(
                       mAttachInfo.mVisibleInsets);
               final boolean stableInsetsChanged = !mPendingStableInsets.equals(
                       mAttachInfo.mStableInsets);
               final boolean cutoutChanged = !mPendingDisplayCutout.equals(
                       mAttachInfo.mDisplayCutout);
               final boolean outsetsChanged = !mPendingOutsets.equals(mAttachInfo.mOutsets);
               final boolean surfaceSizeChanged = (relayoutResult
                       & WindowManagerGlobal.RELAYOUT_RES_SURFACE_RESIZED) != 0;
               surfaceChanged |= surfaceSizeChanged;
               final boolean alwaysConsumeNavBarChanged =
                       mPendingAlwaysConsumeNavBar != mAttachInfo.mAlwaysConsumeNavBar;
               if (contentInsetsChanged) {
                   mAttachInfo.mContentInsets.set(mPendingContentInsets);
                   if (DEBUG_LAYOUT) Log.v(mTag, "Content insets changing to: "
                           + mAttachInfo.mContentInsets);
               }
               if (overscanInsetsChanged) {
                   mAttachInfo.mOverscanInsets.set(mPendingOverscanInsets);
                   if (DEBUG_LAYOUT) Log.v(mTag, "Overscan insets changing to: "
                           + mAttachInfo.mOverscanInsets);
                   // Need to relayout with content insets.
                   contentInsetsChanged = true;
               }
               if (stableInsetsChanged) {
                   mAttachInfo.mStableInsets.set(mPendingStableInsets);
                   if (DEBUG_LAYOUT) Log.v(mTag, "Decor insets changing to: "
                           + mAttachInfo.mStableInsets);
                   // Need to relayout with content insets.
                   contentInsetsChanged = true;
               }
               if (cutoutChanged) {
                   mAttachInfo.mDisplayCutout.set(mPendingDisplayCutout);
                   if (DEBUG_LAYOUT) {
                       Log.v(mTag, "DisplayCutout changing to: " + mAttachInfo.mDisplayCutout);
                   }
                   // Need to relayout with content insets.
                   contentInsetsChanged = true;
               }
               if (alwaysConsumeNavBarChanged) {
                   mAttachInfo.mAlwaysConsumeNavBar = mPendingAlwaysConsumeNavBar;
                   contentInsetsChanged = true;
               }
               if (contentInsetsChanged || mLastSystemUiVisibility !=
                       mAttachInfo.mSystemUiVisibility || mApplyInsetsRequested
                       || mLastOverscanRequested != mAttachInfo.mOverscanRequested
                       || outsetsChanged) {
                   mLastSystemUiVisibility = mAttachInfo.mSystemUiVisibility;
                   mLastOverscanRequested = mAttachInfo.mOverscanRequested;
                   mAttachInfo.mOutsets.set(mPendingOutsets);
                   mApplyInsetsRequested = false;
                   dispatchApplyInsets(host);
               }
               if (visibleInsetsChanged) {
                   mAttachInfo.mVisibleInsets.set(mPendingVisibleInsets);
                   if (DEBUG_LAYOUT) Log.v(mTag, "Visible insets changing to: "
                           + mAttachInfo.mVisibleInsets);
               }

               if (!hadSurface) {
                   if (mSurface.isValid()) {
                       // If we are creating a new surface, then we need to
                       // completely redraw it.  Also, when we get to the
                       // point of drawing it we will hold off and schedule
                       // a new traversal instead.  This is so we can tell the
                       // window manager about all of the windows being displayed
                       // before actually drawing them, so it can display then
                       // all at once.
                       newSurface = true;
                       mFullRedrawNeeded = true;
                       mPreviousTransparentRegion.setEmpty();

                       // Only initialize up-front if transparent regions are not
                       // requested, otherwise defer to see if the entire window
                       // will be transparent
                       if (mAttachInfo.mThreadedRenderer != null) {
                           try {
                               hwInitialized = mAttachInfo.mThreadedRenderer.initialize(
                                       mSurface);
                               if (hwInitialized && (host.mPrivateFlags
                                       & View.PFLAG_REQUEST_TRANSPARENT_REGIONS) == 0) {
                                   // Don't pre-allocate if transparent regions
                                   // are requested as they may not be needed
                                   mAttachInfo.mThreadedRenderer.allocateBuffers(mSurface);
                               }
                           } catch (OutOfResourcesException e) {
                               handleOutOfResourcesException(e);
                               return;
                           }
                       }
                   }
               } else if (!mSurface.isValid()) {
                   // If the surface has been removed, then reset the scroll
                   // positions.
                   if (mLastScrolledFocus != null) {
                       mLastScrolledFocus.clear();
                   }
                   mScrollY = mCurScrollY = 0;
                   if (mView instanceof RootViewSurfaceTaker) {
                       ((RootViewSurfaceTaker) mView).onRootViewScrollYChanged(mCurScrollY);
                   }
                   if (mScroller != null) {
                       mScroller.abortAnimation();
                   }
                   // Our surface is gone
                   if (mAttachInfo.mThreadedRenderer != null &&
                           mAttachInfo.mThreadedRenderer.isEnabled()) {
                       mAttachInfo.mThreadedRenderer.destroy();
                   }
               } else if ((surfaceGenerationId != mSurface.getGenerationId()
                       || surfaceSizeChanged || windowRelayoutWasForced)
                       && mSurfaceHolder == null
                       && mAttachInfo.mThreadedRenderer != null) {
                   mFullRedrawNeeded = true;
                   try {
                       // Need to do updateSurface (which leads to CanvasContext::setSurface and
                       // re-create the EGLSurface) if either the Surface changed (as indicated by
                       // generation id), or WindowManager changed the surface size. The latter is
                       // because on some chips, changing the consumer side's BufferQueue size may
                       // not take effect immediately unless we create a new EGLSurface.
                       // Note that frame size change doesn't always imply surface size change (eg.
                       // drag resizing uses fullscreen surface), need to check surfaceSizeChanged
                       // flag from WindowManager.
                       mAttachInfo.mThreadedRenderer.updateSurface(mSurface);
                   } catch (OutOfResourcesException e) {
                       handleOutOfResourcesException(e);
                       return;
                   }
               }

               final boolean freeformResizing = (relayoutResult
                       & WindowManagerGlobal.RELAYOUT_RES_DRAG_RESIZING_FREEFORM) != 0;
               final boolean dockedResizing = (relayoutResult
                       & WindowManagerGlobal.RELAYOUT_RES_DRAG_RESIZING_DOCKED) != 0;
               final boolean dragResizing = freeformResizing || dockedResizing;
               if (mDragResizing != dragResizing) {
                   if (dragResizing) {
                       mResizeMode = freeformResizing
                               ? RESIZE_MODE_FREEFORM
                               : RESIZE_MODE_DOCKED_DIVIDER;
                       // TODO: Need cutout?
                       startDragResizing(mPendingBackDropFrame,
                               mWinFrame.equals(mPendingBackDropFrame), mPendingVisibleInsets,
                               mPendingStableInsets, mResizeMode);
                   } else {
                       // We shouldn't come here, but if we come we should end the resize.
                       endDragResizing();
                   }
               }
               if (!mUseMTRenderer) {
                   if (dragResizing) {
                       mCanvasOffsetX = mWinFrame.left;
                       mCanvasOffsetY = mWinFrame.top;
                   } else {
                       mCanvasOffsetX = mCanvasOffsetY = 0;
                   }
               }
           } catch (RemoteException e) {
           }

           if (DEBUG_ORIENTATION) Log.v(
                   TAG, "Relayout returned: frame=" + frame + ", surface=" + mSurface);

           mAttachInfo.mWindowLeft = frame.left;
           mAttachInfo.mWindowTop = frame.top;

           // !!FIXME!! This next section handles the case where we did not get the
           // window size we asked for. We should avoid this by getting a maximum size from
           // the window session beforehand.
           if (mWidth != frame.width() || mHeight != frame.height()) {
               mWidth = frame.width();
               mHeight = frame.height();
           }

           if (mSurfaceHolder != null) {
               // The app owns the surface; tell it about what is going on.
               if (mSurface.isValid()) {
                   // XXX .copyFrom() doesn't work!
                   //mSurfaceHolder.mSurface.copyFrom(mSurface);
                   mSurfaceHolder.mSurface = mSurface;
               }
               mSurfaceHolder.setSurfaceFrameSize(mWidth, mHeight);
               mSurfaceHolder.mSurfaceLock.unlock();
               if (mSurface.isValid()) {
                   if (!hadSurface) {
                       mSurfaceHolder.ungetCallbacks();

                       mIsCreating = true;
                       SurfaceHolder.Callback callbacks[] = mSurfaceHolder.getCallbacks();
                       if (callbacks != null) {
                           for (SurfaceHolder.Callback c : callbacks) {
                               c.surfaceCreated(mSurfaceHolder);
                           }
                       }
                       surfaceChanged = true;
                   }
                   if (surfaceChanged || surfaceGenerationId != mSurface.getGenerationId()) {
                       SurfaceHolder.Callback callbacks[] = mSurfaceHolder.getCallbacks();
                       if (callbacks != null) {
                           for (SurfaceHolder.Callback c : callbacks) {
                               c.surfaceChanged(mSurfaceHolder, lp.format,
                                       mWidth, mHeight);
                           }
                       }
                   }
                   mIsCreating = false;
               } else if (hadSurface) {
                   notifySurfaceDestroyed();
                   mSurfaceHolder.mSurfaceLock.lock();
                   try {
                       mSurfaceHolder.mSurface = new Surface();
                   } finally {
                       mSurfaceHolder.mSurfaceLock.unlock();
                   }
               }
           }

           final ThreadedRenderer threadedRenderer = mAttachInfo.mThreadedRenderer;
           if (threadedRenderer != null && threadedRenderer.isEnabled()) {
               if (hwInitialized
                       || mWidth != threadedRenderer.getWidth()
                       || mHeight != threadedRenderer.getHeight()
                       || mNeedsRendererSetup) {
                   threadedRenderer.setup(mWidth, mHeight, mAttachInfo,
                           mWindowAttributes.surfaceInsets);
                   mNeedsRendererSetup = false;
               }
           }

           if (!mStopped || mReportNextDraw) {
               boolean focusChangedDueToTouchMode = ensureTouchModeLocally(
                       (relayoutResult&WindowManagerGlobal.RELAYOUT_RES_IN_TOUCH_MODE) != 0);
               if (focusChangedDueToTouchMode || mWidth != host.getMeasuredWidth()
                       || mHeight != host.getMeasuredHeight() || contentInsetsChanged ||
                       updatedConfiguration) {
                   int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
                   int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);

                   if (DEBUG_LAYOUT) Log.v(mTag, "Ooops, something changed!  mWidth="
                           + mWidth + " measuredWidth=" + host.getMeasuredWidth()
                           + " mHeight=" + mHeight
                           + " measuredHeight=" + host.getMeasuredHeight()
                           + " coveredInsetsChanged=" + contentInsetsChanged);

                    // Ask host how big it wants to be
                   performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

                   // Implementation of weights from WindowManager.LayoutParams
                   // We just grow the dimensions as needed and re-measure if
                   // needs be
                   int width = host.getMeasuredWidth();
                   int height = host.getMeasuredHeight();
                   boolean measureAgain = false;

                   if (lp.horizontalWeight > 0.0f) {
                       width += (int) ((mWidth - width) * lp.horizontalWeight);
                       childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(width,
                               MeasureSpec.EXACTLY);
                       measureAgain = true;
                   }
                   if (lp.verticalWeight > 0.0f) {
                       height += (int) ((mHeight - height) * lp.verticalWeight);
                       childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(height,
                               MeasureSpec.EXACTLY);
                       measureAgain = true;
                   }

                   if (measureAgain) {
                       if (DEBUG_LAYOUT) Log.v(mTag,
                               "And hey let's measure once more: width=" + width
                               + " height=" + height);
                       performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
                   }

                   layoutRequested = true;
               }
           }
       } else {
           // Not the first pass and no window/insets/visibility change but the window
           // may have moved and we need check that and if so to update the left and right
           // in the attach info. We translate only the window frame since on window move
           // the window manager tells us only for the new frame but the insets are the
           // same and we do not want to translate them more than once.
           maybeHandleWindowMove(frame);
       }

       final boolean didLayout = layoutRequested && (!mStopped || mReportNextDraw);
       boolean triggerGlobalLayoutListener = didLayout
               || mAttachInfo.mRecomputeGlobalAttributes;
       if (didLayout) {
           performLayout(lp, mWidth, mHeight);

           // By this point all views have been sized and positioned
           // We can compute the transparent area

           if ((host.mPrivateFlags & View.PFLAG_REQUEST_TRANSPARENT_REGIONS) != 0) {
               // start out transparent
               // TODO: AVOID THAT CALL BY CACHING THE RESULT?
               host.getLocationInWindow(mTmpLocation);
               mTransparentRegion.set(mTmpLocation[0], mTmpLocation[1],
                       mTmpLocation[0] + host.mRight - host.mLeft,
                       mTmpLocation[1] + host.mBottom - host.mTop);

               host.gatherTransparentRegion(mTransparentRegion);
               if (mTranslator != null) {
                   mTranslator.translateRegionInWindowToScreen(mTransparentRegion);
               }

               if (!mTransparentRegion.equals(mPreviousTransparentRegion)) {
                   mPreviousTransparentRegion.set(mTransparentRegion);
                   mFullRedrawNeeded = true;
                   // reconfigure window manager
                   try {
                       mWindowSession.setTransparentRegion(mWindow, mTransparentRegion);
                   } catch (RemoteException e) {
                   }
               }
           }

           if (DBG) {
               System.out.println("======================================");
               System.out.println("performTraversals -- after setFrame");
               host.debug();
           }
       }

       if (triggerGlobalLayoutListener) {
           mAttachInfo.mRecomputeGlobalAttributes = false;
           mAttachInfo.mTreeObserver.dispatchOnGlobalLayout();
       }

       if (computesInternalInsets) {
           // Clear the original insets.
           final ViewTreeObserver.InternalInsetsInfo insets = mAttachInfo.mGivenInternalInsets;
           insets.reset();

           // Compute new insets in place.
           mAttachInfo.mTreeObserver.dispatchOnComputeInternalInsets(insets);
           mAttachInfo.mHasNonEmptyGivenInternalInsets = !insets.isEmpty();

           // Tell the window manager.
           if (insetsPending || !mLastGivenInsets.equals(insets)) {
               mLastGivenInsets.set(insets);

               // Translate insets to screen coordinates if needed.
               final Rect contentInsets;
               final Rect visibleInsets;
               final Region touchableRegion;
               if (mTranslator != null) {
                   contentInsets = mTranslator.getTranslatedContentInsets(insets.contentInsets);
                   visibleInsets = mTranslator.getTranslatedVisibleInsets(insets.visibleInsets);
                   touchableRegion = mTranslator.getTranslatedTouchableArea(insets.touchableRegion);
               } else {
                   contentInsets = insets.contentInsets;
                   visibleInsets = insets.visibleInsets;
                   touchableRegion = insets.touchableRegion;
               }

               try {
                   mWindowSession.setInsets(mWindow, insets.mTouchableInsets,
                           contentInsets, visibleInsets, touchableRegion);
               } catch (RemoteException e) {
               }
           }
       }

       if (mFirst) {
           if (sAlwaysAssignFocus || !isInTouchMode()) {
               // handle first focus request
               if (DEBUG_INPUT_RESIZE) {
                   Log.v(mTag, "First: mView.hasFocus()=" + mView.hasFocus());
               }
               if (mView != null) {
                   if (!mView.hasFocus()) {
                       mView.restoreDefaultFocus();
                       if (DEBUG_INPUT_RESIZE) {
                           Log.v(mTag, "First: requested focused view=" + mView.findFocus());
                       }
                   } else {
                       if (DEBUG_INPUT_RESIZE) {
                           Log.v(mTag, "First: existing focused view=" + mView.findFocus());
                       }
                   }
               }
           } else {
               // Some views (like ScrollView) won't hand focus to descendants that aren't within
               // their viewport. Before layout, there's a good change these views are size 0
               // which means no children can get focus. After layout, this view now has size, but
               // is not guaranteed to hand-off focus to a focusable child (specifically, the edge-
               // case where the child has a size prior to layout and thus won't trigger
               // focusableViewAvailable).
               View focused = mView.findFocus();
               if (focused instanceof ViewGroup
                       && ((ViewGroup) focused).getDescendantFocusability()
                               == ViewGroup.FOCUS_AFTER_DESCENDANTS) {
                   focused.restoreDefaultFocus();
               }
           }
       }

       final boolean changedVisibility = (viewVisibilityChanged || mFirst) && isViewVisible;
       final boolean hasWindowFocus = mAttachInfo.mHasWindowFocus && isViewVisible;
       final boolean regainedFocus = hasWindowFocus && mLostWindowFocus;
       if (regainedFocus) {
           mLostWindowFocus = false;
       } else if (!hasWindowFocus && mHadWindowFocus) {
           mLostWindowFocus = true;
       }

       if (changedVisibility || regainedFocus) {
           // Toasts are presented as notifications - don't present them as windows as well
           boolean isToast = (mWindowAttributes == null) ? false
                   : (mWindowAttributes.type == WindowManager.LayoutParams.TYPE_TOAST);
           if (!isToast) {
               host.sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
           }
       }

       mFirst = false;
       mWillDrawSoon = false;
       mNewSurfaceNeeded = false;
       mActivityRelaunched = false;
       mViewVisibility = viewVisibility;
       mHadWindowFocus = hasWindowFocus;

       if (hasWindowFocus && !isInLocalFocusMode()) {
           final boolean imTarget = WindowManager.LayoutParams
                   .mayUseInputMethod(mWindowAttributes.flags);
           if (imTarget != mLastWasImTarget) {
               mLastWasImTarget = imTarget;
               InputMethodManager imm = InputMethodManager.peekInstance();
               if (imm != null && imTarget) {
                   imm.onPreWindowFocus(mView, hasWindowFocus);
                   imm.onPostWindowFocus(mView, mView.findFocus(),
                           mWindowAttributes.softInputMode,
                           !mHasHadWindowFocus, mWindowAttributes.flags);
               }
           }
       }

       // Remember if we must report the next draw.
       if ((relayoutResult & WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME) != 0) {
           reportNextDraw();
       }

       boolean cancelDraw = mAttachInfo.mTreeObserver.dispatchOnPreDraw() || !isViewVisible;

       if (!cancelDraw && !newSurface) {
           if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
               for (int i = 0; i < mPendingTransitions.size(); ++i) {
                   mPendingTransitions.get(i).startChangingAnimations();
               }
               mPendingTransitions.clear();
           }

           performDraw();
       } else {
           if (isViewVisible) {
               // Try again
               scheduleTraversals();
           } else if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
               for (int i = 0; i < mPendingTransitions.size(); ++i) {
                   mPendingTransitions.get(i).endChangingAnimations();
               }
               mPendingTransitions.clear();
           }
       }

       mIsInTraversal = false;
   }

这里主要是判断是否需要执行performMeasure() ，performLayout()，performDraw()这三个过程都会遍历View树刷新需要更新的view。

2.10 Session.addToDisplay

[->Session.java]

1
2
3
4
5
6
7
8
@Override
public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
          int viewVisibility, int displayId, Rect outFrame, Rect outContentInsets,
          Rect outStableInsets, Rect outOutsets,
          DisplayCutout.ParcelableWrapper outDisplayCutout, InputChannel outInputChannel) {
      return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId, outFrame,
              outContentInsets, outStableInsets, outOutsets, outDisplayCutout, outInputChannel);
 }

2.11 WMS.addWindow

[->WindowManagerService.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
public int addWindow(Session session, IWindow client, int seq,
          LayoutParams attrs, int viewVisibility, int displayId, Rect outFrame,
          Rect outContentInsets, Rect outStableInsets, Rect outOutsets,
          DisplayCutout.ParcelableWrapper outDisplayCutout, InputChannel outInputChannel) {
      int[] appOp = new int[1];
      //此处mPolicy为PhoneWindowManager
      int res = mPolicy.checkAddPermission(attrs, appOp);
      if (res != WindowManagerGlobal.ADD_OKAY) {
          return res;
      }

      boolean reportNewConfig = false;
      WindowState parentWindow = null;
      long origId;
      final int callingUid = Binder.getCallingUid();
      final int type = attrs.type;

      synchronized(mWindowMap) {
          if (!mDisplayReady) {
              throw new IllegalStateException("Display has not been initialialized");
          }

          final DisplayContent displayContent = getDisplayContentOrCreate(displayId);

          if (displayContent == null) {
              Slog.w(TAG_WM, "Attempted to add window to a display that does not exist: "
                      + displayId + ".  Aborting.");
              return WindowManagerGlobal.ADD_INVALID_DISPLAY;
          }
          if (!displayContent.hasAccess(session.mUid)
                  && !mDisplayManagerInternal.isUidPresentOnDisplay(session.mUid, displayId)) {
              Slog.w(TAG_WM, "Attempted to add window to a display for which the application "
                      + "does not have access: " + displayId + ".  Aborting.");
              return WindowManagerGlobal.ADD_INVALID_DISPLAY;
          }

          if (mWindowMap.containsKey(client.asBinder())) {
              Slog.w(TAG_WM, "Window " + client + " is already added");
              return WindowManagerGlobal.ADD_DUPLICATE_ADD;
          }

          if (type >= FIRST_SUB_WINDOW && type <= LAST_SUB_WINDOW) {
              parentWindow = windowForClientLocked(null, attrs.token, false);
              if (parentWindow == null) {
                  Slog.w(TAG_WM, "Attempted to add window with token that is not a window: "
                        + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_SUBWINDOW_TOKEN;
              }
              if (parentWindow.mAttrs.type >= FIRST_SUB_WINDOW
                      && parentWindow.mAttrs.type <= LAST_SUB_WINDOW) {
                  Slog.w(TAG_WM, "Attempted to add window with token that is a sub-window: "
                          + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_SUBWINDOW_TOKEN;
              }
          }

          if (type == TYPE_PRIVATE_PRESENTATION && !displayContent.isPrivate()) {
              Slog.w(TAG_WM, "Attempted to add private presentation window to a non-private display.  Aborting.");
              return WindowManagerGlobal.ADD_PERMISSION_DENIED;
          }

          AppWindowToken atoken = null;
          final boolean hasParent = parentWindow != null;
          // Use existing parent window token for child windows since they go in the same token
          // as there parent window so we can apply the same policy on them.
          WindowToken token = displayContent.getWindowToken(
                  hasParent ? parentWindow.mAttrs.token : attrs.token);
          // If this is a child window, we want to apply the same type checking rules as the
          // parent window type.
          final int rootType = hasParent ? parentWindow.mAttrs.type : type;

          boolean addToastWindowRequiresToken = false;
          //判读token
          if (token == null) {
              if (rootType >= FIRST_APPLICATION_WINDOW && rootType <= LAST_APPLICATION_WINDOW) {
                  Slog.w(TAG_WM, "Attempted to add application window with unknown token "
                        + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
              }
              if (rootType == TYPE_INPUT_METHOD) {
                  Slog.w(TAG_WM, "Attempted to add input method window with unknown token "
                        + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
              }
              if (rootType == TYPE_VOICE_INTERACTION) {
                  Slog.w(TAG_WM, "Attempted to add voice interaction window with unknown token "
                        + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
              }
              if (rootType == TYPE_WALLPAPER) {
                  Slog.w(TAG_WM, "Attempted to add wallpaper window with unknown token "
                        + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
              }
              if (rootType == TYPE_DREAM) {
                  Slog.w(TAG_WM, "Attempted to add Dream window with unknown token "
                        + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
              }
              if (rootType == TYPE_QS_DIALOG) {
                  Slog.w(TAG_WM, "Attempted to add QS dialog window with unknown token "
                        + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
              }
              if (rootType == TYPE_ACCESSIBILITY_OVERLAY) {
                  Slog.w(TAG_WM, "Attempted to add Accessibility overlay window with unknown token "
                          + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
              }
              if (type == TYPE_TOAST) {
                  // Apps targeting SDK above N MR1 cannot arbitrary add toast windows.
                  if (doesAddToastWindowRequireToken(attrs.packageName, callingUid,
                          parentWindow)) {
                      Slog.w(TAG_WM, "Attempted to add a toast window with unknown token "
                              + attrs.token + ".  Aborting.");
                      return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
                  }
              }
              final IBinder binder = attrs.token != null ? attrs.token : client.asBinder();
              final boolean isRoundedCornerOverlay =
                      (attrs.privateFlags & PRIVATE_FLAG_IS_ROUNDED_CORNERS_OVERLAY) != 0;
              token = new WindowToken(this, binder, type, false, displayContent,
                      session.mCanAddInternalSystemWindow, isRoundedCornerOverlay);
          } else if (rootType >= FIRST_APPLICATION_WINDOW && rootType <= LAST_APPLICATION_WINDOW) {
              atoken = token.asAppWindowToken();
              if (atoken == null) {
                  Slog.w(TAG_WM, "Attempted to add window with non-application token "
                        + token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_NOT_APP_TOKEN;
              } else if (atoken.removed) {
                  Slog.w(TAG_WM, "Attempted to add window with exiting application token "
                        + token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_APP_EXITING;
              } else if (type == TYPE_APPLICATION_STARTING && atoken.startingWindow != null) {
                  Slog.w(TAG_WM, "Attempted to add starting window to token with already existing"
                          + " starting window");
                  return WindowManagerGlobal.ADD_DUPLICATE_ADD;
              }
          } else if (rootType == TYPE_INPUT_METHOD) {
              if (token.windowType != TYPE_INPUT_METHOD) {
                  Slog.w(TAG_WM, "Attempted to add input method window with bad token "
                          + attrs.token + ".  Aborting.");
                    return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
              }
          } else if (rootType == TYPE_VOICE_INTERACTION) {
              if (token.windowType != TYPE_VOICE_INTERACTION) {
                  Slog.w(TAG_WM, "Attempted to add voice interaction window with bad token "
                          + attrs.token + ".  Aborting.");
                    return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
              }
          } else if (rootType == TYPE_WALLPAPER) {
              if (token.windowType != TYPE_WALLPAPER) {
                  Slog.w(TAG_WM, "Attempted to add wallpaper window with bad token "
                          + attrs.token + ".  Aborting.");
                    return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
              }
          } else if (rootType == TYPE_DREAM) {
              if (token.windowType != TYPE_DREAM) {
                  Slog.w(TAG_WM, "Attempted to add Dream window with bad token "
                          + attrs.token + ".  Aborting.");
                    return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
              }
          } else if (rootType == TYPE_ACCESSIBILITY_OVERLAY) {
              if (token.windowType != TYPE_ACCESSIBILITY_OVERLAY) {
                  Slog.w(TAG_WM, "Attempted to add Accessibility overlay window with bad token "
                          + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
              }
          } else if (type == TYPE_TOAST) {
              // Apps targeting SDK above N MR1 cannot arbitrary add toast windows.
              addToastWindowRequiresToken = doesAddToastWindowRequireToken(attrs.packageName,
                      callingUid, parentWindow);
              if (addToastWindowRequiresToken && token.windowType != TYPE_TOAST) {
                  Slog.w(TAG_WM, "Attempted to add a toast window with bad token "
                          + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
              }
          } else if (type == TYPE_QS_DIALOG) {
              if (token.windowType != TYPE_QS_DIALOG) {
                  Slog.w(TAG_WM, "Attempted to add QS dialog window with bad token "
                          + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
              }
          } else if (token.asAppWindowToken() != null) {
              Slog.w(TAG_WM, "Non-null appWindowToken for system window of rootType=" + rootType);
              // It is not valid to use an app token with other system types; we will
              // instead make a new token for it (as if null had been passed in for the token).
              attrs.token = null;
              token = new WindowToken(this, client.asBinder(), type, false, displayContent,
                      session.mCanAddInternalSystemWindow);
          }
          //创建WindowState
          final WindowState win = new WindowState(this, session, client, token, parentWindow,
                  appOp[0], seq, attrs, viewVisibility, session.mUid,
                  session.mCanAddInternalSystemWindow);
          if (win.mDeathRecipient == null) {
              // Client has apparently died, so there is no reason to
              // continue.
              Slog.w(TAG_WM, "Adding window client " + client.asBinder()
                      + " that is dead, aborting.");
              return WindowManagerGlobal.ADD_APP_EXITING;
          }

          if (win.getDisplayContent() == null) {
              Slog.w(TAG_WM, "Adding window to Display that has been removed.");
              return WindowManagerGlobal.ADD_INVALID_DISPLAY;
          }

          final boolean hasStatusBarServicePermission =
                  mContext.checkCallingOrSelfPermission(permission.STATUS_BAR_SERVICE)
                          == PackageManager.PERMISSION_GRANTED;
          //调整WindowManager的LayoutParams参数                
          mPolicy.adjustWindowParamsLw(win, win.mAttrs, hasStatusBarServicePermission);
          win.setShowToOwnerOnlyLocked(mPolicy.checkShowToOwnerOnly(attrs));

          res = mPolicy.prepareAddWindowLw(win, attrs);
          if (res != WindowManagerGlobal.ADD_OKAY) {
              return res;
          }

          final boolean openInputChannels = (outInputChannel != null
                  && (attrs.inputFeatures & INPUT_FEATURE_NO_INPUT_CHANNEL) == 0);
          if  (openInputChannels) {
              //打开输入通道
              win.openInputChannel(outInputChannel);
          }

          // If adding a toast requires a token for this app we always schedule hiding
          // toast windows to make sure they don't stick around longer then necessary.
          // We hide instead of remove such windows as apps aren't prepared to handle
          // windows being removed under them.
          //
          // If the app is older it can add toasts without a token and hence overlay
          // other apps. To be maximally compatible with these apps we will hide the
          // window after the toast timeout only if the focused window is from another
          // UID, otherwise we allow unlimited duration. When a UID looses focus we
          // schedule hiding all of its toast windows.
          if (type == TYPE_TOAST) {
              if (!getDefaultDisplayContentLocked().canAddToastWindowForUid(callingUid)) {
                  Slog.w(TAG_WM, "Adding more than one toast window for UID at a time.");
                  return WindowManagerGlobal.ADD_DUPLICATE_ADD;
              }
              // Make sure this happens before we moved focus as one can make the
              // toast focusable to force it not being hidden after the timeout.
              // Focusable toasts are always timed out to prevent a focused app to
              // show a focusable toasts while it has focus which will be kept on
              // the screen after the activity goes away.
              if (addToastWindowRequiresToken
                      || (attrs.flags & LayoutParams.FLAG_NOT_FOCUSABLE) == 0
                      || mCurrentFocus == null
                      || mCurrentFocus.mOwnerUid != callingUid) {
                  mH.sendMessageDelayed(
                          mH.obtainMessage(H.WINDOW_HIDE_TIMEOUT, win),
                          win.mAttrs.hideTimeoutMilliseconds);
              }
          }

          // From now on, no exceptions or errors allowed!

          res = WindowManagerGlobal.ADD_OKAY;
          if (mCurrentFocus == null) {
              mWinAddedSinceNullFocus.add(win);
          }

          if (excludeWindowTypeFromTapOutTask(type)) {
              displayContent.mTapExcludedWindows.add(win);
          }

          origId = Binder.clearCallingIdentity();
          //见2.11.2节
          win.attach();
          mWindowMap.put(client.asBinder(), win);

          win.initAppOpsState();

          final boolean suspended = mPmInternal.isPackageSuspended(win.getOwningPackage(),
                  UserHandle.getUserId(win.getOwningUid()));
          win.setHiddenWhileSuspended(suspended);

          final boolean hideSystemAlertWindows = !mHidingNonSystemOverlayWindows.isEmpty();
          win.setForceHideNonSystemOverlayWindowIfNeeded(hideSystemAlertWindows);

          final AppWindowToken aToken = token.asAppWindowToken();
          if (type == TYPE_APPLICATION_STARTING && aToken != null) {
              aToken.startingWindow = win;
              if (DEBUG_STARTING_WINDOW) Slog.v (TAG_WM, "addWindow: " + aToken
                      + " startingWindow=" + win);
          }

          boolean imMayMove = true;

          win.mToken.addWindow(win);
          if (type == TYPE_INPUT_METHOD) {
              win.mGivenInsetsPending = true;
              setInputMethodWindowLocked(win);
              imMayMove = false;
          } else if (type == TYPE_INPUT_METHOD_DIALOG) {
              displayContent.computeImeTarget(true /* updateImeTarget */);
              imMayMove = false;
          } else {
              if (type == TYPE_WALLPAPER) {
                  displayContent.mWallpaperController.clearLastWallpaperTimeoutTime();
                  displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
              } else if ((attrs.flags&FLAG_SHOW_WALLPAPER) != 0) {
                  displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
              } else if (displayContent.mWallpaperController.isBelowWallpaperTarget(win)) {
                  // If there is currently a wallpaper being shown, and
                  // the base layer of the new window is below the current
                  // layer of the target window, then adjust the wallpaper.
                  // This is to avoid a new window being placed between the
                  // wallpaper and its target.
                  displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
              }
          }

          // If the window is being added to a stack that's currently adjusted for IME,
          // make sure to apply the same adjust to this new window.
          win.applyAdjustForImeIfNeeded();

          if (type == TYPE_DOCK_DIVIDER) {
              mRoot.getDisplayContent(displayId).getDockedDividerController().setWindow(win);
          }

          final WindowStateAnimator winAnimator = win.mWinAnimator;
          winAnimator.mEnterAnimationPending = true;
          winAnimator.mEnteringAnimation = true;
          // Check if we need to prepare a transition for replacing window first.
          if (atoken != null && atoken.isVisible()
                  && !prepareWindowReplacementTransition(atoken)) {
              // If not, check if need to set up a dummy transition during display freeze
              // so that the unfreeze wait for the apps to draw. This might be needed if
              // the app is relaunching.
              prepareNoneTransitionForRelaunching(atoken);
          }

          final DisplayFrames displayFrames = displayContent.mDisplayFrames;
          // TODO: Not sure if onDisplayInfoUpdated() call is needed.
          final DisplayInfo displayInfo = displayContent.getDisplayInfo();
          displayFrames.onDisplayInfoUpdated(displayInfo,
                  displayContent.calculateDisplayCutoutForRotation(displayInfo.rotation));
          final Rect taskBounds;
          if (atoken != null && atoken.getTask() != null) {
              taskBounds = mTmpRect;
              atoken.getTask().getBounds(mTmpRect);
          } else {
              taskBounds = null;
          }
          if (mPolicy.getLayoutHintLw(win.mAttrs, taskBounds, displayFrames, outFrame,
                  outContentInsets, outStableInsets, outOutsets, outDisplayCutout)) {
              res |= WindowManagerGlobal.ADD_FLAG_ALWAYS_CONSUME_NAV_BAR;
          }

          if (mInTouchMode) {
              res |= WindowManagerGlobal.ADD_FLAG_IN_TOUCH_MODE;
          }
          if (win.mAppToken == null || !win.mAppToken.isClientHidden()) {
              res |= WindowManagerGlobal.ADD_FLAG_APP_VISIBLE;
          }

          mInputMonitor.setUpdateInputWindowsNeededLw();

          boolean focusChanged = false;
          if (win.canReceiveKeys()) {
             //当该窗口可以接收按键事件，则更新窗口
              focusChanged = updateFocusedWindowLocked(UPDATE_FOCUS_WILL_ASSIGN_LAYERS,
                      false /*updateInputWindows*/);
              if (focusChanged) {
                  imMayMove = false;
              }
          }

          if (imMayMove) {
              displayContent.computeImeTarget(true /* updateImeTarget */);
          }

          // Don't do layout here, the window must call
          // relayout to be displayed, so we'll do it there.
          win.getParent().assignChildLayers();

          if (focusChanged) {
              mInputMonitor.setInputFocusLw(mCurrentFocus, false /*updateInputWindows*/);
          }
          //更新输入窗口
          mInputMonitor.updateInputWindowsLw(false /*force*/);

          if (localLOGV || DEBUG_ADD_REMOVE) Slog.v(TAG_WM, "addWindow: New client "
                  + client.asBinder() + ": window=" + win + " Callers=" + Debug.getCallers(5));

          if (win.isVisibleOrAdding() && updateOrientationFromAppTokensLocked(displayId)) {
              reportNewConfig = true;
          }
      }

      if (reportNewConfig) {
          sendNewConfiguration(displayId);
      }

      Binder.restoreCallingIdentity(origId);

      return res;
  }

2.11.1 WindowState

[->WindowState.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
WindowState(WindowManagerService service, Session s, IWindow c, WindowToken token,
           WindowState parentWindow, int appOp, int seq, WindowManager.LayoutParams a,
           int viewVisibility, int ownerId, boolean ownerCanAddInternalSystemWindow,
           PowerManagerWrapper powerManagerWrapper) {
       super(service);
       //Session的Binder服务端
       mSession = s; 
       //IWindow的代理端
       mClient = c;
       mAppOp = appOp;
       mToken = token;
       mAppToken = mToken.asAppWindowToken();
       //对应app的uid
       mOwnerUid = ownerId;
       mOwnerCanAddInternalSystemWindow = ownerCanAddInternalSystemWindow;
       mWindowId = new WindowId(this);
       mAttrs.copyFrom(a);
       mLastSurfaceInsets.set(mAttrs.surfaceInsets);
       mViewVisibility = viewVisibility;
       mPolicy = mService.mPolicy;
       mContext = mService.mContext;
       DeathRecipient deathRecipient = new DeathRecipient();
       mSeq = seq;
       mEnforceSizeCompat = (mAttrs.privateFlags & PRIVATE_FLAG_COMPATIBLE_WINDOW) != 0;
       mPowerManagerWrapper = powerManagerWrapper;
       mForceSeamlesslyRotate = token.mRoundedCornerOverlay;
       if (localLOGV) Slog.v(
           TAG, "Window " + this + " client=" + c.asBinder()
           + " token=" + token + " (" + mAttrs.token + ")" + " params=" + a);
       try {
           c.asBinder().linkToDeath(deathRecipient, 0);
       } catch (RemoteException e) {
           mDeathRecipient = null;
           mIsChildWindow = false;
           mLayoutAttached = false;
           mIsImWindow = false;
           mIsWallpaper = false;
           mIsFloatingLayer = false;
           mBaseLayer = 0;
           mSubLayer = 0;
           mInputWindowHandle = null;
           mWinAnimator = null;
           return;
       }
       mDeathRecipient = deathRecipient;

       if (mAttrs.type >= FIRST_SUB_WINDOW && mAttrs.type <= LAST_SUB_WINDOW) {
           // The multiplier here is to reserve space for multiple
           // windows in the same type layer.
           mBaseLayer = mPolicy.getWindowLayerLw(parentWindow)
                   * TYPE_LAYER_MULTIPLIER + TYPE_LAYER_OFFSET;
           mSubLayer = mPolicy.getSubWindowLayerFromTypeLw(a.type);
           mIsChildWindow = true;

           if (DEBUG_ADD_REMOVE) Slog.v(TAG, "Adding " + this + " to " + parentWindow);
           parentWindow.addChild(this, sWindowSubLayerComparator);

           mLayoutAttached = mAttrs.type !=
                   WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG;
           mIsImWindow = parentWindow.mAttrs.type == TYPE_INPUT_METHOD
                   || parentWindow.mAttrs.type == TYPE_INPUT_METHOD_DIALOG;
           mIsWallpaper = parentWindow.mAttrs.type == TYPE_WALLPAPER;
       } else {
           // The multiplier here is to reserve space for multiple
           // windows in the same type layer.
           mBaseLayer = mPolicy.getWindowLayerLw(this)
                   * TYPE_LAYER_MULTIPLIER + TYPE_LAYER_OFFSET;
           mSubLayer = 0;
           mIsChildWindow = false;
           mLayoutAttached = false;
           mIsImWindow = mAttrs.type == TYPE_INPUT_METHOD
                   || mAttrs.type == TYPE_INPUT_METHOD_DIALOG;
           mIsWallpaper = mAttrs.type == TYPE_WALLPAPER;
       }
       mIsFloatingLayer = mIsImWindow || mIsWallpaper;

       if (mAppToken != null && mAppToken.mShowForAllUsers) {
           // Windows for apps that can show for all users should also show when the device is
           // locked.
           mAttrs.flags |= FLAG_SHOW_WHEN_LOCKED;
       }

       mWinAnimator = new WindowStateAnimator(this);
       mWinAnimator.mAlpha = a.alpha;

       mRequestedWidth = 0;
       mRequestedHeight = 0;
       mLastRequestedWidth = 0;
       mLastRequestedHeight = 0;
       mLayer = 0;
       mInputWindowHandle = new InputWindowHandle(
               mAppToken != null ? mAppToken.mInputApplicationHandle : null, this, c,
                   getDisplayId());
   }

2.11.2 ws.attach

[->WindowState.java]

1
2
3
4
void attach() {
      if (localLOGV) Slog.v(TAG, "Attaching " + this + " token=" + mToken);
      mSession.windowAddedLocked(mAttrs.packageName);
  }

[->Session.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void windowAddedLocked(String packageName) {
       mPackageName = packageName;
       mRelayoutTag = "relayoutWindow: " + mPackageName;
       if (mSurfaceSession == null) {
           if (WindowManagerService.localLOGV) Slog.v(
               TAG_WM, "First window added to " + this + ", creating SurfaceSession");
           //创建SurfaceSession对象
           mSurfaceSession = new SurfaceSession();
           if (SHOW_TRANSACTIONS) Slog.i(
                   TAG_WM, "  NEW SURFACE SESSION " + mSurfaceSession);
           //将当前Session添加到mSessions
           mService.mSessions.add(this);
           if (mLastReportedAnimatorScale != mService.getCurrentAnimatorScale()) {
               mService.dispatchNewAnimatorScaleLocked(this);
           }
       }
       mNumWindow++;
   }

2.11.3 创建SurfaceSession

[->SurfaceSession.java]

1
2
3
public SurfaceSession() {
      mNativeClient = nativeCreate();
 }

[->core/jni/android_view_SurfaceSession.cpp]

1
2
3
4
5
static jlong nativeCreate(JNIEnv* env, jclass clazz) {
    SurfaceComposerClient* client = new SurfaceComposerClient();
    client->incStrong((void*)nativeCreate);
    return reinterpret_cast<jlong>(client);
}

创建SurfaceComposerClient，作为SurfaceFlinger通信的对象

2.12 WMS.updateFocusedWindowLocked

[->WindowManagerService.java]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
boolean updateFocusedWindowLocked(int mode, boolean updateInputWindows) {
       WindowState newFocus = mRoot.computeFocusedWindow();
       //当前焦点改变
       if (mCurrentFocus != newFocus) {
           Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "wmUpdateFocus");
           // This check makes sure that we don't already have the focus
           // change message pending.
           mH.removeMessages(H.REPORT_FOCUS_CHANGE);
           mH.sendEmptyMessage(H.REPORT_FOCUS_CHANGE);
           // TODO(multidisplay): Focused windows on default display only.
           final DisplayContent displayContent = getDefaultDisplayContentLocked();
           boolean imWindowChanged = false;
           if (mInputMethodWindow != null) {
               final WindowState prevTarget = mInputMethodTarget;
               final WindowState newTarget =
                       displayContent.computeImeTarget(true /* updateImeTarget*/);

               imWindowChanged = prevTarget != newTarget;

               if (mode != UPDATE_FOCUS_WILL_ASSIGN_LAYERS
                       && mode != UPDATE_FOCUS_WILL_PLACE_SURFACES) {
                   final int prevImeAnimLayer = mInputMethodWindow.mWinAnimator.mAnimLayer;
                   displayContent.assignWindowLayers(false /* setLayoutNeeded */);
                   imWindowChanged |=
                           prevImeAnimLayer != mInputMethodWindow.mWinAnimator.mAnimLayer;
               }
           }

           if (imWindowChanged) {
               mWindowsChanged = true;
               displayContent.setLayoutNeeded();
               newFocus = mRoot.computeFocusedWindow();
           }

           if (DEBUG_FOCUS_LIGHT || localLOGV) Slog.v(TAG_WM, "Changing focus from " +
                   mCurrentFocus + " to " + newFocus + " Callers=" + Debug.getCallers(4));
           final WindowState oldFocus = mCurrentFocus;
           mCurrentFocus = newFocus;
           mLosingFocus.remove(newFocus);

           if (mCurrentFocus != null) {
               mWinAddedSinceNullFocus.clear();
               mWinRemovedSinceNullFocus.clear();
           }

           int focusChanged = mPolicy.focusChangedLw(oldFocus, newFocus);

           if (imWindowChanged && oldFocus != mInputMethodWindow) {
               // Focus of the input method window changed. Perform layout if needed.
               // 如果焦点改变，则执行layout
               if (mode == UPDATE_FOCUS_PLACING_SURFACES) {
                   displayContent.performLayout(true /*initial*/,  updateInputWindows);
                   focusChanged &= ~FINISH_LAYOUT_REDO_LAYOUT;
               } else if (mode == UPDATE_FOCUS_WILL_PLACE_SURFACES) {
                   // Client will do the layout, but we need to assign layers
                   // for handleNewWindowLocked() below.
                   displayContent.assignWindowLayers(false /* setLayoutNeeded */);
               }
           }

           if ((focusChanged & FINISH_LAYOUT_REDO_LAYOUT) != 0) {
               // The change in focus caused us to need to do a layout.  Okay.
               displayContent.setLayoutNeeded();
               if (mode == UPDATE_FOCUS_PLACING_SURFACES) {
                   displayContent.performLayout(true /*initial*/, updateInputWindows);
               }
           }

           if (mode != UPDATE_FOCUS_WILL_ASSIGN_LAYERS) {
               // If we defer assigning layers, then the caller is responsible for
               // doing this part.
               mInputMonitor.setInputFocusLw(mCurrentFocus, updateInputWindows);
           }

           displayContent.adjustForImeIfNeeded();

           // We may need to schedule some toast windows to be removed. The toasts for an app that
           // does not have input focus are removed within a timeout to prevent apps to redress
           // other apps' UI.
           displayContent.scheduleToastWindowsTimeoutIfNeededLocked(oldFocus, newFocus);

           Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
           return true;
       }
       return false;
   }

三、总结

本文详细分析了Android屏幕刷新机制中的View的绘制过程，这里只介绍到framework层。

1.从Activity的启动流程开始分析，在performLaunchActivity方法中调用Activity.attach方法创建PhoneWindow；

2.PhoneWindow中有一个DecorView实例，DecorView继承于FrameLayout，通过setContentView将Activity中的布局view添加DecorView中；

3.调用handleResumeActivity，进入到Activity的onResume方法，后面再调用Activity.makeVisible方法；

4.makeVisible方法调用了WindowManagerGlobal.addView方法，创建了ViewRootImpl对象；

5.调用ViewRootImlp中的requestLayout，再调用到里面的scheduleTraversals进行绘制；

6.scheduleTraversals方法，向主线程发送同步屏障消息，通过mChoreographer.postCallback将mTraversalRunnable放到mCallbackQueues队列里面，在同一个帧内，多次请求requestLayout，只会调用一次scheduleTraversals。

7.如果当前线程是主线程则调用nativeScheduleVsync，如果不是则通过handler发送到主线程进行处理；

8.native方法主要是向底层注册监听Vsync屏幕刷新信号，当下一个Vsync信号发出时，底层会回调onVsync方法

9.onVsync方法，会向主线程发送Runnable异步消息，里面会执行doFrame方法；

10.doFrame会执行mCallbackQueues队列里面的任务，取出来的任务会执行doTraversal方法

11.doTraversal方法会先移除主线程中同步屏障，然后调用performTraversals，根据当前的状态判断是否需要执行performMeasure，performLayout，performDraw，这三个过程都会遍历View树刷新需要更新的view。

12.通过Session.addToDisplay向WMS添加Window，WMS建立SurfaceComposerClient，然后会在SurfaceFlinger创建Client与之对应，后面通过ISurfaceComposerClient和SurfaceFlinger进行通信。