一探究竟之PullZoomView

最新推荐文章于 2017-07-17 12:03:56 发布
最新推荐文章于 2017-07-17 12:03:56 发布
阅读量2.1k 收藏
点赞数 2
分类专栏： Android 框架剖析 文章标签： 开源框架 开源框架解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012874222/article/details/51226089
版权

我们先看效果图:

       




这是仿苹果app的一种下拉head拉伸的效果，这种弹性伸缩能给用户一种良好的体验，因此我们在各大主流app上也能看的到这种效果，而PullZoomView是一款在安卓能实现上述效果并且能实现视差效果的开源框架。今天让我们来对此框架一探究竟！


先来看看项目结构：

    

此项目包括了：IPollToZoom，一个接口类定义了一些供实例对象调用的方法；  PullToZoomBase，一个基类定义了一些公共方法；然后

PullToZoomListViewEx 与 PullToZoomScrollViewEx 分别是继承base所派生的两个子类。
 

 

那么我们就先来看看PullToZoomBase基类：
 

 

package com.yinbaner.view;

import android.app.Activity;
import android.content.Context;
import android.content.res.TypedArray;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.widget.LinearLayout;

import com.yinbaner.wifibox.R;


public abstract class PullToZoomBase<T extends View> extends LinearLayout implements IPullToZoom<T> {
    private static final float FRICTION = 2.0f;
    protected T mRootView;
    protected View mHeaderView;//头部View
    protected View mZoomView;//缩放拉伸View

    protected int mScreenHeight;
    protected int mScreenWidth;

    private boolean isZoomEnabled = true;
    private boolean isParallax = true;
    private boolean isZooming = false;
    private boolean isHideHeader = false;

    private int mTouchSlop;
    private boolean mIsBeingDragged = false;
    private float mLastMotionY;
    private float mLastMotionX;
    private float mInitialMotionY;
    private OnPullZoomListener onPullZoomListener;

    public PullToZoomBase(Context context) {
        this(context, null);
    }

    public PullToZoomBase(Context context, AttributeSet attrs) {
        super(context, attrs);

        init(context, attrs);
    }

    private void init(Context context, AttributeSet attrs) {
        setGravity(Gravity.CENTER);

        ViewConfiguration config = ViewConfiguration.get(context);
        mTouchSlop = config.getScaledTouchSlop();//滑动标准

        DisplayMetrics localDisplayMetrics = new DisplayMetrics();
        ((Activity) getContext()).getWindowManager().getDefaultDisplay().getMetrics(localDisplayMetrics);
        mScreenHeight = localDisplayMetrics.heightPixels; //屏幕像素h
        mScreenWidth = localDisplayMetrics.widthPixels; //屏幕像素w

        // Refreshable View
        // By passing the attrs, we can add ListView/GridView params via XML
        mRootView = createRootView(context, attrs); //抽象方法，子类实现返回子类创建的mRootView

        if (attrs != null) {
            LayoutInflater mLayoutInflater = LayoutInflater.from(getContext());
            //初始化状态View
            TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.PullToZoomView);

            int zoomViewResId = a.getResourceId(R.styleable.PullToZoomView_zoomView, 0);//获得xml中定义的zommView ID
            if (zoomViewResId > 0) {
                mZoomView = mLayoutInflater.inflate(zoomViewResId, null, false);
            }

            int headerViewResId = a.getResourceId(R.styleable.PullToZoomView_headerView, 0);//获得xml中定义的headerView ID
            if (headerViewResId > 0) {
                mHeaderView = mLayoutInflater.inflate(headerViewResId, null, false);
            }

            isParallax = a.getBoolean(R.styleable.PullToZoomView_isHeaderParallax, true);//获得xml中定义的是否支持视差

            // Let the derivative classes have a go at handling attributes, then
            // recycle them...
            handleStyledAttributes(a);//传入TypedArray，让子类获取到xml中定义的contentView ID
            a.recycle();
        }
        addView(mRootView, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
    }

