可滑动Header控件的实现

最新推荐文章于 2022-02-14 22:23:24 发布
原创 最新推荐文章于 2022-02-14 22:23:24 发布 · 441 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#ListView滑动 #滑动冲突 #事件传递

本文介绍了一种解决Android中内外层视图滑动冲突的方法，通过自定义SlideHeaderView控件来实现平滑的滑动效果，并保持良好的用户体验。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

最近在项目开发中经常遇到这样的需求：在一个Activity中，上半部分是一个高度比较大(屏幕高度的1/3或者1/2)的Header，下半部分是ListView或者是ViewPager(里面依然包含ListView)。如果Header不能向上活动，则在浏览ListView中的内容时，只能在很小的高度里面滑动，不能发挥大屏幕的优势。如果在滑动过程中，使Header也滑动则会造成外层ViewGroup与内层ListView滑动冲突。

本文从滑动冲突产生的原因、解决方案以及代码实现过程三个方面，介绍了可滑动Header控件的实现过程。
1.滑动冲突产生的原因
滑动冲突的原因很简单，就是一个原因：在界面中只要内外两层同时可以滑动，就会产生滑动冲突。常见的滑动冲突场景有两种：
a.外部View滑动方向与内部View滑动方向一致；
b.外部View滑动方向与内部View滑动方向不一致。
Android系统提供的可滑动控件有的已经解决了滑动冲突问题，例如：ViewPager；而大部分可滑动控件并没有处理滑动冲突，例如：ScrollView、ListView。
2.解决方案
要想解决滑动冲突，首先要对Android的事件传递机制有一个深入的理解，本文的重点是讲述解决滑动冲突，对Android的事件传递机制就不展开了。Android的MotionEvent是从外层View向内层View传递的，一旦MotionEvent被拦截，MotionEvent就交给拦截它的View处理。针对滑动冲突问题，外层滑动View在onInterceptTouchEvent()方法中根据业务逻辑的需要判断是否拦截MotionEvent，在onTouchEvent()方法中实现滑动效果；在滑动的过程中，使内外层View只有一个能拦截MotionEvent，这样子就解决了View的滑动冲突问题。

