最普通不过的Toast我们进场使用，有没有想过这样的问题，可不可以在显示的时候取消Toast的显示,Toast到底是被添加到哪个Window的，WindowManager是如何添加Toast的，在添加Toast的时候总共有几个WindowManager参与，参与Toast显示的WindowManager是如何产生的……
好吧，想到这么多的时候，我感觉头绪有点乱，还是从最简单的开始吧，先看下Toast的显示吧。
最常用的方式如下：
Toast.makeText(context, "test", Toast.LENGTH_SHORT).show();
跟踪下代码：
public static Toast makeText(@NonNull Context context, @Nullable Looper looper,
@NonNull CharSequence text, @Duration int duration) {
Toast result = new Toast(context, looper);
LayoutInflater inflate = (LayoutInflater)
context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View v = inflate.inflate(com.android.internal.R.layout.transient_notification, null);
TextView tv = (TextView)v.findViewById(com.android.internal.R.id.message);
tv.setText(text);
result.mNextView = v;
result.mDuration = duration;
return result;
}
Toast的对象和普通的对象没有什么区别，先新建一个对象，然后给Toast对象设置一个view，再设置Toast的显示时常，然后makeText就直接返回，接下来就需要调用show方法，看下show方法
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
}
}
show方法是一个跨进程调用，最终会调用NotificationManagerService的enqueueToast方法，这里有一个TN类型的tn对象，这个对象的作用是接收来自NotificationManagerService的回调，后面会对这个对象进行解释，接下来进入NotificationManagerService，看下它是如何处理Toast。
@Override
public void enqueueToast(String pkg, ITransientNotification callback, int duration)
{
......
synchronized (mToastQueue) {
......
try {
ToastRecord record;
int index;
if (!isSystemToast) {
index = indexOfToastPackageLocked(pkg);
} else {
......
}
// If the package already has a toast, we update its toast
// in the queue, we don't move it to the end of the queue.
if (index >= 0) {
record = mToastQueue.get(index);
record.update(duration);
record.update(callback);
} else {
Binder token = new Binder();
mWindowManagerInternal.addWindowToken(token, TYPE_TOAST, DEFAULT_DISPLAY);
record = new ToastRecord(callingPid, pkg, callback, duration, token);
mToastQueue.add(record);
index = mToastQueue.size() - 1;
}
......
// 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 {
......
}
}
}
最终函数走进了showNextToast的调用。
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(record.token);
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);
}
keepProcessAliveIfNeededLocked(record.pid);
if (mToastQueue.size() > 0) {
record = mToastQueue.get(0);
} else {
record = null;
}
}
}
}
showNextToast方法再mToastQueue上进行循环，如果找到待显示的Toast则调用record.callback.show函数进行显示，并执行scheduleTimeoutLocked函数。
record.callback.show函数后面会重点说明，先理解一下scheduleTimeoutLocked函数
scheduleTimeoutLocked
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);
}
返现scheduleTimeoutLocked函数还是很简单的，就是根据显示时的时长去触发一个message。这个地方有一个Toast使用经常会遇到的问题，直接使用Toast.makeText是无法控制Toast的显示时长的，因为系统处理的时候仅仅设置了LONG_DELAY和SHORT_DELAY，究竟是不是这个原因，再往下看。
代码段1
public void handleMessage(Message msg)
{
switch (msg.what)
{
case MESSAGE_TIMEOUT:
handleTimeout((ToastRecord)msg.obj);
break;
......
}
}
代码段2
private void handleTimeout(ToastRecord record)
{
if (DBG) Slog.d(TAG, "Timeout pkg=" + record.pkg + " callback=" + record.callback);
synchronized (mToastQueue) {
int index = indexOfToastLocked(record.pkg, record.callback);
if (index >= 0) {
cancelToastLocked(index);
}
}
}
代码段3
void cancelToastLocked(int index) {
ToastRecord record = mToastQueue.get(index);
try {
record.callback.hide();
} catch (RemoteException e) {
Slog.w(TAG, "Object died trying to hide notification " + record.callback
+ " in package " + record.pkg);
// don't worry about this, we're about to remove it from
// the list anyway
}
ToastRecord lastToast = mToastQueue.remove(index);
mWindowManagerInternal.removeWindowToken(lastToast.token, true, DEFAULT_DISPLAY);
keepProcessAliveIfNeededLocked(record.pid);
if (mToastQueue.size() > 0) {
// Show the next one. If the callback fails, this will remove
// it from the list, so don't assume that the list hasn't changed
// after this point.
showNextToastLocked();
}
}
代码段2是MESSAGE_TIMEOUT的具体处理逻辑，可以看到，系统执行cancelToastLocked方法取消了Toast的显示，如果mToastQueue中还存在未显示的Toast，则继续执行显示。看来直接使用Toast.makeText无法控制Toast的显示时长的原因就是这儿了。
record.callback.show
这个方法是Toast显示的核心，还记得record的callback指的是什么吗，不记得的同学往前面看即可。callback指的是toast的内部类的TN类型的对象，因此show方法调用的也是TN的show函数。
public void show(IBinder windowToken) {
if (localLOGV) Log.v(TAG, "SHOW: " + this);
mHandler.obtainMessage(SHOW, windowToken).sendToTarget();
}
show函数很好理解，但是windowToken从哪来的呢？可以看下前面enqueueToast函数的实现，为了实现NotificationServiceManager的跨进程调用，在封装ToastRecord对象时新建了一个binder对象作为windowToken，继续…
public void handleShow(IBinder windowToken) {
.....
if (mHandler.hasMessages(CANCEL) || mHandler.hasMessages(HIDE)) {
return;
}
if (mView != mNextView) {
// 删除之前显示的Toast
handleHide();
mView = mNextView;
Context context = mView.getContext().getApplicationContext();
String packageName = mView.getContext().getOpPackageName();
if (context == null) {
context = mView.getContext();
}
mWM = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
// We can resolve the Gravity here by using the Locale for getting
// the layout direction
final Configuration config = mView.getContext().getResources().getConfiguration();
final int gravity = Gravity.getAbsoluteGravity(mGravity, config.getLayoutDirection());
mParams.gravity = gravity;
if ((gravity & Gravity.HORIZONTAL_GRAVITY_MASK) == Gravity.FILL_HORIZONTAL) {
mParams.horizontalWeight = 1.0f;
}
if ((gravity & Gravity.VERTICAL_GRAVITY_MASK) == Gravity.FILL_VERTICAL) {
mParams.verticalWeight = 1.0f;
}
mParams.x = mX;
mParams.y = mY;
mParams.verticalMargin = mVerticalMargin;
mParams.horizontalMargin = mHorizontalMargin;
mParams.packageName = packageName;
mParams.hideTimeoutMilliseconds = mDuration ==
Toast.LENGTH_LONG ? LONG_DURATION_TIMEOUT : SHORT_DURATION_TIMEOUT;
mParams.token = windowToken;
if (mView.getParent() != null) {
if (localLOGV) Log.v(TAG, "REMOVE! " + mView + " in " + this);
mWM.removeView(mView);
}
if (localLOGV) Log.v(TAG, "ADD! " + mView + " in " + this);
// Since the notification manager service cancels the token right
// after it notifies us to cancel the toast there is an inherent
// race and we may attempt to add a window after the token has been
// invalidated. Let us hedge against that.
try {
mWM.addView(mView, mParams);
trySendAccessibilityEvent();
} catch (WindowManager.BadTokenException e) {
/* ignore */
}
}
}
代码看的比较长，实际上逻辑比较简单，就是将Toast的view添加到Windowmanager。具体的流程：判断当前还有没有正在显示的Toast，如果有则先取消，然后给准备显示的Toast设置显示位置，最后将Toast显示出来。