    public void setOnPullZoomListener(OnPullZoomListener onPullZoomListener) {
        this.onPullZoomListener = onPullZoomListener;
    }

    @Override
    public T getPullRootView() {
        return mRootView;
    }

    @Override
    public View getZoomView() {
        return mZoomView;
    }

    @Override
    public View getHeaderView() {
        return mHeaderView;
    }

    @Override
    public boolean isPullToZoomEnabled() {
        return isZoomEnabled;
    }

    @Override
    public boolean isZooming() {
        return isZooming;
    }

    @Override
    public boolean isParallax() {
        return isParallax;
    }

    @Override
    public boolean isHideHeader() {
        return isHideHeader;
    }

    public void setZoomEnabled(boolean isZoomEnabled) {
        this.isZoomEnabled = isZoomEnabled;
    }

    public void setParallax(boolean isParallax) {
        this.isParallax = isParallax;
    }

    public void setHideHeader(boolean isHideHeader) {//header显示才能Zoom
        this.isHideHeader = isHideHeader;
    }

    private VelocityTracker mVelocityTracker;
    @Override
    public boolean onInterceptTouchEvent(MotionEvent event) {
        if (!isPullToZoomEnabled() || isHideHeader()) {
            return false;
        }

        final int action = event.getAction();

        if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
            mIsBeingDragged = false;
            return false;
        }

        if (action != MotionEvent.ACTION_DOWN && mIsBeingDragged) {
            return true;
        }

        switch (action) {
            case MotionEvent.ACTION_MOVE: {
                if (isReadyForPullStart()) {//如果处于顶部
                    final float y = event.getY(), x = event.getX();
                    final float diff, oppositeDiff, absDiff;

                    // We need to use the correct values, based on scroll
                    // direction
                    diff = y - mLastMotionY;
                    oppositeDiff = x - mLastMotionX;
                    absDiff = Math.abs(diff);
                    //如果是滑动，并且是垂直滑动
                    if (absDiff > mTouchSlop && absDiff > Math.abs(oppositeDiff)) {
                        if (diff >= 1f && isReadyForPullStart()) {//如果处于顶部
                            mLastMotionY = y;
                            mLastMotionX = x;
                            mIsBeingDragged = true;
                        }
                    }
                }
                break;
            }
            case MotionEvent.ACTION_DOWN: {
                if (isReadyForPullStart()) {//如果处于顶部
                    mLastMotionY = mInitialMotionY = event.getY();
                    mIsBeingDragged = false;
                }
                break;
            }
        }

        return mIsBeingDragged;
    }
    @Override
    public boolean onTouchEvent( MotionEvent event) {
        if (!isPullToZoomEnabled() || isHideHeader()) {
            return false;
        }

        if (event.getAction() == MotionEvent.ACTION_DOWN && event.getEdgeFlags() != 0) {//getEdgeFlags触到边缘
            return false;
        }

        switch (event.getAction()) {
            case MotionEvent.ACTION_MOVE: {
                if (mIsBeingDragged) {
                    mLastMotionY = event.getY();
                    mLastMotionX = event.getX();
                    pullEvent();//下拉事件处理
                    isZooming = true;
                    return true;
                }
                break;
            }

            case MotionEvent.ACTION_DOWN: {
                if (isReadyForPullStart()) {
                    mLastMotionY = mInitialMotionY = event.getY();
                    return true;
                }
                break;
            }

            case MotionEvent.ACTION_CANCEL:
            case MotionEvent.ACTION_UP: {
                if (mIsBeingDragged) {
                    mIsBeingDragged = false;
                    // If we're already refreshing, just scroll back to the top
                    if (isZooming()) {//                  ↑
                    //我发现这个注释是经典的下拉刷新框架PulToRefresh里面的，由此可以看出此框架有借鉴了PulToRefresh的思想
                        smoothScrollToTop();//调用子类的缩回逻辑
                        if (onPullZoomListener != null) {
                            onPullZoomListener.onPullZoomEnd();
                        }
                        isZooming = false;
                        return true;
                    }
                    return true;
                }
                break;
            }
        }
        return false;
    }

    private void pullEvent() {
        final int newScrollValue;
        final float initialMotionValue, lastMotionValue;

        initialMotionValue = mInitialMotionY; //开始按下的Y坐标
        lastMotionValue = mLastMotionY;//滑动移动的Y坐标
        //当放大head时候,随时的计算手指滑动的 y距离/2
        newScrollValue = Math.round(Math.min(initialMotionValue - lastMotionValue, 0) / FRICTION);
        //调用子类放大逻辑,传入差值
        pullHeaderToZoom(newScrollValue);
        if (onPullZoomListener != null) {
            onPullZoomListener.onPullZooming(newScrollValue);
        }
    }

    protected abstract void pullHeaderToZoom(int newScrollValue);

    public abstract void setHeaderView(View headerView);

    public abstract void setZoomView(View zoomView);

    protected abstract T createRootView(Context context, AttributeSet attrs);

    protected abstract void smoothScrollToTop();

    protected abstract boolean isReadyForPullStart();

    public interface OnPullZoomListener {
        void onPullZooming(int newScrollValue);

        void onPullZoomEnd();
    }
}

 

 必要的地方都做了注释，大体上是实现了接口，重写了一些外部操作的方法，定义了一些抽象方法，用于从子类获取到返回的结果，并且根据一些条件做了事件的拦截和处理和通过MotionEvent计算出处于顶部的时候下拉的距离，传给子类做head高度拉伸处理。 

 

