轻量级控件SnackBar使用以及源码分析

本篇博客将会给大家带来一个轻量级控件SnackBar，为什么要讲SnackBar？Snackbar:的提出实际上是界于Toast和Dialog的中间产物。因为Toast与Dialog各有一定的不足，使用Toast的时候， 用户无法交互；使用Dialog：用户可以交互，但是体验会打折扣，会阻断用户的连贯性操作；但是使用Snackbar既可以做到轻量级的用户提醒效果，又可以有交互的功能，本博客将会从SnackBar的使用和源码分析两个方面进行介绍。

SnackBar的使用

SnackBar的使用十分简单，其实和Toast的使用方法差不多，我们写一个很简单的例子，来看一下SnackBar的使用，布局上有一个按钮，点击后弹出SnackBar，弹出的逻辑如下，布局代码很简单就不贴了。

public void showSnackBar(View view) {
//LENGTH_INDEFINITE：无穷
Snackbar snackbar = Snackbar.make(view,"您的Wifi已经开启！",Snackbar.LENGTH_INDEFINITE);
snackbar.setAction("确定", new View.OnClickListener() {
@Override
public void onClick(View v) {
Toast.makeText(MainActivity.this, "确定啦", Toast.LENGTH_SHORT).show();
}
});
snackbar.setCallback(new Snackbar.Callback() {
@Override
public void onDismissed(Snackbar snackbar, int event) {
Toast.makeText(MainActivity.this, "SnackBar消失了", Toast.LENGTH_SHORT).show();
}

@Override
public void onShown(Snackbar snackbar) {
Toast.makeText(MainActivity.this, "SnackBar出现了", Toast.LENGTH_SHORT).show();
}
});
snackbar.setActionTextColor(Color.BLUE);
snackbar.show();
}
可以看到上面代码，setAction方法用于给SnackBar设置按钮，setCallback方法用于设置回调，当SnackBar出现时或者消失时都会有相应的回调，同时setActionTextColor方法可以给改变SnackBar中按钮的颜色。



SnackBar的源码分析

SnackBar是通过make方法进行创建的，所以我们首先需要查看SnackBar的make方法

public static Snackbar make(@NonNull View view, @NonNull CharSequence text,
@Duration int duration) {
Snackbar snackbar = new Snackbar(findSuitableParent(view));
snackbar.setText(text);
snackbar.setDuration(duration);
return snackbar;
}
里面有一个findSuitableParent方法，Snackbar内部把view传递给了这个方法，查看该方法的逻辑

private static ViewGroup findSuitableParent(View view) {
ViewGroup fallback = null;
do {
if (view instanceof CoordinatorLayout) {
// We've found a CoordinatorLayout, use it
return (ViewGroup) view;
} else if (view instanceof FrameLayout) {
if (view.getId() == android.R.id.content) {
// If we've hit the decor content view, then we didn't find a CoL in the
// hierarchy, so use it.
return (ViewGroup) view;
} else {
// It's not the content view but we'll use it as our fallback
fallback = (ViewGroup) view;
}
}

if (view != null) {
// Else, we will loop and crawl up the view hierarchy and try to find a parent
final ViewParent parent = view.getParent();
view = parent instanceof View ? (View) parent : null;
}
} while (view != null);

// If we reach here then we didn't find a CoL or a suitable content view so we'll fallback
return fallback;
}

发现这里竟然是一个do while的循环，只要view!= null，就会一直循环下去，里面会对view进行判断，是CoordinatorLayout，则直接返回，如果是FrameLayout，并且当view.getId() == android.R.id.content时候，也将view进行返回，大家都知道R.id.content就是decorView下的content部分，否则就会将这个view赋值给fallback,这个fallback就是一个viewGroup。下面这一句非常关键

if (view != null) {
// Else, we will loop and crawl up the view hierarchy and try to find a parent
final ViewParent parent = view.getParent();
view = parent instanceof View ? (View) parent : null;
}
取出view的Parent并且只要这个parent是View，就将其赋值给我门的view，到这里我们明白了，这个死循环就是为了无限的从传进来的这个view开始无限的向上寻找view的父亲，直到没有父亲为止，最后会返回fallback。然后我们自然会先去查看Snackbar构造函数，看它里面是进行了什么逻辑

