概述
Window表示一个窗口的概念，它是一个抽象类，它的具体实现类是PhoneWindow。
WindowManager是外界访问Window的入口，Window的具体实现位于WindowManagerService中。
WindowManager和WindowManagerService的交互其实是一个IPC过程。Android中所有视图都是通过Window来呈现的，无论是Activity，Dialog还是Toast，它们的视图都是附加在Window上的，因此Window是View的直接管理者。从事件分发的流程可以知道，触摸事件是由Window传递给DecorView的，Activity的setContentView()在底层也是通过Window来完成的。
WindowManager.LayoutParams
为了分析Window的工作机制，我们先了解WindowManager.LayoutParams，如下：
mWindowManager = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
mFloatingButton = new Button(this);
mFloatingButton.setText("click me");
mLayoutParams = new WindowManager.LayoutParams(
LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, 0, 0,
PixelFormat.TRANSPARENT);
mLayoutParams.flags = LayoutParams.FLAG_NOT_TOUCH_MODAL
| LayoutParams.FLAG_NOT_FOCUSABLE
| LayoutParams.FLAG_SHOW_WHEN_LOCKED;
mLayoutParams.type = LayoutParams.TYPE_SYSTEM_ERROR;
mLayoutParams.gravity = Gravity.LEFT | Gravity.TOP;
mLayoutParams.x = 100;
mLayoutParams.y = 300;
mFloatingButton.setOnTouchListener(this);
mWindowManager.addView(mFloatingButton, mLayoutParams);上述代码将一个Button添加到频幕坐标(100,300)的位置上。其中WindowManager.LayoutParams的两个参数flags和type比较重要。
flag
flag表示Window的属性，可以控制Window的显示特性，下面介绍比较常用的几个：
FLAG_NOT_FOCUSABLE
设置之后Window不会获取焦点，也不会接收各种输入事件，最终事件会传递给在其下面的可获取焦点的Window，这个flag同时会启用 FLAG_NOT_TOUCH_MODAL flag。FLAG_NOT_TOUCH_MODAL
这个flag简而言之就是说，当前Window区域以外的点击事件传递给下层Window，当前Window区域以内的点击事件自己处理。- FLAG_SHOW_WHEN_LOCKED
一个特殊的flag，使得Window可以在锁屏状态下显示，它使得Window比KeyGuard或其他锁屏界面具有更高的层级。
type
type表示Window的类型，Window有三种类型，分别是应用Window，子Window和系统Window。
应用类Window对应着一个Activity。子Window不能单独存在，它需要附属在特定的父Window中，比如Dialog就是一个子Window。系统Window是需要声明权限才能创建的Window，比如Toast和系统状态栏这些都是系统Window。
Window是分层的，每个Window都有对应的z-ordered，层级大的会覆盖在层级小的Window上。在三类Window中，应用Window的层级范围是1~99，子Window的层级范围是1000~1999，系统Window的层级范围是2000~2999。很显然系统Window的层级是最大的，而且系统层级有很多值，一般我们可以选用TYPE_SYSTEM_ERROR或者TYPE_SYSTEM_OVERLAY，另外重要的是要记得在清单文件中声明权限。
Window的内部机制
Window是一个抽象的概念，每一个Window都对应着一个View和一个ViewRootImpl，Window和View通过ViewRootImpl来建立联系，因此Window并不是实际存在的，它是以View的形式存在，这点从WindowManager的定义可以看出。WindowManager所提供的功能很简单，常用的只有三个方法，即添加View、更新View和删除View，这三个方法定义在ViewManager中，而WindowManager继承了ViewManager。
public interface ViewManager
{
/**
* Assign the passed LayoutParams to the passed View and add the view to the window.
* <p>Throws {@link android.view.WindowManager.BadTokenException} for certain programming
* errors, such as adding a second view to a window without removing the first view.
* <p>Throws {@link android.view.WindowManager.InvalidDisplayException} if the window is on a
* secondary {@link Display} and the specified display can't be found
* (see {@link android.app.Presentation}).
* @param view The view to be added to this window.
* @param params The LayoutParams to assign to view.
*/
public void addView(View view, ViewGroup.LayoutParams params);
public void updateViewLayout(View view, ViewGroup.LayoutParams params);
public void removeView(View view);
}Window的添加过程
Window的添加过程通过WindowManager的addView来实现，WindowManager是一个接口，它的真正实现类是WindowManagerImpl。然而WindowManagerImpl并没有直接实现Window的三大操作，而是全部交给WindowManagerGlobal来处理：
@Override
public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
applyDefaultToken(params);
mGlobal.addView(view, params, mDisplay, mParentWindow);
}
@Override
public void updateViewLayout(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
applyDefaultToken(params);
mGlobal.updateViewLayout(view, params);
}
@Override
public void removeView(View view) {
mGlobal.removeView(view, false);
}那WindowManagerGlobal是什么呢？
首先看到WindowManagerImpl中：
private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();然后再看WindowManagerGlobal中：
public static WindowManagerGlobal getInstance() {
synchronized (WindowManagerGlobal.class) {
if (sDefaultWindowManager == null) {
sDefaultWindowManager = new WindowManagerGlobal();
}
return sDefaultWindowManager;
}
}可以看到WindowManagerGlobal中获取实例的方法是单例模式，所以其实多个WindowManagerImpl拥有同一个WindowManagerGlobal。
WindowManagerImpl这种工作模式是典型的桥接模式，将所有的操作委托给WindowManagerGlobal来实现。
WindowManagerGlobal的addView()：
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 {
root.setView(view, wparams, panelParentView);
} catch (RuntimeException e) {
// BadTokenException or InvalidDisplayException, clean up.
synchronized (mLock) {
final int index = findViewLocked(view, false);
if (index >= 0) {
removeViewLocked(index, true);
}
}
throw e;
}
}其中第一步对参数的合法性进行了校验，如果是子Window还需要调整布局参数。
第二步创建ViewRootImpl并将信息存储到集合中：
private final ArrayList<View> mViews = new ArrayList<View>();
private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();
private final ArrayList<WindowManager.LayoutParams> mParams =
new ArrayList<WindowManager.LayoutParams>();我们看到这是WindowManagerGlobal中对三个集合的声明，mViews 存储的是所有Window对应的View，mRoots 存储的是所有Window对应的ViewRootImpl，mParams 存储的是所有Window对应的布局参数。
第三步通过ViewRootImpl来更新界面并完成Window的添加。这个步骤由ViewRootImpl的setView()来完成，setView()内部调用requestLayout()来完成异步刷新请求。接着会通过WindowSession最终来完成Window的添加过程，如下是setView()的部分代码:
try {
mOrigWindowType = mWindowAttributes.type;
mAttachInfo.mRecomputeGlobalAttributes = true;
collectViewAttributes();
res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
getHostVisibility(), mDisplay.getDisplayId(),
mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
mAttachInfo.mOutsets, mInputChannel);
} catch (RemoteException e) {
mAdded = false;
mView = null;
mAttachInfo.mRootView = null;
mInputChannel = null;
mFallbackEventHandler.setView(null);
unscheduleTraversals();
setAccessibilityFocus(null, null);
throw new RuntimeException("Adding window failed", e);
} finally {
if (restore) {
attrs.restore();
}
}mWindowSession的类型是IWindowSession，它是一个Binder对象，真正的实现类是Session，也就是Window的添加过程是一次IPC调用。
Session内部通过WindowManagerService来实现Window的添加，代码如下：
@Override
public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
int viewVisibility, int displayId, Rect outContentInsets, Rect outStableInsets,
Rect outOutsets, InputChannel outInputChannel) {
return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId,
outContentInsets, outStableInsets, outOutsets, outInputChannel);
}如此一来，Window的添加请求就交给WindowManagerService去处理了，在WindowManagerService内部会为每一个应用保留一个单独的Session。具体Window在WindowManagerService内部怎么添加的，这里就不做分析了。
Window的删除过程
Window的删除过程和添加过程一样，通过WindowManagerImpl调用WindowManagerGlobal的removeView()来实现：
public void removeView(View view, boolean immediate) {
if (view == null) {
throw new IllegalArgumentException("view must not be null");
}
synchronized (mLock) {
int index = findViewLocked(view, true);
View curView = mRoots.get(index).getView();
removeViewLocked(index, immediate);
if (curView == view) {
return;
}
throw new IllegalStateException("Calling with view " + view
+ " but the ViewAncestor is attached to " + curView);
}
}首先通过findViewLocked()来查找待删除的View的索引，然后再调用removeViewLocked()来做进一步的删除，如下：
private void removeViewLocked(int index, boolean immediate) {
ViewRootImpl root = mRoots.get(index);
View view = root.getView();
if (view != null) {
InputMethodManager imm = InputMethodManager.getInstance();
if (imm != null) {
imm.windowDismissed(mViews.get(index).getWindowToken());
}
}
boolean deferred = root.die(immediate);
if (view != null) {
view.assignParent(null);
if (deferred) {
mDyingViews.add(view);
}
}
}removeViewLocked()是通过ViewRootImpl来完成删除操作的。WindowManager中提供了两种删除接口，removeView()和removeViewImmediate()，他们分表表示异步删除和同步删除。具体的删除操作由ViewRootImpl的die()来完成：
boolean die(boolean immediate) {
// Make sure we do execute immediately if we are in the middle of a traversal or the damage
// done by dispatchDetachedFromWindow will cause havoc on return.
if (immediate && !mIsInTraversal) {
doDie();
return false;
}
if (!mIsDrawing) {
destroyHardwareRenderer();
} else {
Log.e(TAG, "Attempting to destroy the window while drawing!\n" +
" window=" + this + ", title=" + mWindowAttributes.getTitle());
}
mHandler.sendEmptyMessage(MSG_DIE);
return true;
}在异步删除的情况下，die()只是发送了一个请求删除的消息就返回了，这时候View还没有完成删除操作，所以最后将它添加到mDyingViews中，mDyingViews表示待删除的View的集合。如果是同步删除，不发送消息就直接调用dodie()：
void doDie() {
checkThread();
if (LOCAL_LOGV) Log.v(TAG, "DIE in " + this + " of " + mSurface);
synchronized (this) {
if (mRemoved) {
return;
}
mRemoved = true;
if (mAdded) {
dispatchDetachedFromWindow();
}
if (mAdded && !mFirst) {
destroyHardwareRenderer();
if (mView != null) {
int viewVisibility = mView.getVisibility();
boolean viewVisibilityChanged = mViewVisibility != viewVisibility;
if (mWindowAttributesChanged || viewVisibilityChanged) {
// If layout params have been changed, first give them
// to the window manager to make sure it has the correct
// animation info.
try {
if ((relayoutWindow(mWindowAttributes, viewVisibility, false)
& WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME) != 0) {
mWindowSession.finishDrawing(mWindow);
}
} catch (RemoteException e) {
}
}
mSurface.release();
}
}
mAdded = false;
}
WindowManagerGlobal.getInstance().doRemoveView(this);
}在dodie()内部会调用dispatchDetachedFromWindow()，真正删除View的逻辑就在dispatchDetachedFromWindow()中：
void dispatchDetachedFromWindow() {
if (mView != null && mView.mAttachInfo != null) {
mAttachInfo.mTreeObserver.dispatchOnWindowAttachedChange(false);
mView.dispatchDetachedFromWindow();
}
mAccessibilityInteractionConnectionManager.ensureNoConnection();
mAccessibilityManager.removeAccessibilityStateChangeListener(
mAccessibilityInteractionConnectionManager);
mAccessibilityManager.removeHighTextContrastStateChangeListener(
mHighContrastTextManager);
removeSendWindowContentChangedCallback();
destroyHardwareRenderer();
setAccessibilityFocus(null, null);
mView.assignParent(null);
mView = null;
mAttachInfo.mRootView = null;
mSurface.release();
if (mInputQueueCallback != null && mInputQueue != null) {
mInputQueueCallback.onInputQueueDestroyed(mInputQueue);
mInputQueue.dispose();
mInputQueueCallback = null;
mInputQueue = null;
}
if (mInputEventReceiver != null) {
mInputEventReceiver.dispose();
mInputEventReceiver = null;
}
try {
mWindowSession.remove(mWindow);
} catch (RemoteException e) {
}
// Dispose the input channel after removing the window so the Window Manager
// doesn't interpret the input channel being closed as an abnormal termination.
if (mInputChannel != null) {
mInputChannel.dispose();
mInputChannel = null;
}
mDisplayManager.unregisterDisplayListener(mDisplayListener);
unscheduleTraversals();
}dispatchDetachedFromWindow()主要做几件事情：
- 垃圾回收相关操作，比如清除数据和消息，移除回调。
- 通过Session的remove()删除Window，这同样是一个IPC过程，最终会调用WindowManagerService的removeWindow()。
- 调用View的dispatchDetachedFromWindow()，进而调用View的onDetachedFromWindow()，onDetachedFromWindowInternal()。
onDetachedFromWindow()对于大家来说一定不陌生，我们可以在这个方法内部做一些资源回收工作，比如终止动画、停止线程等。
最后再调用WindowManagerGlobal的doRemoveView()方法刷新数据，包括mRoots、mParams、mViews和mDyingViews，将当前Window所关联的对象从集合中删除。
Window的更新过程
首先看WindowManagerGlobal的updateViewLayout()：
public void updateViewLayout(View view, ViewGroup.LayoutParams params) {
if (view == null) {
throw new IllegalArgumentException("view must not be null");
}
if (!(params instanceof WindowManager.LayoutParams)) {
throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
}
final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;
view.setLayoutParams(wparams);
synchronized (mLock) {
int index = findViewLocked(view, true);
ViewRootImpl root = mRoots.get(index);
mParams.remove(index);
mParams.add(index, wparams);
root.setLayoutParams(wparams, false);
}
}updateViewLayout()做的事情就比较简单了，首先先更新View的LayoutParams，接着更新ViewRootImpl的LayoutParams。ViewRootImpl会在setLayoutParams()中调用scheduleTraversals()来对View重新布局重绘。除此之外ViewRootImpl还会通过WindowSession来更新Window的视图，这个过程最终由WindowManagerService的relayoutWindow()来具体实现，这同样是一个IPC过程。
Window的创建过程
Activity的Window创建过程
见Activity的Window创建及DecorView的添加(Android开发艺术探索学习笔记)
Dialog的Window创建过程
Dialog的Window创建过程和Activity的类似。
首先创建Window，通过Dialog的构造方法：
Dialog(@NonNull Context context, @StyleRes int themeResId, boolean createContextThemeWrapper) {
if (createContextThemeWrapper) {
if (themeResId == 0) {
final TypedValue outValue = new TypedValue();
context.getTheme().resolveAttribute(R.attr.dialogTheme, outValue, true);
themeResId = outValue.resourceId;
}
mContext = new ContextThemeWrapper(context, themeResId);
} else {
mContext = context;
}
mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
final Window w = new PhoneWindow(mContext);
mWindow = w;
w.setCallback(this);
w.setOnWindowDismissedCallback(this);
w.setWindowManager(mWindowManager, null, null);
w.setGravity(Gravity.CENTER);
mListenersHandler = new ListenersHandler(this);
}然后初始化DecorView，并将Dialog的视图添加到DecorView中：
public void setContentView(@LayoutRes int layoutResID) {
mWindow.setContentView(layoutResID);
}最后将DecorView添加到Window中并显示：
public void show() {
……
mWindowManager.addView(mDecor, l);
mShowing = true;
……
}从上面三个步骤，可以看出Dialog的Window创建过程和Activity的基本一样。
普通Dialog有一个特殊之处，那就是构造方法必须传入Activity的Context，如果采用Application的就会报错，因为需要应用的token。
除此之外，系统的Window比较特殊，可以不需要应用的token。所以要将Dialog对应的Window指定为系统层级：
dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ERROR);并且在清单文件中声明权限：
<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>Toast的Window创建过程
Toast和Dialog不同，它的工作过程稍显复杂。首先Toast也是基于Window来实现的，但是由于Toast具有定时取消这一功能，所以系统采用了Handler。在Toast内部有两个IPC过程，一个是Toast访问NotificationManagerService，第二个是NotificationManagerService回调Toast里的TN接口。
Toast提供了show()和cancel()分别用来显示和隐藏Toast，它们内部是一个IPC过程：
public void show() {
if (mNextView == null) {
throw new RuntimeException("setView must have been called");
}
INotificationManager service = getService();
String pkg = mContext.getOpPackageName();
TN tn = mTN;
tn.mNextView = mNextView;
try {
service.enqueueToast(pkg, tn, mDuration);
} catch (RemoteException e) {
// Empty
}
}
public void cancel() {
mTN.hide();
try {
getService().cancelToast(mContext.getPackageName(), mTN);
} catch (RemoteException e) {
// Empty
}
}从上面的代码来看，显示和隐藏Toast都要通过NMS来实现，由于NMS运行在系统进程中，所以只能通过远程调用的方式来显示和隐藏Toast。TN是一个Binder类，在Toast和NMS进行IPC的过程中，当MNS处理Toast的请求时会跨进程回调TN中的方法，这个时候由于TN运行在Binder线程池当中，所以需要通过Handler将其切换到当前线程中。注意由于使用了Handler，这意味着Toast无法在没有Looper的线程中弹出。
Toast的show()中调用了NMS的enqueueToast()，第一参数代表当前应用的包名，第二个参数代表远程回调，第三个参数代表Toast显示的时长：
public void enqueueToast(String pkg, ITransientNotification callback, int duration)
{
if (DBG) {
Slog.i(TAG, "enqueueToast pkg=" + pkg + " callback=" + callback
+ " duration=" + duration);
}
if (pkg == null || callback == null) {
Slog.e(TAG, "Not doing toast. pkg=" + pkg + " callback=" + callback);
return ;
}
final boolean isSystemToast = isCallerSystem() || ("android".equals(pkg));
if (ENABLE_BLOCKED_TOASTS && !noteNotificationOp(pkg, Binder.getCallingUid())) {
if (!isSystemToast) {
Slog.e(TAG, "Suppressing toast from package " + pkg + " by user request.");
return;
}
}
synchronized (mToastQueue) {
int callingPid = Binder.getCallingPid();
long callingId = Binder.clearCallingIdentity();
try {
ToastRecord record;
int index = indexOfToastLocked(pkg, callback);
// If it's already in the queue, we update it in place, we don't
// move it to the end of the queue.
if (index >= 0) {
record = mToastQueue.get(index);
record.update(duration);
} else {
// Limit the number of toasts that any given package except the android
// package can enqueue. Prevents DOS attacks and deals with leaks.
if (!isSystemToast) {
int count = 0;
final int N = mToastQueue.size();
for (int i=0; i<N; i++) {
final ToastRecord r = mToastQueue.get(i);
if (r.pkg.equals(pkg)) {
count++;
if (count >= MAX_PACKAGE_NOTIFICATIONS) {
Slog.e(TAG, "Package has already posted " + count
+ " toasts. Not showing more. Package=" + pkg);
return;
}
}
}
}
record = new ToastRecord(callingPid, pkg, callback, duration);
mToastQueue.add(record);
index = mToastQueue.size() - 1;
keepProcessAliveLocked(callingPid);
}
// If it's at index 0, it's the current toast. It doesn't matter if it's
// new or just been updated. Call back and tell it to show itself.
// If the callback fails, this will remove it from the list, so don't
// assume that it's valid after this.
if (index == 0) {
showNextToastLocked();
}
} finally {
Binder.restoreCallingIdentity(callingId);
}
}
}在enqueueToast()中，Toast请求被封装成ToastRecord对象并被添加到一个名为mToastQueue的队列中。并且mToastQueue最多能存下50个ToastRecord，这是由MAX_PACKAGE_NOTIFICATIONS决定的，防止破坏性的连续请求。之后通过showNextToastLocked()来显示当前的Toast：
void showNextToastLocked() {
ToastRecord record = mToastQueue.get(0);
while (record != null) {
if (DBG) Slog.d(TAG, "Show pkg=" + record.pkg + " callback=" + record.callback);
try {
record.callback.show();
scheduleTimeoutLocked(record);
return;
} catch (RemoteException e) {
Slog.w(TAG, "Object died trying to show notification " + record.callback
+ " in package " + record.pkg);
// remove it from the list and let the process die
int index = mToastQueue.indexOf(record);
if (index >= 0) {
mToastQueue.remove(index);
}
keepProcessAliveLocked(record.pid);
if (mToastQueue.size() > 0) {
record = mToastQueue.get(0);
} else {
record = null;
}
}
}
}从以上代码可以看到，Toast的显示是由ToastRecord的callback来完成的，这个callback实际上就是Toast中的TN对象的远程Binder，通过callback访问TN中的方法需要跨进程来完成。Toast显示以后，NMS还会通过scheduleTimeoutLocked()来发送一个延时消息，具体的延时取决于Toast的时长：
private void scheduleTimeoutLocked(ToastRecord r)
{
mHandler.removeCallbacksAndMessages(r);
Message m = Message.obtain(mHandler, MESSAGE_TIMEOUT, r);
long delay = r.duration == Toast.LENGTH_LONG ? LONG_DELAY : SHORT_DELAY;
mHandler.sendMessageDelayed(m, delay);
}NMS会通过cancelToastLocked()方法来隐藏Toast并将对应的ToastRecord从mToastQueue中移除。Toast的隐藏也是通过ToastRecord的callback来完成的，同样和Toast的显示一样也是一次IPC过程。
通过上面的分析大家知道，Toast的显示和隐藏实际上是通过Toast中的TN这个类来实现的，它有两个方法show()和hide()：
@Override
public void show() {
if (localLOGV) Log.v(TAG, "SHOW: " + this);
mHandler.post(mShow);
}
/**
* schedule handleHide into the right thread
*/
@Override
public void hide() {
if (localLOGV) Log.v(TAG, "HIDE: " + this);
mHandler.post(mHide);
}由于这两个方法被NMS以跨进程的方式调用，因此它们运行在Binder线程池中，为了执行切换到Toast发起请求的线程中，在它们的内部使用了Handler。
以上代码中mShow和mHide是两个Runnable，内部分别调用了handleShow()和handleHide()：
public void handleShow() {
……
mWM = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
……
mWM.addView(mView, mParams);
……
}
public void handleHide() {
if (localLOGV) Log.v(TAG, "HANDLE HIDE: " + this + " mView=" + mView);
if (mView != null) {
// note: checking parent() just to make sure the view has
// been added... i have seen cases where we get here when
// the view isn't yet added, so let's try not to crash.
if (mView.getParent() != null) {
if (localLOGV) Log.v(TAG, "REMOVE! " + mView + " in " + this);
mWM.removeView(mView);
}
mView = null;
}
}以上两个方法就是Toast正真完成显示和隐藏的地方。
688
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