再来看看 PullToZoomScrollViewEx
 

 

package com.yinbaner.view;

import android.content.Context;
import android.content.res.TypedArray;
import android.os.SystemClock;
import android.util.AttributeSet;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.Interpolator;
import android.widget.FrameLayout;
import android.widget.LinearLayout;
import android.widget.ScrollView;

import com.yinbaner.wifibox.R;


public class PullToZoomScrollViewEx extends PullToZoomBase<ScrollView> {
    private static final String TAG = PullToZoomScrollViewEx.class.getSimpleName();
    private boolean isCustomHeaderHeight = false;
    private FrameLayout mHeaderContainer;
    private LinearLayout mRootContainer;
    private View mContentView;
    private int mHeaderHeight;
    private ScalingRunnable mScalingRunnable;

    private static final Interpolator sInterpolator = new Interpolator() {
        @Override
        public float getInterpolation(float paramAnonymousFloat) {
            float f = paramAnonymousFloat - 1.0F;
            return 1.0F + f * (f * (f * (f * f)));
        }
    };

    public PullToZoomScrollViewEx(Context context) {
        this(context, null);
    }

    public PullToZoomScrollViewEx(Context context, AttributeSet attrs) {
        super(context, attrs);
        mScalingRunnable = new ScalingRunnable();
        ((InternalScrollView) mRootView).setOnScrollViewChangedListener(new OnScrollViewChangedListener() {
            @Override
            public void onInternalScrollChanged(int left, int top, int oldLeft, int oldTop) {
                if (isPullToZoomEnabled() && isParallax()) {//视差效果实现代码块，即是滑动scrollView的时候同时移动mHeaderContainer
                    Log.d(TAG, "onScrollChanged --> getScrollY() = " + mRootView.getScrollY());
                    float f = mHeaderHeight - mHeaderContainer.getBottom() + mRootView.getScrollY();
                    Log.d(TAG, "onScrollChanged --> f = " + f);
                    if(osc != null)
                    osc.OnScrollChangeListener(f);//若实现了监听，则回调
                    if ((f > 0.0F) && (f < mHeaderHeight)) {
                        int i = (int) (0.65D * f);
                        mHeaderContainer.scrollTo(0, -i);//两者移动距离之商为0.65，所以产生视差效果
                    } else if (mHeaderContainer.getScrollY() != 0) {
                        mHeaderContainer.scrollTo(0, 0);//移动mHeaderContainer
                    }
                }
            }

			@Override
			public void OnScrollChangeListener(float f) {
				// TODO Auto-generated method stub
				
			}
        });
    }