private Snackbar(ViewGroup parent) {
mParent = parent;
mContext = parent.getContext();

LayoutInflater inflater = LayoutInflater.from(mContext);
mView = (SnackbarLayout) inflater.inflate(R.layout.design_layout_snackbar, mParent, false);
}

在这里面最重要的一句就是渲染了一个R.layout.design_layout_snackbar的布局，很明显这个布局是系统自带的，很明显在这里已经写死了，所以我们想修改这个SnackBar显然是不行的，而且它还强转成了SnackbarLayout布局，我们可以查看一下这个布局的代码，这个布局在design包的layout下

<view xmlns:android="http://schemas.android.com/apk/res/android"
class="android.support.design.widget.Snackbar$SnackbarLayout"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_gravity="bottom"
style="@style/Widget.Design.Snackbar" />

在这里我们可以学到2点，一是如何引用某个类里面的内部类，就是通过class=“”，第二点就是自定义控件的第二种引用方法，使用View标签，然后内部使用class进行引用。我们看一下SnackbarLayout的代码：

<pre name="code" class="java"><pre name="code" class="java">public SnackbarLayout(Context context, AttributeSet attrs) {
super(context, attrs);
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.SnackbarLayout);
mMaxWidth = a.getDimensionPixelSize(R.styleable.SnackbarLayout_android_maxWidth, -1);
mMaxInlineActionWidth = a.getDimensionPixelSize(
R.styleable.SnackbarLayout_maxActionInlineWidth, -1);
if (a.hasValue(R.styleable.SnackbarLayout_elevation)) {
ViewCompat.setElevation(this, a.getDimensionPixelSize(
R.styleable.SnackbarLayout_elevation, 0));
}
a.recycle();

setClickable(true);

// Now inflate our content. We need to do this manually rather than using an <include>
// in the layout since older versions of the Android do not inflate includes with
// the correct Context.
LayoutInflater.from(context).inflate(R.layout.design_layout_snackbar_include, this);
}

里面会创建一个TypedArray，然后取出里面的属性进行设置，最后会渲染一个布局：R.layout.design_layout_snackbar_include，它被渲染到当前SnackbarLayout之中

<merge xmlns:android="http://schemas.android.com/apk/res/android">

<TextView
android:id="@+id/snackbar_text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_weight="1"
android:paddingTop="@dimen/snackbar_padding_vertical"
android:paddingBottom="@dimen/snackbar_padding_vertical"
android:paddingLeft="@dimen/snackbar_padding_horizontal"
android:paddingRight="@dimen/snackbar_padding_horizontal"
android:textAppearance="@style/TextAppearance.Design.Snackbar.Message"
android:maxLines="@integer/snackbar_text_max_lines"
android:layout_gravity="center_vertical|left|start"
android:ellipsize="end"/>

<TextView
android:id="@+id/snackbar_action"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="@dimen/snackbar_extra_spacing_horizontal"
android:layout_marginStart="@dimen/snackbar_extra_spacing_horizontal"
android:layout_gravity="center_vertical|right|end"
android:background="?attr/selectableItemBackground"
android:paddingTop="@dimen/snackbar_padding_vertical"
android:paddingBottom="@dimen/snackbar_padding_vertical"
android:paddingLeft="@dimen/snackbar_padding_horizontal"
android:paddingRight="@dimen/snackbar_padding_horizontal"
android:visibility="gone"
android:textAppearance="@style/TextAppearance.Design.Snackbar.Action"/>

</merge>

Snackbar的布局里面果然是使用了这个布局，如果我们要改变布局的样式，我们就修改这个文件里面的相关属性就可以了，就比如这里的textAppearance。我们回到Snackbar的构造方法中，同时它还把parent传了进去，  看过LayoutInflater源码的都知道，只有同时满足root不为空，而且attachToRoot为真的时候，root才会去添加这个渲染的temp，也就是我们上面传进来的R.layout.design_layout_snackbar，明显没有添加进mParent中去，那么Snackbar到底是在哪里addView的呢？我们一定要去追寻出这个添加Snackbar的地方。

if (root != null && attachToRoot) {
root.addView(temp, params);
}

我们跟踪mView这个变量，终于在showView方法中，找到了addView的足迹

