一、顶部标题显示和隐藏渐变效果

在吸顶效果前，先记录一个简单的标题渐变效果。

1.1 简单显示和隐藏

监听滚动,只控制显示和隐藏,布局初始隐藏,不用设置渐变度。
iShot2020-09-1323.53.28.gif

1.2 渐变效果

监听滚动,通过设置alpha(范围0~1),实现布局渐变。
iShot2020-09-1323.56.38.gif

1.3 通过设置背景颜色实现

监听滚动,通过设置背景颜色alpha(范围0~255),实现布局渐变。
iShot2020-09-1323.59.58.gif

1.4 实现方式如下

    1. xml 布局 ``` <?xml version=”1.0” encoding=”utf-8”?>

  1. <RelativeLayout
  2.     android:id="@+id/rl_scroll_title_titleWhite"
  3.     android:layout_width="match_parent"
  4.     android:layout_height="45dp"
  5.     app:layout_constraintTop_toTopOf="parent"
  6.     android:background="@color/white"
  7.     android:visibility="gone"
  8.     >
  10.     <ImageView
  11.         android:layout_width="wrap_content"
  12.         android:layout_height="match_parent"
  13.         android:src="@mipmap/ic_navigation_back_white"
  14.         android:tint="@color/red"/>
  15.     <TextView
  16.         android:layout_width="wrap_content"
  17.         android:layout_height="wrap_content"
  18.         android:text="标题部分"
  19.         android:layout_centerInParent="true"/>
  21. </RelativeLayout>

  2. - 2. activity 部分，所有实现都在这里面
  4. 重点关注这三个方法就可以了。
  5. > 1.监听滚动,只控制显示和隐藏,布局初始隐藏,不用设置渐变度scrollListener()
  6. > 2.监听滚动,通过设置alpha(范围0~1),实现布局渐变scrollListener2()
  7. > 3,监听滚动,通过设置背景颜色alpha(范围0~255),实现布局渐变scrollListener3()

class ScrollTitleActivity : BaseActivity(R.layout.activity_scroll_title) { override fun initData() {

  1. }
  2. private var hasMeasured = false
  3. override fun initEvent() {
  4.     //onCreate中获取控件的高度,参考: https://blog.csdn.net/wangzhongshun/article/details/105196366
  5.     //方法一

// tv_scroll_title_one.post { // val height = tv_scroll_title_one.height // LogUtils.e(“height=$height”)//height=750 // } //方法二 tv_scroll_title_one.viewTreeObserver.addOnPreDrawListener { //不做处理会一直重复调用,调用一次就够了 if (!hasMeasured){ val height = tv_scroll_title_one.height LogUtils.e(“height=$height”)//height=750 hasMeasured = true } true//返回true为可用状态 } } override fun onWindowFocusChanged(hasFocus: Boolean) { super.onWindowFocusChanged(hasFocus) //方法三,会重复调用,当Activity的窗口得到焦点和失去焦点时均会被调用一次，如果频繁地进行onResume和onPause，那么onWindowFocusChanged也会被频繁地调用，不太适合处理一些复杂的业务逻辑 val height = tv_scroll_title_one.height LogUtils.e(“height=$height”) }

  1. @RequiresApi(Build.VERSION_CODES.M)
  2. override fun initInterface() {
  3.     //1.监听滚动,只控制显示和隐藏,布局初始隐藏,不用设置渐变度
  4.     //scrollListener()
  5.     //2.监听滚动,通过设置alpha(范围0~1),实现布局渐变
  6.     //scrollListener2()
  7.     //3,监听滚动,通过设置背景颜色alpha(范围0~255),实现布局渐变
  8.     //scrollListener3()
  9. }
  11. @RequiresApi(Build.VERSION_CODES.M)
  12. private fun scrollListener3() {
  13.     //初始进入隐藏,Color.argb转换工具https://www.wanandroid.com/tools/color
  14.     rl_scroll_title_titleWhite.visibility = View.GONE
  15.     rl_scroll_title_title.visibility = View.VISIBLE
  16.     sv_scroll_title_outer.setOnScrollChangeListener { view, i, i2, i3, i4 ->
  17.         val height = rl_scroll_title_title.height
  18.         LogUtils.e("i2 = $i2 ----------- height = $height")
  19.         if (i2 <= 0){
  20.             LogUtils.e("gone")
  21.             rl_scroll_title_titleWhite.visibility = View.GONE
  22.             rl_scroll_title_titleWhite.setBackgroundColor(Color.argb(0, 255, 255, 255))
  23.         }else if (i2 <= height){
  24.             rl_scroll_title_titleWhite.visibility = View.VISIBLE
  25.             val scale = i2.toFloat() / height
  26.             val alpha = (scale * 255).toInt()
  27.             LogUtils.e("scale = $scale ---- alpha = $alpha")
  28.             rl_scroll_title_titleWhite.setBackgroundColor(Color.argb(alpha, 255, 255, 255))
  29.         }else{
  30.             LogUtils.e("visible")
  31.             rl_scroll_title_titleWhite.visibility = View.VISIBLE
  32.             rl_scroll_title_titleWhite.setBackgroundColor(ContextCompat.getColor(this,R.color.white))
  33.         }
  34.     }
  35. }
  37. /**
  38.  * 监听滚动,通过设置alpha,实现布局渐变
  39.  */
  40. @RequiresApi(Build.VERSION_CODES.M)
  41. private fun scrollListener2() {
  42.     rl_scroll_title_titleWhite.alpha = 0f
  43.     rl_scroll_title_titleWhite.visibility = View.VISIBLE
  44.     //这种情况,height不会为0,不需要处理
  45.     sv_scroll_title_outer.setOnScrollChangeListener { p0, p1, p2, p3, p4 ->
  46.         LogUtils.e("p2=$p2")
  47.         if (p2 <= 0) {
  48.             rl_scroll_title_titleWhite.alpha = 0f
  49.         } else if (p2 < rl_scroll_title_titleWhite.height) {
  50.             //1.监听滚动,直接设置控件的透明度来实现标题渐变
  51.             //3,根据某个控件设置滚动到某个控件时,完全不透明
  52.             val scale = p2.toFloat() / (rl_scroll_title_titleWhite.height)
  53.             rl_scroll_title_titleWhite.alpha = scale
  54.         } else {
  55.             rl_scroll_title_titleWhite.alpha = 1f
  56.         }
  57.     }
  58. }
  61. /**
  62.  * 监听滚动,只控制显示和隐藏,布局初始隐藏,不用设置渐变度
  63.  */
  64. @RequiresApi(Build.VERSION_CODES.M)
  65. private fun scrollListener() {
  66.     //初始进入隐藏
  67.     rl_scroll_title_titleWhite.visibility = View.GONE
  68.     sv_scroll_title_outer.setOnScrollChangeListener { p0, p1, p2, p3, p4 ->
  69.         //获取rl_scroll_title_title控件的高度
  70.         val height = rl_scroll_title_titleWhite.height
  71.         LogUtils.e("p2=$p2---height=$height")
  72.         if (p2 <= height) {
  73.             //1.监听滚动,直接设置控件的透明度来实现标题渐变
  74.             rl_scroll_title_titleWhite.visibility = View.GONE
  75.             LogUtils.e("gone")
  76.         } else {
  77.             //初始进入 height 为 0
  78.             if (height == 0){
  79.                 rl_scroll_title_titleWhite.visibility = View.INVISIBLE
  80.             }else{
  81.                 rl_scroll_title_titleWhite.visibility = View.VISIBLE
  82.             }
  83.             LogUtils.e("visible")
  84.         }
  85.     }
  86. }
  88. override fun initIsToolbar(): Boolean {
  89.     return false
  90. }
  92. override fun onReload() {
  93. }

}

  1. <a name="dJkVl"></a>
  2. ## 二、吸顶，悬浮标题实现
  3. <a name="skegm"></a>
  4. ### 2.1 通过两个 View 控制显示和隐藏实现
  5. ![iShot2020-09-1400.05.07.gif](https://cdn.nlark.com/yuque/0/2020/gif/1624725/1600013139931-9b8d4839-1cf7-41ff-82a8-1e58cd1622aa.gif#align=left&display=inline&height=1016&margin=%5Bobject%20Object%5D&name=iShot2020-09-1400.05.07.gif&originHeight=1016&originWidth=614&size=2955058&status=done&style=none&width=614)
  7. - 布局文件

<?xml version=”1.0” encoding=”utf-8”?>

- activity class ScrollStickActivity : BaseActivity(R.layout.activityscroll_stick) { override fun initData() { } override fun initEvent() { } @RequiresApi(Build.VERSION_CODES.M) override fun initInterface() { //监听滚动 sv_scroll_stick_scroll.setOnScrollChangeListener { view, i, i2, i3, i4 -> if (i2 > tv_scroll_stick_one.height){ tv_scroll_stick_stick2.visibility = View.VISIBLE }else{ tv_scroll_stick_stick2.visibility = View.GONE } } } override fun onReload() { } } ``` ### 2.2 和上面的方法类似，通过 addView 和 removeView 实现 缺点是当包裹内容布局中带有滑动特性的View（ListView，RecyclerView等)，* 我们需要额外处理滑动冲突，并且这种包裹方式，会使得它们的缓存模式失效。_
iShot2020-09-1400.07.54.gif - 布局 ``` <?xml version=”1.0” encoding=”utf-8”?> 
  1.         </LinearLayout>
  6.         <TextView
  7.             android:layout_width="match_parent"
  8.             android:layout_height="250dp"
  9.             android:background="@color/yellow_FF9B52"/>
  10.         <TextView
  11.             android:layout_width="match_parent"
  12.             android:layout_height="250dp"
  13.             android:background="@color/green_07C0C2"/>
  14.         <TextView
  15.             android:layout_width="match_parent"
  16.             android:layout_height="250dp"
  17.             android:background="@color/red_F7E6ED"/>
  18.         <TextView
  19.             android:layout_width="match_parent"
  20.             android:layout_height="250dp"
  21.             android:background="@color/black_999999"/>
  22.     </LinearLayout>
  24. </com.kiwilss.xview.ui.view.scrollview.widget.ObservableScrollView>
 - activity class ScrollStickActivity2 : BaseActivity(R.layout.activity_scroll_stick2) { override fun initData() { } override fun initEvent() { } override fun initInterface() { //监听滚动 sv_scroll_stick2_scroll.setScrollViewListener { scrollView, x, y, oldx, oldy -> val h = tv_scroll_stick2_header.height val height = ll_scroll_stick2_stick.top LogUtils.e(“h = $h —- top = $height”) if (y > 0 && y >= height){ //addview if (rl_scroll_stick2_stick.parent != ll_scroll_stick2_title) { ll_scroll_stick2_stick.removeView(rl_scroll_stick2_stick) ll_scroll_stick2_title.addView(rl_scroll_stick2_stick) } }else{ //remove view if (rl_scroll_stick2_stick.parent != ll_scroll_stick2_stick) { ll_scroll_stick2_title.removeView(rl_scroll_stick2_stick) ll_scroll_stick2_stick.addView(rl_scroll_stick2_stick) } } } } override fun onReload() { } } <a name="IVJxO"></a> ### 2.3 通过 MD 折叠布局实现 ![iShot2020-09-1400.10.50.gif](https://cdn.nlark.com/yuque/0/2020/gif/1624725/1600013469832-98d69ed0-7860-48fe-bbf3-1c36c918eccb.gif#align=left&display=inline&height=1048&margin=%5Bobject%20Object%5D&name=iShot2020-09-1400.10.50.gif&originHeight=1048&originWidth=622&size=6804567&status=done&style=none&width=622) - 布局 <?xml version=”1.0” encoding=”utf-8”?> 
  1. </androidx.core.widget.NestedScrollView>

  2. - activity，可以什么都不用做就可以实现

class NestScrollStickActivity : BaseActivity(R.layout.activity_nestscroll_stick) {

  1. override fun initData() {
  2. }
  4. override fun initEvent() {
  5. }
  7. override fun initInterface() {
  9.     //滚动监听,可以直接调用
  10.     nsv_scroll_stick_outer.setOnScrollChangeListener { v: NestedScrollView?, scrollX: Int, scrollY: Int, oldScrollX: Int, oldScrollY: Int ->
  11.         LogUtils.e("x = $scrollX --- y = $scrollY")
  13.     }
  15. }
  18. override fun initIsToolbar(): Boolean {
  19.     return false
  20. }

}

  1. <a name="0Zkde"></a>
  2. ### 2.4 ObservableScrollView
  3. 上面用到了自定义 ScrollView 帮助实现滚动监听，可以直接使用 NestScrollView。下面是自定义 ScrollView：

public class ObservableScrollView extends ScrollView {

  1. private ScrollViewListener scrollViewListener = null;  
  3. public ObservableScrollView(Context context) {
  4.     super(context);  
  5. }  
  7. public ObservableScrollView(Context context, AttributeSet attrs,
  8.         int defStyle) {  
  9.     super(context, attrs, defStyle);  
  10. }  
  12. public ObservableScrollView(Context context, AttributeSet attrs) {  
  13.     super(context, attrs);  
  14. }  
  16. public void setScrollViewListener(ScrollViewListener scrollViewListener) {  
  17.     this.scrollViewListener = scrollViewListener;  
  18. }  
  20. @Override  
  21. protected void onScrollChanged(int x, int y, int oldx, int oldy) {  
  22.     super.onScrollChanged(x, y, oldx, oldy);  
  23.     if (scrollViewListener != null) {  
  24.         scrollViewListener.onScrollChanged(this, x, y, oldx, oldy);  
  25.     }  
  26. }

} 

  1. ```
  2. public interface ScrollViewListener {
  4.     void onScrollChanged(ObservableScrollView scrollView, int x, int y, int oldx, int oldy);  
  6. }