    @Override
    protected void pullHeaderToZoom(int newScrollValue) {//放大逻辑
        Log.d(TAG, "pullHeaderToZoom --> newScrollValue = " + newScrollValue);
        Log.d(TAG, "pullHeaderToZoom --> mHeaderHeight = " + mHeaderHeight);
        if (mScalingRunnable != null && !mScalingRunnable.isFinished()) {
            mScalingRunnable.abortAnimation();
        }
        //，根据传入的差值动态改变高度
        ViewGroup.LayoutParams localLayoutParams = mHeaderContainer.getLayoutParams(); //获取到mHeaderContainer的LayoutParams
        localLayoutParams.height = Math.abs(newScrollValue) + mHeaderHeight;//改变高度
        mHeaderContainer.setLayoutParams(localLayoutParams);//设置新的LayoutParams

        if (isCustomHeaderHeight) {
            ViewGroup.LayoutParams zoomLayoutParams = mZoomView.getLayoutParams();
            zoomLayoutParams.height = Math.abs(newScrollValue) + mHeaderHeight;
            mZoomView.setLayoutParams(zoomLayoutParams);
        }
    }

    /**
     * 是否显示headerView
     *
     * @param isHideHeader true: show false: hide
     */
    @Override
    public void setHideHeader(boolean isHideHeader) {
        if (isHideHeader != isHideHeader() && mHeaderContainer != null) {
            super.setHideHeader(isHideHeader);
            if (isHideHeader) {
                mHeaderContainer.setVisibility(GONE);
            } else {
                mHeaderContainer.setVisibility(VISIBLE);
            }
        }
    }
    /**
     * 动态设置headerView
     *
     * @param headerView
     */
    @Override
    public void setHeaderView(View headerView) {
        if (headerView != null) {
            mHeaderView = headerView;
            updateHeaderView();
        }
    }
    /**
     * 动态设置zoomView
     *
     * @param zoomView
     */
    @Override
    public void setZoomView(View zoomView) {
        if (zoomView != null) {
            mZoomView = zoomView;
            updateHeaderView();
        }
    }
    /**
     * 更新HeaderView
     */
    private void updateHeaderView() {
        if (mHeaderContainer != null) {
            mHeaderContainer.removeAllViews();

            if (mZoomView != null) {
                mHeaderContainer.addView(mZoomView);
            }

            if (mHeaderView != null) {
                mHeaderContainer.addView(mHeaderView);
            }
        }
    }
    /**
     * 动态设置contentView
     *
     * @param contentView
     */
    public void setScrollContentView(View contentView) {
        if (contentView != null) {
            if (mContentView != null) {
                mRootContainer.removeView(mContentView);
            }
            mContentView = contentView;
            mRootContainer.addView(mContentView);
        }
    }
    /**
     * 实现父类的抽象方法，用于返回scrollView给父类
     *
     */
    @Override
    protected ScrollView createRootView(Context context, AttributeSet attrs) {
        ScrollView scrollView = new InternalScrollView(context, attrs);
        scrollView.setId(R.id.scrollview);
        return scrollView;
    }
    /**
     * 伸缩之后的回弹
     */
    @Override
    protected void smoothScrollToTop() {
        Log.d(TAG, "smoothScrollToTop --> ");
        mScalingRunnable.startAnimation(200L);
    }
    /**
     * 是否除于顶部
     */
    @Override
    protected boolean isReadyForPullStart() {
        return mRootView.getScrollY() == 0;
    }

    @Override //初始化view
    public void handleStyledAttributes(TypedArray a) {
        mRootContainer = new LinearLayout(getContext());
        mRootContainer.setOrientation(LinearLayout.VERTICAL);
        mHeaderContainer = new FrameLayout(getContext());

        if (mZoomView != null) {
            mHeaderContainer.addView(mZoomView);
        }
        if (mHeaderView != null) {
            mHeaderContainer.addView(mHeaderView);
        }
        int contentViewResId = a.getResourceId(R.styleable.PullToZoomView_contentView, 0);
        if (contentViewResId > 0) {
            LayoutInflater mLayoutInflater = LayoutInflater.from(getContext());
            mContentView = mLayoutInflater.inflate(contentViewResId, null, false);
        }

        mRootContainer.addView(mHeaderContainer);
        if (mContentView != null) {
            mRootContainer.addView(mContentView);
        }

        mRootContainer.setClipChildren(false);//允许子View超出范围
        mHeaderContainer.setClipChildren(false);

        mRootView.addView(mRootContainer);
    }