final void showView() {
if (mView.getParent() == null) {
final ViewGroup.LayoutParams lp = mView.getLayoutParams();

if (lp instanceof CoordinatorLayout.LayoutParams) {
// If our LayoutParams are from a CoordinatorLayout, we'll setup our Behavior

final Behavior behavior = new Behavior();
behavior.setStartAlphaSwipeDistance(0.1f);
behavior.setEndAlphaSwipeDistance(0.6f);
behavior.setSwipeDirection(SwipeDismissBehavior.SWIPE_DIRECTION_START_TO_END);
behavior.setListener(new SwipeDismissBehavior.OnDismissListener() {
@Override
public void onDismiss(View view) {
dispatchDismiss(Callback.DISMISS_EVENT_SWIPE);
}

@Override
public void onDragStateChanged(int state) {
switch (state) {
case SwipeDismissBehavior.STATE_DRAGGING:
case SwipeDismissBehavior.STATE_SETTLING:
// If the view is being dragged or settling, cancel the timeout
SnackbarManager.getInstance().cancelTimeout(mManagerCallback);
break;
case SwipeDismissBehavior.STATE_IDLE:
// If the view has been released and is idle, restore the timeout
SnackbarManager.getInstance().restoreTimeout(mManagerCallback);
break;
}
}
});
((CoordinatorLayout.LayoutParams) lp).setBehavior(behavior);
}

mParent.addView(mView);
}

if (ViewCompat.isLaidOut(mView)) {
// If the view is already laid out, animate it now
animateViewIn();
} else {
// Otherwise, add one of our layout change listeners and animate it in when laid out
mView.setOnLayoutChangeListener(new SnackbarLayout.OnLayoutChangeListener() {
@Override
public void onLayoutChange(View view, int left, int top, int right, int bottom) {
animateViewIn();
mView.setOnLayoutChangeListener(null);
}
});
}
}

这里的代码比较长，我们一点一点进行分析，当mView.getParent() == null时，就是mView已经没有父View的时候，会取出它的LayoutParams，如果这个LayoutParams instanceofCoordinatorLayout.LayoutParams，然后是new一个Behavior，给Behavior设置各种参数以及监听，最后这个Behavior会设置给LayoutParams，然后这个mView最终会添加mParent的ViewGroup容器之中。

当view已经绘制完毕后，会给它设置一个出现的动画animateViewIn，否则会给mView设置布局变化的监听，每一次布局改变都会调用动画，并把监听设置为null，这里设置为null也是非常巧妙的，如果不这样设置，这个监听就会一直回调。

我们粗略查看一下animateViewIn的内部逻辑：

private void animateViewIn() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
ViewCompat.setTranslationY(mView, mView.getHeight());
ViewCompat.animate(mView).translationY(0f)
.setInterpolator(FAST_OUT_SLOW_IN_INTERPOLATOR)
.setDuration(ANIMATION_DURATION)
.setListener(new ViewPropertyAnimatorListenerAdapter() {
@Override
public void onAnimationStart(View view) {
mView.animateChildrenIn(ANIMATION_DURATION - ANIMATION_FADE_DURATION,
ANIMATION_FADE_DURATION);
}

@Override
public void onAnimationEnd(View view) {
if (mCallback != null) {
mCallback.onShown(Snackbar.this);
}
SnackbarManager.getInstance().onShown(mManagerCallback);
}
}).start();
} else {
Animation anim = AnimationUtils.loadAnimation(mView.getContext(), R.anim.design_snackbar_in);
anim.setInterpolator(FAST_OUT_SLOW_IN_INTERPOLATOR);
anim.setDuration(ANIMATION_DURATION);
anim.setAnimationListener(new Animation.AnimationListener() {
@Override
public void onAnimationEnd(Animation animation) {
if (mCallback != null) {
mCallback.onShown(Snackbar.this);
}
SnackbarManager.getInstance().onShown(mManagerCallback);
}

@Override
public void onAnimationStart(Animation animation) {}

@Override
public void onAnimationRepeat(Animation animation) {}
});
mView.startAnimation(anim);
}
}

其实就是进行判断，如果编译的版本大于3.0,就是用属性动画进行一系列的动画设置，否则就是用传统的动画设置。

接着我们查看一下Show方法的逻辑：

public void show() {
SnackbarManager.getInstance().show(mDuration, mManagerCallback);
}