3.实现过程
外层滑动View的实现`

import android.annotation.TargetApi;
import android.content.Context;
import android.os.Build;
import android.os.Handler;
import android.os.Message;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.widget.LinearLayout;

import java.util.NoSuchElementException;


public class SlideHeaderView extends LinearLayout{

    private static final String TAG = "SlideHeaderView";
    private static final boolean DEBUG = true;

    /**
     * 滑动的风格类型，非覆盖
     */
    private StyleType mStyleType = StyleType.SlideOut;

    /**
     * 覆盖式、非覆盖式枚举
     */
    public enum StyleType {
        SlideOut, SlideIn // SlideOut:整个View滑动，整个View的位置发生改变  SlideIn:整个View的位置没有改变，改变View内HeaderView的高度
    }

    public interface OnInterceptScrollListener {
        boolean isInterceptScrollUpward(MotionEvent event);
        boolean isInterceptScrollDownward(MotionEvent event);
    }

    public interface OnChangeHeaderStateListener {
        void onExpandHeader();
        void onCollapseHeader();
    }

    private View mHeader;
    private View mContent;
    private OnInterceptScrollListener mInterceptScrollListener;

    private OnChangeHeaderStateListener mChangeHeaderStateListener;

    // header的高度  单位：px
    private int mOriginalHeaderHeight = -1;
    private int mHeaderHeight;
    private int minHeaderHeight;

    public int mStatus = STATUS_EXPANDED;
    public static final int STATUS_EXPANDED = 1;
    public static final int STATUS_COLLAPSED = 2;

    public int mAutoScrollOrientation;
    private final int mSlideDownward = 1; //向下滑动
    private final int mSlideUpward = 2; //向上滑动

    private int mTouchSlop;

    // 分别记录上次滑动的坐标
    private int mLastX = 0;
    private int mLastY = 0;

    // 分别记录上次滑动的坐标(onInterceptTouchEvent)
    private int mLastXIntercept = 0;
    private int mLastYIntercept = 0;

    // 用来控制滑动角度，仅当角度a满足如下条件才进行滑动：tan a = deltaX / deltaY > 2
    private static final int TAN = 2;

    private boolean mIsSticky = true;
    private boolean mInitDataSucceed = false;
    private boolean mDisallowInterceptTouchEventOnHeader = true;

    private MarginLayoutParams mTopMarginLayoutParams;
    private int mTopMargin;
    private int maxTopMargin = -1;

    private int mAnimationSpeed = 20;
    private int mAnimationInterval = 10;

    public SlideHeaderView(Context context) {
        super(context);
    }

    public SlideHeaderView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
    public SlideHeaderView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    @Override
    public void onWindowFocusChanged(boolean hasWindowFocus) {
        super.onWindowFocusChanged(hasWindowFocus);
        if (hasWindowFocus && (mHeader == null || mContent == null)) {
            initData();
        }
    }

    private void initData() {
        int headerId= getResources().getIdentifier("sticky_header", "id", getContext().getPackageName());
        int contentId = getResources().getIdentifier("sticky_content", "id", getContext().getPackageName());
        if (headerId != 0 && contentId != 0) {
            mHeader = findViewById(headerId);
            mContent = findViewById(contentId);

            if (mOriginalHeaderHeight < 0) {
                mOriginalHeaderHeight = mHeader.getMeasuredHeight();
            }
            mHeaderHeight = mOriginalHeaderHeight;
            if (maxTopMargin < 0) {
                maxTopMargin = mOriginalHeaderHeight;
            }
            mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
            if (mHeaderHeight > 0) {
                mInitDataSucceed = true;
            }
            if (DEBUG) {
                Log.d(TAG, "mTouchSlop = " + mTouchSlop + "mHeaderHeight = " + mHeaderHeight);
            }
        } else {
            throw new NoSuchElementException("Did your view with id \"sticky_header\" or \"sticky_content\" exists?");
        }
    }

    public void setOnInterceptScrollListener(OnInterceptScrollListener l) {
        mInterceptScrollListener = l;
    }

    public void setOnChangeHeaderStateListener(OnChangeHeaderStateListener l) {
        mChangeHeaderStateListener = l;
    }

    public void setAnimationSpeed(int speed) {
        mAnimationSpeed = speed;
    }

    public void setAnimationInterval(int interval) {
        mAnimationInterval = interval;
    }

    public void setMaxTopMargin(int margin) {
        maxTopMargin = margin;
    }

    public void setMinHeaderHeight(int height) {
        minHeaderHeight = height;
    }

    public void setStyleType (StyleType type) {
        mStyleType = type;
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent event) {
        int intercepted = 0;
        int x = getX(event);
        int y = getY(event);
        Log.d(TAG, "onInterceptTouchEvent-->y = " + y);

        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN: {
                mLastXIntercept = x;
                mLastYIntercept = y;
                mLastX = x;
                mLastY = y;
                Log.d(TAG, "onInterceptTouchEvent-->mLastY = " + mLastY);
                intercepted = 0;
                break;
            }
            case MotionEvent.ACTION_MOVE: {
                int deltaX = x - mLastXIntercept;
                int deltaY = y - mLastYIntercept;

                if (Math.abs(deltaY) <= Math.abs(deltaX)) {
                    intercepted = 0;
                } else if (deltaY <= -mTouchSlop) {
                    if (mInterceptScrollListener != null && mInterceptScrollListener.isInterceptScrollUpward(event)) {
                        intercepted = 1;
                    }
                } else if (deltaY >= mTouchSlop) {
                    if (mInterceptScrollListener != null && mInterceptScrollListener.isInterceptScrollDownward(event)) {
                        intercepted = 1;
                    }
                }

//                Log.d(TAG, "onInterceptTouchEvent-->ACTION_MOVE-->intercepted = " + intercepted);
                break;
            }
            case MotionEvent.ACTION_UP: {
                intercepted = 0;
                mLastXIntercept = mLastYIntercept = 0;
                break;
            }
            default:
                break;
        }

        if (DEBUG) {
            Log.d(TAG, "intercepted=" + intercepted);
        }
        return intercepted != 0 && mIsSticky;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (!mIsSticky) {
            return true;
        }
        int x = getX(event);
        int y = getY(event);
        Log.d(TAG, "onTouchEvent-->y = " + y);
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN: {
                mTopMargin = ((MarginLayoutParams) getLayoutParams()).topMargin;
                break;
            }
            case MotionEvent.ACTION_MOVE: {
                int deltaX = x - mLastX;
                int deltaY = y - mLastY;
                Log.d(TAG, "onTouchEvent-->deltaY = " + deltaY);

                if (DEBUG) {
//                    Log.d(TAG, "mHeaderHeight=" + mHeaderHeight + "  deltaY=" + deltaY + "  mlastY=" + mLastY);
                }

                if (mStyleType == StyleType.SlideIn) {
                    mHeaderHeight += deltaY;
                    setHeaderHeight(mHeaderHeight);
                } else if (mStyleType == StyleType.SlideOut) {
                    mTopMargin += deltaY;
                    setTopMargin();
                    Log.d(TAG, "onTouchEvent-->ACTION_MOVE-->mTopMargin = " + mTopMargin);
                }
                break;
            }
            case MotionEvent.ACTION_UP: {
                // 这里做了下判断，当松开手的时候，会自动向两边滑动，具体向哪边滑，要看当前所处的位置
                if (mStyleType == StyleType.SlideIn) {
                    if (mHeaderHeight <= mOriginalHeaderHeight * 0.5) {
//                        mStatus = STATUS_COLLAPSED;
                        mAutoScrollOrientation = mSlideUpward;//向上滑动
                    } else {
//                        mStatus = STATUS_EXPANDED;
                        mAutoScrollOrientation = mSlideDownward;//向下滑动
                    }

                    post(new AutoSlidingRunnable());
                } else if (mStyleType == StyleType.SlideOut) {
                    if (Math.abs(mTopMargin) <= mOriginalHeaderHeight * 0.5) {
//                        mStatus = STATUS_EXPANDED;
                        mAutoScrollOrientation = mSlideDownward;//向下滑动
                    } else {
//                        mStatus = STATUS_COLLAPSED;
                        mAutoScrollOrientation = mSlideUpward;//向上滑动
                    }

                    post(new AutoSlidingRunnable());
                }

                break;
            }
            default:
                break;
        }
        mLastX = x;
        mLastY = y;
        return true;
    }

    private int getX(MotionEvent event) {
        int x = 0;
        if (mStyleType == StyleType.SlideIn) {
            x = (int) event.getX();
        } else if (mStyleType == StyleType.SlideOut) {
            x = (int) event.getRawX();
        }
        return x;
    }

    private int getY(MotionEvent event) {
        int y = 0;
        if (mStyleType == StyleType.SlideIn) {
            y = (int) event.getY();
        } else if (mStyleType == StyleType.SlideOut) {
            y = (int) event.getRawY();
        }
        return y;
    }

    public void setOriginalHeaderHeight(int originalHeaderHeight) {
        mOriginalHeaderHeight = originalHeaderHeight;
    }

    public void setHeaderHeight(int height, boolean modifyOriginalHeaderHeight) {
        if (modifyOriginalHeaderHeight) {
            setOriginalHeaderHeight(height);
        }
        setHeaderHeight(height);
    }

    public void setHeaderHeight(int height) {
        if (!mInitDataSucceed) {
            initData();
        }

        if (DEBUG) {
//            Log.d(TAG, "setHeaderHeight height=" + height);
        }
        if (height <= minHeaderHeight) {
            height = minHeaderHeight;
        } else if (height > mOriginalHeaderHeight) {
            height = mOriginalHeaderHeight;
        }

        if (height == minHeaderHeight) {
            mStatus = STATUS_COLLAPSED;
            if (mChangeHeaderStateListener != null) {
                mChangeHeaderStateListener.onCollapseHeader();
            }
        } else {
            mStatus = STATUS_EXPANDED;
            if (mChangeHeaderStateListener != null) {
                mChangeHeaderStateListener.onExpandHeader();
            }
        }

        if (mHeader != null && mHeader.getLayoutParams() != null) {
            mHeader.getLayoutParams().height = height;
            mHeader.requestLayout();
            mHeaderHeight = height;
        } else {
            if (DEBUG) {
                Log.e(TAG, "null LayoutParams when setHeaderHeight");
            }
        }
    }

    public void setTopMargin() {
        if (mTopMargin < -maxTopMargin) {
            mTopMargin = -maxTopMargin;
        } else if (mTopMargin > 0) {
            mTopMargin = 0;
        }

        if (mTopMargin == -maxTopMargin) {
            mStatus = STATUS_COLLAPSED;
            if (mChangeHeaderStateListener != null) {
                mChangeHeaderStateListener.onCollapseHeader();
            }
        } else {
            mStatus = STATUS_EXPANDED;
            if (mChangeHeaderStateListener != null) {
                mChangeHeaderStateListener.onExpandHeader();
            }
        }

//        Log.d(TAG, "setTopMargin: topMargin = " + mTopMargin);
        mTopMarginLayoutParams = (MarginLayoutParams) getLayoutParams();
        mTopMarginLayoutParams.topMargin = mTopMargin;
        setLayoutParams(mTopMarginLayoutParams);
    }

    public int getHeaderHeight() {
        return mHeaderHeight;
    }

    public void setSticky(boolean isSticky) {
        mIsSticky = isSticky;
    }

    public void requestDisallowInterceptTouchEventOnHeader(boolean disallowIntercept) {
        mDisallowInterceptTouchEventOnHeader = disallowIntercept;
    }

    public int getHeaderStatus() {
        return mStatus;
    }

    private class AutoSlidingRunnable implements Runnable {

        public AutoSlidingRunnable() {}


        @Override
        public void run() {
            switch (mStyleType) {
                case SlideOut:
                    if (mAutoScrollOrientation == mSlideDownward) {
                        mTopMargin = mTopMargin + mAnimationSpeed;
                        Log.d(TAG, "向下滑动: topMargin = " + mTopMargin);
                        if (mTopMargin >= 0 ) {
                            mTopMargin = 0;
                            mHandler.sendEmptyMessage(100);

                            mStatus = STATUS_EXPANDED;
                            if (mChangeHeaderStateListener != null) {
                                mChangeHeaderStateListener.onExpandHeader();
                            }
                            return;
                        }
                        mHandler.sendEmptyMessage(100);
                    } else if (mAutoScrollOrientation == mSlideUpward) {
                        mTopMargin = mTopMargin - mAnimationSpeed;
                        Log.d(TAG, "向上滑动: topMargin = " + mTopMargin);
                        if (mTopMargin <= -maxTopMargin ) {
                            mTopMargin = -maxTopMargin;
                            mHandler.sendEmptyMessage(100);

                            mStatus = STATUS_COLLAPSED;
                            if (mChangeHeaderStateListener != null) {
                                mChangeHeaderStateListener.onCollapseHeader();
                            }
                            return;
                        }
                        mHandler.sendEmptyMessage(100);
                    }

                    postDelayed(this, mAnimationInterval);

                    break;
                case SlideIn:
                    if (mAutoScrollOrientation == mSlideDownward) {
                        mHeaderHeight = mHeaderHeight + mAnimationSpeed;
                        Log.d(TAG, "向下滑动: mHeaderHeight = " + mHeaderHeight);
                        if (mHeaderHeight >= mOriginalHeaderHeight) {
                            mHeaderHeight = mOriginalHeaderHeight;
                            mHandler.sendEmptyMessage(101);

                            mStatus = STATUS_EXPANDED;
                            if (mChangeHeaderStateListener != null) {
                                mChangeHeaderStateListener.onExpandHeader();
                            }
                            return;
                        }
                        mHandler.sendEmptyMessage(101);
                    } else if (mAutoScrollOrientation == mSlideUpward) {
                        mHeaderHeight = mHeaderHeight - mAnimationSpeed;
                        Log.d(TAG, "向上滑动: mHeaderHeight = " + mHeaderHeight);
                        if (mHeaderHeight <= minHeaderHeight) {
                            mHeaderHeight = minHeaderHeight;
                            mHandler.sendEmptyMessage(101);

                            mStatus = STATUS_COLLAPSED;
                            if (mChangeHeaderStateListener != null) {
                                mChangeHeaderStateListener.onCollapseHeader();
                            }
                            return;
                        }
                        mHandler.sendEmptyMessage(101);
                    }

                    postDelayed(this, mAnimationInterval);

                    break;
                default:
                    break;
            }

        }
    }

    /**
     * Handler处理者
     */
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 100:
                    mTopMarginLayoutParams = (MarginLayoutParams) getLayoutParams();
                    mTopMarginLayoutParams.topMargin = mTopMargin;
                    setLayoutParams(mTopMarginLayoutParams);
                    break;
                case 101:
                    if (mHeader != null && mHeader.getLayoutParams() != null) {
                        mHeader.getLayoutParams().height = mHeaderHeight;
                        mHeader.requestLayout();
                    } else {
                        if (DEBUG) {
                            Log.e(TAG, "null LayoutParams when setHeaderHeight");
                        }
                    }
                    break;
                default:
                    break;
            }
        }
    };

    public void expandHeader() {
        mAutoScrollOrientation = mSlideDownward;
        post(new AutoSlidingRunnable());
    }

}

使用这种方式解决滑动冲突问题，只需重新外层滑动View，内层滑动View不用做任何处理。

在使用SlideHeaderView的Activity中需要实现SlideHeaderView.OnInterceptScrollListener接口

@Override
    public boolean isInterceptScrollUpward(MotionEvent event) {
        if (isNeedIntercept) {
            return true；
        }
        return false;
    }

    @Override
    public boolean isInterceptScrollDownward(MotionEvent event) {
        if (isNeedIntercept) {
            return true;
        }
        return false;
    }

xml文件的实现

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#FFEEEFEF">

    <SlideHeaderView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">

        <LinearLayout
            android:id="@+id/sticky_header"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:orientation="vertical">

            <ImageView
                android:layout_width="match_parent"
                android:layout_height="match_parent"/>

        </LinearLayout>

        <LinearLayout
            android:id="@+id/sticky_content"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:orientation="vertical">

            <android.support.v4.view.ViewPager
                android:id="@+id/viewpager"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:background="#FFEEEFEF"></android.support.v4.view.ViewPager>

        </LinearLayout>

    </SlideHeaderView>

</RelativeLayout>

过一段时间，写一个demo上传上来。

reference：Android开发艺术探索

Flutter 实现 列表滑动过程控件停靠效果 学习
且听真言
01-04 1384
Ticker` 是 Flutter 动画系统的基础，它会按照屏幕刷新率（通常是每秒 60 次）调用一个回调函数，帮助你在每一帧更新动画。使用 `Ticker` 可以让动画与设备的帧同步，从而实现平滑的动画效果。`Expanded` 和 `Spacer` 是 Flutter 布局系统中强大且灵活的工具。通过这些小部件，你可以轻松创建响应式布局，确保组件在不同屏幕尺寸和方向上都能合理地显示和排列。了解如何使用这些工具将帮助你更高效地设计和实现复杂的用户界面。
自定义view实战(6)：滑动折叠Header的控件（滑动冲突）
silencefly的博客
10-20 436
自定义view实战(6)：通过一个内容滚动造成header折叠的控件学习一下滑动事件冲突问题、更改view节点以及CoordinatorLayout事件传递（超低仿），基本都是一个引子，希望学完这个控件，要继续省略学习下涉及的内容。
扩展的THeader控件
03-06
delphi自带的THeader控件不具备设置背景色的功能，同时也不能设置Header上的每一列的文本对齐方式，THeaderEx控件扩充了THeader的功能，通过Color属性设置背景颜色，通过调用SectionAlign方法来设置每一列的对齐方式。
HEADER控件
pikachu_beta的博客
09-06 389
HEADER控件 1、主要内容 HEADER控件基本使用方法 2、源码介绍 2.1、定义控件的初始值 hItem = WM_GetDialogItem(pMsg->hWin,ID_LISTVIEW_0); hHeader = LISTVIEW_GetHeader(hItem);① WM_SetFocus(hItem);② HEADER_SetFont(hHeader,&GUI_FontFont_Micro_20);③ HEADER_SetHeight(hHeader, 25); ④ LIST
改变 CListCtrl、CHeaderCtrl 高度、字体、颜色和背景
顺子的专栏
04-21 1万+
用CListCtrl来显示数据比较方便，有时候我们需要标注某一列或某一个单元格的背景和字体颜色，或者需要改变一下行高和字体大小，CListCtrl要改变这些并不是很方便。本文将介绍如何派生一个类来改变CListCtrl及其表头的高度、字体大小、列背景颜色、单元格背景颜色、列字体颜色、单元格字体颜色 实现过程：1.表头修改　　新建一个MFC类CHeaderCtrlCl,其基类为CHead
How to change JTable header height? 设置JTableHeader 高度的正确方式
myNameAbian的专栏
03-04 652
 1-设置 JTable header height错误方式   table.getTableHeader().setPreferredSize(new Dimension(10,10));      为什么是错误的?请看截图   当拖动列的时候 错误就出现了?表头和列错乱了.而国内清一色的采用上一种错误方式     2 正确的解决方式: 我们公司大神 坤哥在http://...