    /**
     * 设置HeaderView高度
     *
     * @param width
     * @param height
     */
    public void setHeaderViewSize(int width, int height) {
        if (mHeaderContainer != null) {
            Object localObject = mHeaderContainer.getLayoutParams();
            if (localObject == null) {
                localObject = new ViewGroup.LayoutParams(width, height);
            }
            ((ViewGroup.LayoutParams) localObject).width = width;
            ((ViewGroup.LayoutParams) localObject).height = height;
            mHeaderContainer.setLayoutParams((ViewGroup.LayoutParams) localObject);
            mHeaderHeight = height;
            isCustomHeaderHeight = true;
        }
    }

    /**
     * 设置HeaderView LayoutParams
     *
     * @param layoutParams LayoutParams
     */
    public void setHeaderLayoutParams(LinearLayout.LayoutParams layoutParams) {
        if (mHeaderContainer != null) {
            mHeaderContainer.setLayoutParams(layoutParams);
            mHeaderHeight = layoutParams.height;
            isCustomHeaderHeight = true;
        }
    }
    @Override
    protected void onLayout(boolean paramBoolean, int paramInt1, int paramInt2,
                            int paramInt3, int paramInt4) {
        super.onLayout(paramBoolean, paramInt1, paramInt2, paramInt3, paramInt4);
        Log.d(TAG, "onLayout --> ");
        if (mHeaderHeight == 0 && mZoomView != null) {
            mHeaderHeight = mHeaderContainer.getHeight();
        }
    }
    /**
     * 通过调用 startAnimation
     * 来调用 ScalingRunnable的run()方法里面的回弹逻辑
     */
    class ScalingRunnable implements Runnable {
        protected long mDuration;
        protected boolean mIsFinished = true;
        protected float mScale;
        protected long mStartTime;

        ScalingRunnable() {
        }

        public void abortAnimation() {
            mIsFinished = true;
        }

        public boolean isFinished() {
            return mIsFinished;
        }

        public void run() {
            if (mZoomView != null) {
                if ((!mIsFinished) && (mScale > 1.0D)) {
                    float f1 = ((float) SystemClock.currentThreadTimeMillis() - (float) mStartTime) / (float) mDuration;
                    float f2 = mScale - (mScale - 1.0F) * PullToZoomScrollViewEx.sInterpolator.getInterpolation(f1);
                    Log.d(TAG, "ScalingRunnable --> f2 = " + f2);
                    if (f2 > 1.0F) {
                        ViewGroup.LayoutParams localLayoutParams = mHeaderContainer.getLayoutParams();
                        localLayoutParams.height = ((int) (f2 * mHeaderHeight));
                        mHeaderContainer.setLayoutParams(localLayoutParams);//动态改变高度
                        if (isCustomHeaderHeight) {
                            ViewGroup.LayoutParams zoomLayoutParams = mZoomView.getLayoutParams();
                            zoomLayoutParams.height = ((int) (f2 * mHeaderHeight));
                            mZoomView.setLayoutParams(zoomLayoutParams);
                        }
                        post(this);
                        return;
                    }
                    mIsFinished = true;
                }
            }
        }

        public void startAnimation(long paramLong) {//传入duration
            if (mZoomView != null) {
                mStartTime = SystemClock.currentThreadTimeMillis();
                mDuration = paramLong;
                mScale = ((float) (mHeaderContainer.getBottom()) / mHeaderHeight);
                mIsFinished = false;
                post(this);
            }
        }
    }
    //重写了ScrollView并且添加了滑动监听方法
    protected class InternalScrollView extends ScrollView {
        private OnScrollViewChangedListener onScrollViewChangedListener;

