Android View.Post 的原理及缺陷

/**
 * 作者：leavesC
 * 时间：2020/03/14 11:05
 * 描述：
 * GitHub：https://github.com/leavesC
 */
class MainActivity : AppCompatActivity() {

 private val view by lazy {
  findViewById<View>(R.id.view)
 }

 override fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)
  setContentView(R.layout.activity_main)
  getWidthHeight("onCreate")
  view.post {
   getWidthHeight("view.Post")
  }
  Handler().post {
   getWidthHeight("handler")
  }
 }

 override fun onResume() {
  super.onResume()
  getWidthHeight("onResume")
 }

 private fun getWidthHeight(tag: String) {
  Log.e(tag, "width: "   view.width)
  Log.e(tag, "height: "   view.height)
 }

}

github.leavesc.view E/onCreate: width: 0
github.leavesc.view E/onCreate: height: 0
github.leavesc.view E/onResume: width: 0
github.leavesc.view E/onResume: height: 0
github.leavesc.view E/handler: width: 0
github.leavesc.view E/handler: height: 0
github.leavesc.view E/view.Post: width: 263
github.leavesc.view E/view.Post: height: 263

 public boolean post(Runnable action) {
  final AttachInfo attachInfo = mAttachInfo;
  if (attachInfo != null) {
   return attachInfo.mHandler.post(action);
  }
  // Postpone the runnable until we know on which thread it needs to run.
  // Assume that the runnable will be successfully placed after attach.
  getRunQueue().post(action);
  return true;
 }

 private HandlerActionQueue getRunQueue() {
  if (mRunQueue == null) {
   mRunQueue = new HandlerActionQueue();
  }
  return mRunQueue;
 }

final static class AttachInfo {
 
  /**
   * A Handler supplied by a view's {@link android.view.ViewRootImpl}. This
   * handler can be used to pump events in the UI events queue.
   */
  @UnsupportedAppUsage
  final Handler mHandler;

 	AttachInfo(IWindowSession session, IWindow window, Display display,
    ViewRootImpl viewRootImpl, Handler handler, Callbacks effectPlayer,
    Context context) {
   ···
   mHandler = handler;
   ···
 	}
 
 	···
}

	@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
 void dispatchAttachedToWindow(AttachInfo info, int visibility) {
  mAttachInfo = info;
  ···
 }

	final ViewRootHandler mHandler = new ViewRootHandler();

 public ViewRootImpl(Context context, Display display, IWindowSession session,
      boolean useSfChoreographer) {
  ···
  mAttachInfo = new View.AttachInfo(mWindowSession, mWindow, display, this, mHandler, this,
    context);
  ···
 }

 private void performTraversals() {
  ···
  if (mFirst) {
   ···
   host.dispatchAttachedToWindow(mAttachInfo, 0);
 	 ···
  }
  ···
  performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
  performLayout(lp, mWidth, mHeight);
  performDraw();
  ···
 }

public class HandlerActionQueue {
 
 private HandlerAction[] mActions;
 private int mCount;

 public void post(Runnable action) {
  postDelayed(action, 0);
 }

 public void postDelayed(Runnable action, long delayMillis) {
  final HandlerAction handlerAction = new HandlerAction(action, delayMillis);
  synchronized (this) {
   if (mActions == null) {
    mActions = new HandlerAction[4];
   }
   mActions = GrowingArrayUtils.append(mActions, mCount, handlerAction);
   mCount  ;
  }
 }

 public void executeActions(Handler handler) {
  synchronized (this) {
   final HandlerAction[] actions = mActions;
   for (int i = 0, count = mCount; i < count; i  ) {
    final HandlerAction handlerAction = actions[i];
    handler.postDelayed(handlerAction.action, handlerAction.delay);
   }

   mActions = null;
   mCount = 0;
  }
 }

 private static class HandlerAction {
  final Runnable action;
  final long delay;

  public HandlerAction(Runnable action, long delay) {
   this.action = action;
   this.delay = delay;
  }

  public boolean matches(Runnable otherAction) {
   return otherAction == null && action == null
     || action != null && action.equals(otherAction);
  }
 }
 
 ···
 
}

	@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
 void dispatchAttachedToWindow(AttachInfo info, int visibility) {
  mAttachInfo = info;
  ···
  // Transfer all pending runnables.
  if (mRunQueue != null) {
   mRunQueue.executeActions(info.mHandler);
   mRunQueue = null;
  }
  ···
 }

	@Override
 public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
   String reason) {
  ···
  //Activity 的 onResume 方法
  final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
  ···
  if (r.window == null && !a.mFinished && willBeVisible) {
   ···
   ViewManager wm = a.getWindowManager();
   if (a.mVisibleFromClient) {
    if (!a.mWindowAdded) {
     a.mWindowAdded = true;
     //重点
     wm.addView(decor, l);
    } else {
     a.onWindowAttributesChanged(l);
    }
   }
  } else if (!willBeVisible) {
   if (localLOGV) Slog.v(TAG, "Launch "   r   " mStartedActivity set");
   r.hideForNow = true;
  }
		···
 }

 @UnsupportedAppUsage
 private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();

	@Override
 public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
  applyDefaultToken(params);
  mGlobal.addView(view, params, mContext.getDisplayNoVerify(), mParentWindow,
    mContext.getUserId());
 }

public void addView(View view, ViewGroup.LayoutParams params,
   Display display, Window parentWindow, int userId) {
  ···
  ViewRootImpl root;
  View panelParentView = null;
  synchronized (mLock) {
   ···
   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 {
    root.setView(view, wparams, panelParentView, userId);
   } catch (RuntimeException e) {
    // BadTokenException or InvalidDisplayException, clean up.
    if (index >= 0) {
     removeViewLocked(index, true);
    }
    throw e;
   }
  }
 }

	//Android API 24 及之后的版本
	public boolean post(Runnable action) {
  final AttachInfo attachInfo = mAttachInfo;
  if (attachInfo != null) {
   return attachInfo.mHandler.post(action);
  }
  // Postpone the runnable until we know on which thread it needs to run.
  // Assume that the runnable will be successfully placed after attach.
  getRunQueue().post(action);
  return true;
 }

	//Android API 23 及之前的版本
	public boolean post(Runnable action) {
  final AttachInfo attachInfo = mAttachInfo;
  if (attachInfo != null) {
   return attachInfo.mHandler.post(action);
  }
  // Assume that post will succeed later
  ViewRootImpl.getRunQueue().post(action);
  return true;
 }

 static final ThreadLocal<RunQueue> sRunQueues = new ThreadLocal<RunQueue>();

	static RunQueue getRunQueue() {
  RunQueue rq = sRunQueues.get();
  if (rq != null) {
   return rq;
  }
  rq = new RunQueue();
  sRunQueues.set(rq);
  return rq;
 }

  val view = View(Context)
  view.post {
   getWidthHeight("view.Post")
  }