这里用到了SnackbarManager，我们查看一下它的源码，看到getInstance就知道它肯定使用了单例的设计模式

static SnackbarManager getInstance() {
if (sSnackbarManager == null) {
sSnackbarManager = new SnackbarManager();
}
return sSnackbarManager;
}

直接查看show方法

synchronized (mLock) {
if (isCurrentSnackbar(callback)) {
// Means that the callback is already in the queue. We'll just update the duration
mCurrentSnackbar.duration = duration;

// If this is the Snackbar currently being shown, call re-schedule it's
// timeout
mHandler.removeCallbacksAndMessages(mCurrentSnackbar);
scheduleTimeoutLocked(mCurrentSnackbar);
return;
} else if (isNextSnackbar(callback)) {
// We'll just update the duration
mNextSnackbar.duration = duration;
} else {
// Else, we need to create a new record and queue it
mNextSnackbar = new SnackbarRecord(duration, callback);
}

if (mCurrentSnackbar != null && cancelSnackbarLocked(mCurrentSnackbar,
Snackbar.Callback.DISMISS_EVENT_CONSECUTIVE)) {
// If we currently have a Snackbar, try and cancel it and wait in line
return;
} else {
// Clear out the current snackbar
mCurrentSnackbar = null;
// Otherwise, just show it now
showNextSnackbarLocked();
}
}
}

Show方法中会传进来一个callback，这个callback是一个接口，里面有两个抽象方法show和dismiss

interface Callback {
void show();
void dismiss(int event);
}

再回到show方法内部，可以发现首先是加了一个同步锁，这样的目的，我们也可以猜出来，就是防止多次对SnackBar调用show方法，只有当一个SnackBar show完事了之后，下一个SnackBar才能show，也可以看出来SnackbarManager是对SnackBar起到管理作用的。通过isCurrentSnackbar(callback)方法判断传入show方法的callback是否在队列之中，其中有一个SnackbarRecord类型的变量mCurrentSnackbar用于记录时间。

if (isCurrentSnackbar(callback)) {
// Means that the callback is already in the queue. We'll just update the duration
mCurrentSnackbar.duration = duration;

// If this is the Snackbar currently being shown, call re-schedule it's
// timeout
mHandler.removeCallbacksAndMessages(mCurrentSnackbar);
scheduleTimeoutLocked(mCurrentSnackbar);
return;
}

如果当前的Snackbar已经展示完毕，同时它的展示时间已经到了，mHandler就会发送一个消息，移除这个Snackbar的callback,同时调用scheduleTimeoutLocked方法，我们查看一下该方法的内部逻辑：

private void scheduleTimeoutLocked(SnackbarRecord r) {
if (r.duration == Snackbar.LENGTH_INDEFINITE) {
// If we're set to indefinite, we don't want to set a timeout
return;
}

int durationMs = LONG_DURATION_MS;
if (r.duration > 0) {
durationMs = r.duration;
} else if (r.duration == Snackbar.LENGTH_SHORT) {
durationMs = SHORT_DURATION_MS;
}
mHandler.removeCallbacksAndMessages(r);
mHandler.sendMessageDelayed(Message.obtain(mHandler, MSG_TIMEOUT, r), durationMs);
}

首先是根据给SnackBar设置的不同显示时长来进行相应处理，然后是调用mHandler的removeCallbacksAndMessages和sendMessageDelayed方法，进行消息的发送，接着我们可以看一下handler做了什么处理

mHandler = new Handler(Looper.getMainLooper(), new Handler.Callback() {
@Override
public boolean handleMessage(Message message) {
switch (message.what) {
case MSG_TIMEOUT:
handleTimeout((SnackbarRecord) message.obj);
return true;
}
return false;
}
});

当时间到了，会调用handleTimeout方法，SnackbarRecord会被传入这个方法之中

private void handleTimeout(SnackbarRecord record) {
synchronized (mLock) {
if (mCurrentSnackbar == record || mNextSnackbar == record) {
cancelSnackbarLocked(record, Snackbar.Callback.DISMISS_EVENT_TIMEOUT);
}
}
}
在handleTimeout中同样会同步的调用cancelSnackbarLocked方法
private boolean cancelSnackbarLocked(SnackbarRecord record, int event) {
final Callback callback = record.callback.get();
if (callback != null) {
callback.dismiss(event);
return true;
}
return false;
}