        public InternalScrollView(Context context) {
            this(context, null);
        }

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

        public void setOnScrollViewChangedListener(OnScrollViewChangedListener onScrollViewChangedListener) {
            this.onScrollViewChangedListener = onScrollViewChangedListener;
        }

        @Override
        protected void onScrollChanged(int l, int t, int oldl, int oldt) {
            super.onScrollChanged(l, t, oldl, oldt);
            if (onScrollViewChangedListener != null) {
                onScrollViewChangedListener.onInternalScrollChanged(l, t, oldl, oldt);
            }
        }
    }
    //定义的滑动的回调接口
    private OnScrollViewChangedListener osc;
    public void setOnScrollViewChangedListener(OnScrollViewChangedListener osc){
	    this.osc = osc;
	  }
    public interface OnScrollViewChangedListener {
        public void onInternalScrollChanged(int left, int top, int oldLeft, int oldTop);
        public void OnScrollChangeListener(float f);
    }
}

 

 

 

 

主要结论
 

①根据传入的滑动距离/2的值加上原mHeaderContainer的高度设置到它的layoutparams中来达到放大的效果；
 

②视差效果是两个view同方向上移动速度的差别所产生的效果.
 

 
由于篇幅原因，这里只贴出对  
PullToZoom 
ScrollViewEx 的主要注释，理解了PullToZoomScrollViewEx ， 
PullToZoomListViewEx也是同理的。 

 

想要看完整代码及demo，请链至github→         https://github.com/Frank-Zhu/PullZoomView  
 


 
 


                

        

        

    

  


    

      

        

            

              
                
                  y-grey
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
C语言中的signed和unsigned的使用以及整型提升一探究竟

				
			

			

				

					qq_45219263的博客
				

				

					03-24
					
					4514
					
				

			

		

		

			
				