2.5 多个标题悬浮

使用自定义 View 实现，这个方法可以满足一个标题悬浮和多个标题悬浮，使用的关键点在于在想要悬浮的控件上加上 tag 属性,android:tag=”sticky”,只要加上这个就可以实现吸顶效果。

iShot2020-09-1400.16.16.gif

  • xml ``` <?xml version=”1.0” encoding=”utf-8”?>

    1.   <LinearLayout
    2.       android:layout_width="match_parent"
    3.       android:layout_height="wrap_content"
    4.       android:orientation="vertical">
    6.       <TextView
    7.           android:id="@+id/tv_scroll_title_one"
    8.           android:layout_width="match_parent"
    9.           android:layout_height="250dp"
    10.           android:background="@color/colorAccent"/>
    11.       <RelativeLayout
    12.           android:layout_width="match_parent"
    13.           android:layout_height="45dp"
    14.           android:background="@color/white"
    15.           android:visibility="visible"
    16.           android:tag="sticky"
    17.           >
    18.           <TextView
    19.               android:layout_width="wrap_content"
    20.               android:layout_height="wrap_content"
    21.               android:text="第一个悬停部分"
    22.               android:layout_centerInParent="true"/>
    24.       </RelativeLayout>
    25.       <TextView
    26.           android:layout_width="match_parent"
    27.           android:layout_height="250dp"
    28.           android:background="@color/yellow_FF9B52"/>
    29.       <RelativeLayout
    30.           android:layout_width="match_parent"
    31.           android:layout_height="45dp"
    32.           android:background="@color/white"
    33.           android:visibility="visible"
    34.           android:tag="sticky"
    35.           >
    36.           <TextView
    37.               android:layout_width="wrap_content"
    38.               android:layout_height="wrap_content"
    39.               android:text="第二个悬停部分"
    40.               android:layout_centerInParent="true"/>
    42.       </RelativeLayout>
    43.       <TextView
    44.           android:layout_width="match_parent"
    45.           android:layout_height="250dp"
    46.           android:background="@color/green_07C0C2"/>
    47.       <RelativeLayout
    48.           android:layout_width="match_parent"
    49.           android:layout_height="45dp"
    50.           android:background="@color/white"
    51.           android:visibility="visible"
    52.           android:tag="sticky"
    53.           >
    54.           <TextView
    55.               android:layout_width="wrap_content"
    56.               android:layout_height="wrap_content"
    57.               android:text="第三个悬停部分"
    58.               android:layout_centerInParent="true"/>
    60.       </RelativeLayout>
    61.       <TextView
    62.           android:layout_width="match_parent"
    63.           android:layout_height="250dp"
    64.           android:background="@color/red_F7E6ED"/>
    66.       <TextView
    67.           android:layout_width="match_parent"
    68.           android:layout_height="250dp"
    69.           android:background="@color/black_999999"/>
  1.         <TextView
  2.             android:layout_width="match_parent"
  3.             android:layout_height="250dp"
  4.             android:background="@color/blue_74D3FF"/>
  5.         <TextView
  6.             android:layout_width="match_parent"
  7.             android:layout_height="250dp"
  8.             android:background="@color/yellow_FF9B52"/>
  9.         <TextView
  10.             android:layout_width="match_parent"
  11.             android:layout_height="250dp"
  12.             android:background="@color/colorPrimary"/>
  14.     </LinearLayout>
  19. </LinearLayout>

  2. - StickyScrollView

public class StickyScrollView extends NestedScrollView {

  1. /**
  2.  * Tag for views that should stick and have constant drawing. e.g. TextViews, ImageViews etc
  3.  */
  4. public static final String STICKY_TAG = "sticky";
  6. /**
  7.  * Flag for views that should stick and have non-constant drawing. e.g. Buttons, ProgressBars etc
  8.  */
  9. public static final String FLAG_NONCONSTANT = "-nonconstant";
  11. /**
  12.  * Flag for views that have aren't fully opaque
  13.  */
  14. public static final String FLAG_HASTRANSPARANCY = "-hastransparancy";
  16. /**
  17.  * Default height of the shadow peeking out below the stuck view.
  18.  */
  19. private static final int DEFAULT_SHADOW_HEIGHT = 10; // dp;
  21. private ArrayList<View> stickyViews;
  22. private View currentlyStickingView;
  23. private float stickyViewTopOffset;
  24. private int stickyViewLeftOffset;
  25. private boolean redirectTouchesToStickyView;
  26. private boolean clippingToPadding;
  27. private boolean clipToPaddingHasBeenSet;
  29. private int mShadowHeight;
  30. private Drawable mShadowDrawable;
  32. private final Runnable invalidateRunnable = new Runnable() {
  34.     @Override
  35.     public void run() {
  36.         if (currentlyStickingView != null) {
  37.             int l = getLeftForViewRelativeOnlyChild(currentlyStickingView);
  38.             int t = getBottomForViewRelativeOnlyChild(currentlyStickingView);
  39.             int r = getRightForViewRelativeOnlyChild(currentlyStickingView);
  40.             int b = (int) (getScrollY() + (currentlyStickingView.getHeight() + stickyViewTopOffset));
  41.             invalidate(l, t, r, b);
  42.         }
  43.         postDelayed(this, 16);
  44.     }
  45. };
  47. public StickyScrollView(Context context) {
  48.     this(context, null);
  49. }
  51. public StickyScrollView(Context context, AttributeSet attrs) {
  52.     this(context, attrs, android.R.attr.scrollViewStyle);
  53. }
  55. public StickyScrollView(Context context, AttributeSet attrs, int defStyle) {
  56.     super(context, attrs, defStyle);
  57.     setup();
  59.     TypedArray a = context.obtainStyledAttributes(attrs,
  60.             R.styleable.StickyScrollView, defStyle, 0);
  62.     final float density = context.getResources().getDisplayMetrics().density;
  63.     int defaultShadowHeightInPix = (int) (DEFAULT_SHADOW_HEIGHT * density + 0.5f);
  65.     mShadowHeight = a.getDimensionPixelSize(
  66.             R.styleable.StickyScrollView_stuckShadowHeight,
  67.             defaultShadowHeightInPix);
  69.     int shadowDrawableRes = a.getResourceId(
  70.             R.styleable.StickyScrollView_stuckShadowDrawable, -1);
  72.     if (shadowDrawableRes != -1) {
  73.         mShadowDrawable = context.getResources().getDrawable(
  74.                 shadowDrawableRes);
  75.     }
  77.     a.recycle();
  78. }
  80. /**
  81.  * Sets the height of the shadow drawable in pixels.
  82.  *
  83.  * @param height
  84.  */
  85. public void setShadowHeight(int height) {
  86.     mShadowHeight = height;
  87. }
  90. public void setup() {
  91.     stickyViews = new ArrayList<View>();
  92. }
  94. private int getLeftForViewRelativeOnlyChild(View v) {
  95.     int left = v.getLeft();
  96.     while (v.getParent() != getChildAt(0)) {
  97.         v = (View) v.getParent();
  98.         left += v.getLeft();
  99.     }
  100.     return left;
  101. }
  103. private int getTopForViewRelativeOnlyChild(View v) {
  104.     int top = v.getTop();
  105.     while (v.getParent() != getChildAt(0)) {
  106.         v = (View) v.getParent();
  107.         top += v.getTop();
  108.     }
  109.     return top;
  110. }
  112. private int getRightForViewRelativeOnlyChild(View v) {
  113.     int right = v.getRight();
  114.     while (v.getParent() != getChildAt(0)) {
  115.         v = (View) v.getParent();
  116.         right += v.getRight();
  117.     }
  118.     return right;
  119. }
  121. private int getBottomForViewRelativeOnlyChild(View v) {
  122.     int bottom = v.getBottom();
  123.     while (v.getParent() != getChildAt(0)) {
  124.         v = (View) v.getParent();
  125.         bottom += v.getBottom();
  126.     }
  127.     return bottom;
  128. }
  130. @Override
  131. protected void onLayout(boolean changed, int l, int t, int r, int b) {
  132.     super.onLayout(changed, l, t, r, b);
  133.     if (!clipToPaddingHasBeenSet) {
  134.         clippingToPadding = true;
  135.     }
  136.     notifyHierarchyChanged();
  137. }
  139. @Override
  140. public void setClipToPadding(boolean clipToPadding) {
  141.     super.setClipToPadding(clipToPadding);
  142.     clippingToPadding = clipToPadding;
  143.     clipToPaddingHasBeenSet = true;
  144. }
  146. @Override
  147. public void addView(View child) {
  148.     super.addView(child);
  149.     findStickyViews(child);
  150. }
  152. @Override
  153. public void addView(View child, int index) {
  154.     super.addView(child, index);
  155.     findStickyViews(child);
  156. }
  158. @Override
  159. public void addView(View child, int index, android.view.ViewGroup.LayoutParams params) {
  160.     super.addView(child, index, params);
  161.     findStickyViews(child);
  162. }
  164. @Override
  165. public void addView(View child, int width, int height) {
  166.     super.addView(child, width, height);
  167.     findStickyViews(child);
  168. }
  170. @Override
  171. public void addView(View child, android.view.ViewGroup.LayoutParams params) {
  172.     super.addView(child, params);
  173.     findStickyViews(child);
  174. }
  176. @Override
  177. protected void dispatchDraw(Canvas canvas) {
  178.     super.dispatchDraw(canvas);
  179.     if (currentlyStickingView != null) {
  180.         canvas.save();
  181.         canvas.translate(getPaddingLeft() + stickyViewLeftOffset, getScrollY() + stickyViewTopOffset + (clippingToPadding ? getPaddingTop() : 0));
  183.         canvas.clipRect(0, (clippingToPadding ? -stickyViewTopOffset : 0),
  184.                 getWidth() - stickyViewLeftOffset,
  185.                 currentlyStickingView.getHeight() + mShadowHeight + 1);
  187.         if (mShadowDrawable != null) {
  188.             int left = 0;
  189.             int right = currentlyStickingView.getWidth();
  190.             int top = currentlyStickingView.getHeight();
  191.             int bottom = currentlyStickingView.getHeight() + mShadowHeight;
  192.             mShadowDrawable.setBounds(left, top, right, bottom);
  193.             mShadowDrawable.draw(canvas);
  194.         }
  196.         canvas.clipRect(0, (clippingToPadding ? -stickyViewTopOffset : 0), getWidth(), currentlyStickingView.getHeight());
  197.         if (getStringTagForView(currentlyStickingView).contains(FLAG_HASTRANSPARANCY)) {
  198.             showView(currentlyStickingView);
  199.             currentlyStickingView.draw(canvas);
  200.             hideView(currentlyStickingView);
  201.         } else {
  202.             currentlyStickingView.draw(canvas);
  203.         }
  204.         canvas.restore();
  205.     }
  206. }
  208. @Override
  209. public boolean dispatchTouchEvent(MotionEvent ev) {
  210.     if (ev.getAction() == MotionEvent.ACTION_DOWN) {
  211.         redirectTouchesToStickyView = true;
  212.     }
  214.     if (redirectTouchesToStickyView) {
  215.         redirectTouchesToStickyView = currentlyStickingView != null;
  216.         if (redirectTouchesToStickyView) {
  217.             redirectTouchesToStickyView =
  218.                     ev.getY() <= (currentlyStickingView.getHeight() + stickyViewTopOffset) &&
  219.                             ev.getX() >= getLeftForViewRelativeOnlyChild(currentlyStickingView) &&
  220.                             ev.getX() <= getRightForViewRelativeOnlyChild(currentlyStickingView);
  221.         }
  222.     } else if (currentlyStickingView == null) {
  223.         redirectTouchesToStickyView = false;
  224.     }
  225.     if (redirectTouchesToStickyView) {
  226.         ev.offsetLocation(0, -1 * ((getScrollY() + stickyViewTopOffset) - getTopForViewRelativeOnlyChild(currentlyStickingView)));
  227.     }
  228.     return super.dispatchTouchEvent(ev);
  229. }
  231. private boolean hasNotDoneActionDown = true;
  233. @Override
  234. public boolean onTouchEvent(MotionEvent ev) {
  235.     if (redirectTouchesToStickyView) {
  236.         ev.offsetLocation(0, ((getScrollY() + stickyViewTopOffset) - getTopForViewRelativeOnlyChild(currentlyStickingView)));
  237.     }
  239.     if (ev.getAction() == MotionEvent.ACTION_DOWN) {
  240.         hasNotDoneActionDown = false;
  241.     }
  243.     if (hasNotDoneActionDown) {
  244.         MotionEvent down = MotionEvent.obtain(ev);
  245.         down.setAction(MotionEvent.ACTION_DOWN);
  246.         super.onTouchEvent(down);
  247.         hasNotDoneActionDown = false;
  248.     }
  250.     if (ev.getAction() == MotionEvent.ACTION_UP || ev.getAction() == MotionEvent.ACTION_CANCEL) {
  251.         hasNotDoneActionDown = true;
  252.     }
  254.     return super.onTouchEvent(ev);
  255. }
  257. @Override
  258. protected void onScrollChanged(int l, int t, int oldl, int oldt) {
  259.     super.onScrollChanged(l, t, oldl, oldt);
  260.     doTheStickyThing();
  261. }
  263. private void doTheStickyThing() {
  264.     View viewThatShouldStick = null;
  265.     View approachingView = null;
  266.     for (View v : stickyViews) {
  267.         int viewTop = getTopForViewRelativeOnlyChild(v) - getScrollY() + (clippingToPadding ? 0 : getPaddingTop());
  268.         if (viewTop <= 0) {
  269.             if (viewThatShouldStick == null || viewTop > (getTopForViewRelativeOnlyChild(viewThatShouldStick) - getScrollY() + (clippingToPadding ? 0 : getPaddingTop()))) {
  270.                 viewThatShouldStick = v;
  271.             }
  272.         } else {
  273.             if (approachingView == null || viewTop < (getTopForViewRelativeOnlyChild(approachingView) - getScrollY() + (clippingToPadding ? 0 : getPaddingTop()))) {
  274.                 approachingView = v;
  275.             }
  276.         }
  277.     }
  278.     if (viewThatShouldStick != null) {
  279.         stickyViewTopOffset = approachingView == null ? 0 : Math.min(0, getTopForViewRelativeOnlyChild(approachingView) - getScrollY() + (clippingToPadding ? 0 : getPaddingTop()) - viewThatShouldStick.getHeight());
  280.         if (viewThatShouldStick != currentlyStickingView) {
  281.             if (currentlyStickingView != null) {
  282.                 stopStickingCurrentlyStickingView();
  283.             }
  284.             // only compute the left offset when we start sticking.
  285.             stickyViewLeftOffset = getLeftForViewRelativeOnlyChild(viewThatShouldStick);
  286.             startStickingView(viewThatShouldStick);
  287.         }
  288.     } else if (currentlyStickingView != null) {
  289.         stopStickingCurrentlyStickingView();
  290.     }
  291. }
  293. private void startStickingView(View viewThatShouldStick) {
  294.     currentlyStickingView = viewThatShouldStick;
  295.     if (getStringTagForView(currentlyStickingView).contains(FLAG_HASTRANSPARANCY)) {
  296.         hideView(currentlyStickingView);
  297.     }
  298.     if (((String) currentlyStickingView.getTag()).contains(FLAG_NONCONSTANT)) {
  299.         post(invalidateRunnable);
  300.     }
  301. }
  303. private void stopStickingCurrentlyStickingView() {
  304.     if (getStringTagForView(currentlyStickingView).contains(FLAG_HASTRANSPARANCY)) {
  305.         showView(currentlyStickingView);
  306.     }
  307.     currentlyStickingView = null;
  308.     removeCallbacks(invalidateRunnable);
  309. }
  311. /**
  312.  * Notify that the sticky attribute has been added or removed from one or more views in the View hierarchy
  313.  */
  314. public void notifyStickyAttributeChanged() {
  315.     notifyHierarchyChanged();
  316. }
  318. private void notifyHierarchyChanged() {
  319.     if (currentlyStickingView != null) {
  320.         stopStickingCurrentlyStickingView();
  321.     }
  322.     stickyViews.clear();
  323.     findStickyViews(getChildAt(0));
  324.     doTheStickyThing();
  325.     invalidate();
  326. }
  328. private void findStickyViews(View v) {
  329.     if (v instanceof ViewGroup) {
  330.         ViewGroup vg = (ViewGroup) v;
  331.         for (int i = 0; i < vg.getChildCount(); i++) {
  332.             String tag = getStringTagForView(vg.getChildAt(i));
  333.             if (tag != null && tag.contains(STICKY_TAG)) {
  334.                 stickyViews.add(vg.getChildAt(i));
  335.             } else if (vg.getChildAt(i) instanceof ViewGroup) {
  336.                 findStickyViews(vg.getChildAt(i));
  337.             }
  338.         }
  339.     } else {
  340.         String tag = (String) v.getTag();
  341.         if (tag != null && tag.contains(STICKY_TAG)) {
  342.             stickyViews.add(v);
  343.         }
  344.     }
  345. }
  347. private String getStringTagForView(View v) {
  348.     Object tagObject = v.getTag();
  349.     return String.valueOf(tagObject);
  350. }
  352. private void hideView(View v) {
  353.     if (Build.VERSION.SDK_INT >= 11) {
  354.         v.setAlpha(0);
  355.     } else {
  356.         AlphaAnimation anim = new AlphaAnimation(1, 0);
  357.         anim.setDuration(0);
  358.         anim.setFillAfter(true);
  359.         v.startAnimation(anim);
  360.     }
  361. }
  363. private void showView(View v) {
  364.     if (Build.VERSION.SDK_INT >= 11) {
  365.         v.setAlpha(1);
  366.     } else {
  367.         AlphaAnimation anim = new AlphaAnimation(0, 1);
  368.         anim.setDuration(0);
  369.         anim.setFillAfter(true);
  370.         v.startAnimation(anim);
  371.     }
  372. }

}

  2. - attr

```

三、参考

Android Scrollview上滑停靠—悬浮框停靠在标题栏下方（防微博详情页）
android ScrollView 吸顶效果
Android NestedScrollView滚动到顶部固定子View悬停