这方法内部会从SnackbarRecord内部把callback取出来，如果callback不为空的时候，会调用callback的dismiss方法，回到show方法中，如果调用show方法的是下一个Snackbar就更新一下mNextSnackbar的duration，否则就new 一个SnackbarRecord。

接下来是判定，如果当前有一个Snackbar，就不做处理。

if (mCurrentSnackbar != null && cancelSnackbarLocked(mCurrentSnackbar,
Snackbar.Callback.DISMISS_EVENT_CONSECUTIVE)) {
// If we currently have a Snackbar, try and cancel it and wait in line
return;
} else {
// Clear out the current snackbar
mCurrentSnackbar = null;
// Otherwise, just show it now
showNextSnackbarLocked();
}

如果当前SnackbarRecord不为空，而且其中的callback正在dismiss时，return，否则会清空当前snackbar，然后展示下一个snackbar

private void showNextSnackbarLocked() {
if (mNextSnackbar != null) {
mCurrentSnackbar = mNextSnackbar;
mNextSnackbar = null;

final Callback callback = mCurrentSnackbar.callback.get();
if (callback != null) {
callback.show();
} else {
// The callback doesn't exist any more, clear out the Snackbar
mCurrentSnackbar = null;
}
}
}

showNextSnackbarLocked其中的逻辑也很简单，把下一个SnackbarRecord赋值给当前的，取出里面的callback，不为空时调用show方法。我们再查看一下SnackbarRecord的源码：

private static class SnackbarRecord {
private final WeakReference<Callback> callback;
private int duration;

SnackbarRecord(int duration, Callback callback) {
this.callback = new WeakReference<>(callback);
this.duration = duration;
}

boolean isSnackbar(Callback callback) {
return callback != null && this.callback.get() == callback;
}
}

里面使用了一个弱引用来包裹callback，这里是很值得我们学习的，使用WeakReference可以较好的避免内存泄漏的问题。Callback我们之前说过是一个接口，我们需要找一下它的实现类，既然是在show方法中把callback传进来的，所以我们要寻找一下SnackBarManager的show方法是在哪里调用的。本篇之前我们就看过SnackBar的show方法，里面调用了SnackbarManager的show方法

public void show() {
SnackbarManager.getInstance().show(mDuration, mManagerCallback);
}

该方法内的参数mManagerCallback就是SnackBarManager内部Callback的实现类

private final SnackbarManager.Callback mManagerCallback = new SnackbarManager.Callback() {
@Override
public void show() {
sHandler.sendMessage(sHandler.obtainMessage(MSG_SHOW, Snackbar.this));
}

@Override
public void dismiss(int event) {
sHandler.sendMessage(sHandler.obtainMessage(MSG_DISMISS, event, 0, Snackbar.this));
}
};

可以发现，其内部实现show与dismiss方法，使用sHandler发送不同的消息，查看sHandler的实现

sHandler = new Handler(Looper.getMainLooper(), new Handler.Callback() {
@Override
public boolean handleMessage(Message message) {
switch (message.what) {
case MSG_SHOW:
((Snackbar) message.obj).showView();
return true;
case MSG_DISMISS:
((Snackbar) message.obj).hideView(message.arg1);
return true;
}
return false;
}
});

当message为MSG_SHOW时，会调用Snackbar的showView方法，当message为MSG_DISMISS时，会调用Snackbar的hideView，showView方法内部逻辑我们之前已经分析过了，再看一下hideView方法：

final void hideView(int event) {
if (mView.getVisibility() != View.VISIBLE || isBeingDragged()) {
onViewHidden(event);
} else {
animateViewOut(event);
}
}

hideView方法内调用onViewHidden方法：

private void onViewHidden(int event) {
// First remove the view from the parent
mParent.removeView(mView);
// Now call the dismiss listener (if available)
if (mCallback != null) {
mCallback.onDismissed(this, event);
}
// Finally, tell the SnackbarManager that it has been dismissed
SnackbarManager.getInstance().onDismissed(mManagerCallback);
}

首先mParent会把mView进行移除，然后如果mCallback!= null，会调用mCallback的onDismissed方法，最后调用SnackbarManager的onDismissed的方法，将callback移除出队列，到这里SnackBar和SnackbarManager的源码我们就基本分析完毕了。