iOS tableView滑动header放大效果实现指南
文档标题“ios-tableView滑动header放大的效果.zip”暗示了这是一个包含源代码的压缩包，用于展示当用户在 tableView 中滑动时，头部视图（header）如何放大。 ###iOS 开发基础 iOS 开发是基于苹果公司提供的操作...
Windows MFC滑动按钮控件的设计与实现
资源摘要信息:"Windows MFC实现自定义滑动按钮控件" 在Windows应用程序开发中，MFC（Microsoft Foundation Classes）是一个C++库，用于简化Windows应用程序的开发。本资源描述了一个特定的控件实现过程——一个具有...
列表header/footer滑动快速显示功能源码实现
2. 表头(Header)与表尾(Footer)：在列表视图中，表头通常位于列表的顶部，可以用来显示列表的标题或者是用于搜索、排序等功能的控件。表尾则位于列表底部，可能用来显示额外的功能按钮或者分页信息。 3. 滚动隐藏与...
setHeader方法的使用
热门推荐
zxcvb12zxcvb12的博客
05-24 2万+
response.setHeader()下载中文文件名乱码1. HTTP消息头（1）通用信息头即能用于请求消息中,也能用于响应信息中,但与被传输的实体内容没有关系的信息头,如Data,Pragma主要: Cache-Control , Connection , Data , Pragma , Trailer , Transfer-Encoding , Upgrade（2）请求头用于在请求消息中向服...
5，头部Header组件 ly-tab插件的使用
m0_62598303的博客
02-14 1422
components 下新建home文件夹 添加header.vue组件 <template> <header> <h1>荼七网</h1> <div class="search"> <i class="iconfont icon-RectangleCopy"></i> <span>猜你喜欢</span> </div> &lt
如何访问HeaderTemplate中的控件
weixin_30466039的博客
03-01 317
在DataGrid的ItemCreated事件中 if (e.Item.ItemType==ListItemType.Header) { ((LinkButton)e.Item.Cells[i].Controls[1]).Text="haha"; } 1.datagrid.Controls(0) 是{System.W...
上拉加载下拉刷新---SmartRefreshLayout
liu362732346的博客
10-15 4266
    SmartRefreshLayout链接： https://github.com/scwang90/SmartRefreshLayout 一.主要属性 //下面示例中的值等于默认值 RefreshLayout refreshLayout = (RefreshLayout)findViewById(R.id.refreshLayout); refre...
根据文本内容的长度动态的设置TextView的高度
kg_2012的博客
06-28 4715
在做Android开发中，经常需要根据文本内容的长度和手机屏幕的大小动态的设置TextView的高度。设置TextView的高度后，再设置TextView可以滑动，就可以展示完整的文本，但是TextView的滑动效果不流畅；可以给TextView外层包一个ScrollView，通过设置ScrollView的高度，通过ScrollView的滑动展示完整的文本内容。 根据文本内容的长度设置TextVi
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值