在C语言中，signed表示有符号的，是默认的，可以输出整数、负数
unsigned是无符号的，不能表示数值的征服
在整型提升的时候，如两个char型的字符相加(char型是一个字节)，而计算机内部的操作数的字符长度一般为int型即四个字节。因此我们没有办法直接将两个char型的字符进行相加，就必须要进行整型提升。
输入如下代码会输出什么结果呢？
#include<stdio.h> 
int main()
{
	char a=-1;
	signed char b=-1;
	unsigned ch

			
		

	



                

              
                



	

		

			

				
					
Android-PullZoomScrollView滑动缩放顶部视图

				
			

			

				

					08-13
				

			

		

		

			
				
PullZoomScrollView 滑动缩放顶部视图

			
		

	



                


  
              

                


	

		

			

				
					
Android自定义控件——PullZoomView

				
			

			

				

					monoCuty的专栏
				

				

					03-18
					
					463
					
				

			

		

		

			
				
本文介绍PullZoomView的简单实现，如图：




就是通过下拉ListView或者ScrollView或者更多的View如GridView，RecycleView等等，的时候对Header有一个放大缩小的效果
实现思路就是根据所需要封装的不同的下拉控件来做不同的实现，比如：
ListView：该控件本身有添加Header的功能，我们只需做简单的处理就可以用了，在满足一定条件

			
		

	





	

		

			

				
					
Android PullZoomView：PullToZoomScrollViewEx（2）

				
			

			

				

					Zhang Phil
				

				

					12-07
					
					4487
					
				

			

		

		

			
				

Android PullZoomView：PullToZoomScrollViewEx（2）
在附录文章1中，介绍了Android PullZoomView在ListView中的实现：PullToZoomListViewEx，事实上，Android PullZoomView亦可在ScrollView实现，Android PullZoomView在ScrollView的实现是：PullTo

			
		

	



		

			
		



	

		

			

				
					
PullZoomView 支持ScollView和ListView的上方View随下拉放大效果

				
			

			

				

					08-03
				

			

		

		

			
				
简单使用教程
http://blog.csdn.net/zhouhuakang/article/details/47251587

			
		

	





	

		

			

				
					
PullToZoomView的使用

				
			

			

				

					FinyGao
				

				

					05-27
					
					1303
					
				

			

		

		

			
				
这个开源框架的使用主要用到的是PullToZoomListViewEx和PullToZoomScrollViewEx的2个类库，PullToZoomListViewEx这个是ListView的下拉效果，暂时没用到，需要的话可能要自己去研究下了。 PullToZoomScrollViewEx这个是ScrollView，用的比较多，我们经常有用户信息界面、内容区域，都是信息量比较大的，会涉及到下拉之类

			
		

	





	

		

			

				
					
CRC校验一探究竟1

				
			

			

				

					08-03
				

			

		

		

			
				
1. 原理 . 2. 长除法 c 语言实现 . 3. 线性移位寄存器电路实现 . 4. 初值问题 . 5. 并行处理 . 6. CRC 的种类 . 1. 原理

			
		

	





	

		

			

				
					
普普艺术一探究竟

				
			

			

				

					09-02
				

			

		

		

			
				
普普艺术一探究竟

			
		

	





	

		

			

				
					
prithvijitguha.github.io：我的个人网站。 托管在githubpages上。 一探究竟！

				
			

			

				

					02-17
				

			

		

		

			
				
＃pj12342013.github.io  我的个人网站。 看一看！

			
		

	





	

		

			

				
					
行业分类-设备装置-一种便携式探照灯.zip

				
			

			

				

					08-19
				

			

		

		

			
				
《行业分类-设备装置-一种便携式探照灯》  在现代科技发展的背景下，便携式探照灯作为一款重要的设备装置，广泛应用于各种行业，包括但不限于户外探险、应急救援、工矿作业等。本文件主要围绕“一种便携式探照灯”...

			
		

	





	

		

			

				
					
PullBezierZoomView-贝塞尔曲线下拉放大背景图效果.zip

				
			

			

				

					09-24
				

			

		

		

			
				
该控件效果基于PullZoomView源码改动的而来,感谢Frank-Zhu的开源代码.该控件具有下拉放大背景图和贝塞尔曲线的效果.

			
		

	





	

		

			

				
					
PullToZoomScrollView

				
			

			

				

					08-13
				

			

		

		

			
				
下拉自动放大头部View,而且头部的View内部控件不会变形。可以查看http://jiyiren.github.io博客

			
		

	





	

		

			

				
					
pullzoomview头部图片下拉缩放功能

				
			

			

				

					08-13
				

			

		

		

			
				
NULL
博文链接：https://274137570-qq-com.iteye.com/blog/2302894

			
		

	





	

		

			

				
					
拓展自定义下拉缩放header的组件PullZoomView，增加对listView的下拉刷新和上拉更多

				
			

			

				

					08-10
				

			

		

		

			
				
本组件来源于Github开源框架：PullZoomView

我只是在该控件之上对ListView拓展了下拉刷新和上拉更多的功能呢；

			
		

	





	

		

			

				
					
PullToZoomView兼容RecyclerView瀑布流布局

				
			

			

				

					11-19
				

			

		

		

			
				
PullZoomView是个不错的伸缩效果头部的开源控件，可以使用ListView、ScrollView和RecyclerView做出头部伸缩效果，但是不支持RecyclerView瀑布流布局，这里自己兼容RecyclerView瀑布流布局

			
		

	





	

		

			

				
					
开源项目PullToZoomView使用

				
			

			

				

					Small_Lee的博客
				

				

					07-22
					
					752
					
				

			

		

		

			
				
public class MainActivity extends AppCompatActivity {
    private List<String> datas;
    private RecyclerView recyclerView;
    private CustomScrollView scrollView;
    private RelativeLayout relative

			
		

	





	

		

			

				
					
PullZoomView使用

				
			

			

				

					flysweetegg的博客
				

				

					07-17
					
					556
					
				

			

		

		

			
				
https://github.com/jeasonlzy/PullZoomView

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值