仿美团下拉刷新动画

最新推荐文章于 2024-04-22 16:31:53 发布
最新推荐文章于 2024-04-22 16:31:53 发布
阅读量138 收藏
点赞数
文章标签： 移动开发 java
原文链接：http://www.cnblogs.com/sidxu/p/4940371.html
版权

经常使用美团，感觉下拉刷新动画挺好玩的，抽空也做了一个，图片资源是网上获取，先看效果：
开始下拉动画
正在刷新动画
本文所实现的功能是在网上流传的下拉刷新框架（PullToRefreshView.java），然后修改而得的，只在分享经验，代码如下：

package refresh_view;

import com.example.pullrefersh.R;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.graphics.drawable.AnimationDrawable;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.LinearInterpolator;
import android.view.animation.RotateAnimation;
import android.widget.AdapterView;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ProgressBar;
import android.widget.ScrollView;
import android.widget.TextView;

public class PullToRefreshView extends LinearLayout{

    private static final int PULL_TO_REFRESH = 2;
    private static final int RELEASE_TO_REFRESH = 3;
    private static final int REFRESHING = 4;
    private static final int PULL_UP_STATE = 0;
    private static final int PULL_DOWN_STATE = 1;
    private static final int HEADER_OFFERT = 20;
    private boolean enablePullTorefresh = true;
    private boolean enablePullLoadMoreDataStatus = true;
    private int mLastMotionY;
    private boolean mLock;
    private boolean isFooter;
    private View mHeaderView;
    private View mFooterView;
    private LayoutParams params;
    private AdapterView<?> mAdapterView;
    private ScrollView mScrollView;
    private int mHeaderViewHeight;
    private int mFooterViewHeight;

    private ImageView mHeaderImageView;
    private ImageView mFooterImageView;
    private TextView mFooterTextView;
    private ProgressBar mFooterProgressBar;
    private LayoutInflater mInflater;
    private int mHeaderState;
    private int mFooterState;
    private int mPullState;
    private RotateAnimation mFlipAnimation;
    private RotateAnimation mReverseFlipAnimation;
    private OnFooterRefreshListener mOnFooterRefreshListener;
    private OnHeaderRefreshListener mOnHeaderRefreshListener;
    private float mCurrentDragPercent;
    private boolean isShow = false;
    private Drawable showDrawable;

    public PullToRefreshView(Context context) {
        super(context);
        init();
    }

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

    private void init() {
        setOrientation(LinearLayout.VERTICAL);  
        // Load all of the animations we need in code rather than through XML  
        mFlipAnimation = new RotateAnimation(0, -180,  
                RotateAnimation.RELATIVE_TO_SELF, 0.5f,  
                RotateAnimation.RELATIVE_TO_SELF, 0.5f);  
        mFlipAnimation.setInterpolator(new LinearInterpolator());  
        mFlipAnimation.setDuration(150);
        mFlipAnimation.setFillAfter(true);
        mReverseFlipAnimation = new RotateAnimation(-180, 0,  
                RotateAnimation.RELATIVE_TO_SELF, 0.5f,  
                RotateAnimation.RELATIVE_TO_SELF, 0.5f);  
        mReverseFlipAnimation.setInterpolator(new LinearInterpolator());  
        mReverseFlipAnimation.setDuration(150);  
        mReverseFlipAnimation.setFillAfter(true);  
        mHeaderState = 2;
        mInflater = LayoutInflater.from(getContext());
        addHeaderView();
    }
    /**
     * 头部刷新视图
     */
    private void addHeaderView() {
        mHeaderView = mInflater.inflate(R.layout.refresh_header, this, false);

        mHeaderImageView = (ImageView) mHeaderView.findViewById(R.id.pull_to_refresh_image);
        measureView(mHeaderView);
        mHeaderViewHeight = mHeaderView.getMeasuredHeight();
        params = new LayoutParams(LayoutParams.MATCH_PARENT, mHeaderViewHeight);
        params.topMargin = -(mHeaderViewHeight);
        addView(mHeaderView, params);
    }

    private void measureView(View child) {
        ViewGroup.LayoutParams p = child.getLayoutParams();
        if (p == null) {
            p = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT);
        }

        int childWidthSpec = ViewGroup.getChildMeasureSpec(0, 0 + 0, p.width);
        int lpHeight = p.height;
        int childHeightSpec;
        if (lpHeight > 0) {
            childHeightSpec = MeasureSpec.makeMeasureSpec(lpHeight, MeasureSpec.EXACTLY);
        } else {
            childHeightSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
        }
        child.measure(childWidthSpec, childHeightSpec);
    }

    /**
     * 尾部刷新视图
     */
    private void addFooterView() {
        mFooterView = mInflater.inflate(R.layout.refresh_footer, this, false);
        mFooterImageView = (ImageView) mFooterView.findViewById(R.id.pull_to_load_image);
        mFooterTextView = (TextView) mFooterView.findViewById(R.id.pull_to_load_text);
        mFooterProgressBar = (ProgressBar) mFooterView.findViewById(R.id.pull_to_load_progress);

        measureView(mFooterView);
        mFooterViewHeight = mFooterView.getMeasuredHeight();
        LayoutParams params = new LayoutParams(LayoutParams.MATCH_PARENT, mFooterViewHeight);
        addView(mFooterView, params);
    }

    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();
        // footer view 鍦ㄦ娣诲姞淇濊瘉娣诲姞鍒發inearlayout涓殑鏈�悗
        addFooterView();
        initContentAdapterView();
    }

    private void initContentAdapterView() {
        int count = getChildCount();
        if (count < 3) {
            throw new IllegalArgumentException("this layout must contain 3 child views,and AdapterView or ScrollView must in the second position!");
        }
        View view = null;
        for (int i = 0; i < count - 1; ++i) {
            view = getChildAt(i);
            if (view instanceof AdapterView<?>) {
                mAdapterView = (AdapterView<?>) view;
            }
            if (view instanceof ScrollView) {
                // finish later
                mScrollView = (ScrollView) view;
                break;
            }
        }
        if (mAdapterView == null && mScrollView == null) {
            throw new IllegalArgumentException("must contain a AdapterView or ScrollView in this layout!");
        }
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent e) {
        int y = (int) e.getRawY();
        switch (e.getAction()) {
        case MotionEvent.ACTION_DOWN:
            mLastMotionY = y;
            break;
        case MotionEvent.ACTION_MOVE:
            int deltaY = y - mLastMotionY;
            if (isRefreshViewScroll(deltaY)) {
                return true;
            }
            break;
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL:
            break;
        }
        return false;
    }

    private boolean isRefreshViewScroll(int deltaY) {
        if (mHeaderState == REFRESHING || mFooterState == REFRESHING) {
            return false;
        }
        if (mAdapterView != null) {
            if (deltaY > 0) {
                if (!enablePullTorefresh) {
                    return false;
                }
                View child = mAdapterView.getChildAt(0);
                if (child == null) {
                    return false;
                }
                if (mAdapterView.getFirstVisiblePosition() == 0 && child.getTop() == 0) {
                    mPullState = PULL_DOWN_STATE;
                    return true;
                }
                int top = child.getTop();
                int padding = mAdapterView.getPaddingTop();
                if (mAdapterView.getFirstVisiblePosition() == 0 && Math.abs(top - padding) <= 11) {
                    mPullState = PULL_DOWN_STATE;
                    return true;
                }

            } else if (deltaY < 0) {
                if (!enablePullLoadMoreDataStatus) {
                    return false;
                }
                View lastChild = mAdapterView.getChildAt(mAdapterView.getChildCount() - 1);
                if (lastChild == null) {
                    return false;
                }
                if (lastChild.getBottom() <= getHeight() && mAdapterView.getLastVisiblePosition() == mAdapterView.getCount() - 1) {
                    mPullState = PULL_UP_STATE;
                    return true;
                }
            }
        }
        if (mScrollView != null) {
            View child = mScrollView.getChildAt(0);
            if (deltaY > 0 && mScrollView.getScrollY() == 0) {
                mPullState = PULL_DOWN_STATE;
                return true;
            } else if (deltaY < 0 && child.getMeasuredHeight() <= getHeight() + mScrollView.getScrollY()) {
                mPullState = PULL_UP_STATE;
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (mLock) {
            return true;
        }
        int y = (int) event.getRawY();
        switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN:
            break;
        case MotionEvent.ACTION_MOVE:
            int deltaY = y - mLastMotionY;
            if (mPullState == PULL_DOWN_STATE) {
                headerPrepareToRefresh(deltaY);
            } else if (mPullState == PULL_UP_STATE && isFooter) {
                footerPrepareToRefresh(deltaY);
            }          
            mLastMotionY = y;
            changeDrawable();//处理头部下拉刷新动画
            break;
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL:
            isShow = false;
            int topMargin = getHeaderTopMargin();
            if (mPullState == PULL_DOWN_STATE) {
                if (topMargin >= 0) {
                    headerRefreshing();
                } else {
                    setHeaderTopMargin(-mHeaderViewHeight);
                }
            } else if (mPullState == PULL_UP_STATE && isFooter) {
                if (Math.abs(topMargin) >= mHeaderViewHeight + mFooterViewHeight) {
                    footerRefreshing();
                } else {
                    setHeaderTopMargin(-mHeaderViewHeight);
                }
            }
            break;
        }
        return super.onTouchEvent(event);
    }

    private void headerPrepareToRefresh(int deltaY) {
        int newTopMargin = changingHeaderViewTopMargin(deltaY);
        if (newTopMargin >= 0 && mHeaderState != RELEASE_TO_REFRESH) {
            mHeaderState = RELEASE_TO_REFRESH;
        } else if (newTopMargin < 0 && newTopMargin > -mHeaderViewHeight && mHeaderState != PULL_TO_REFRESH) {
            mHeaderState = PULL_TO_REFRESH;
        }
    }

    private void footerPrepareToRefresh(int deltaY) {
        int newTopMargin = changingHeaderViewTopMargin(deltaY);
        if (Math.abs(newTopMargin) >= (mHeaderViewHeight + mFooterViewHeight) && mFooterState != RELEASE_TO_REFRESH) {
            mFooterTextView.setText(R.string.pull_to_refresh_footer_release_label);
            mHeaderImageView.setImageResource(R.drawable.ic_pulltorefresh_arrow);
            mFooterImageView.clearAnimation();
            mFooterImageView.startAnimation(mFlipAnimation);
            mFooterState = RELEASE_TO_REFRESH;
        } else if (Math.abs(newTopMargin) < (mHeaderViewHeight + mFooterViewHeight)) {
            mFooterImageView.clearAnimation();
            mFooterImageView.startAnimation(mFlipAnimation);
            mHeaderImageView.setImageResource(R.drawable.ic_pulltorefresh_arrow_up);
            mFooterTextView.setText(R.string.pull_to_refresh_footer_pull_label);
            mFooterState = PULL_TO_REFRESH;
        }
    }

    private int changingHeaderViewTopMargin(int deltaY) {
        float newTopMargin = params.topMargin + deltaY * 0.3f;
        if (deltaY > 0 && mPullState == PULL_UP_STATE && Math.abs(params.topMargin) <= mHeaderViewHeight) {
            return params.topMargin;
        }
        if (deltaY < 0 && mPullState == PULL_DOWN_STATE && Math.abs(params.topMargin) >= mHeaderViewHeight) {
            return params.topMargin;
        }
        params.topMargin = (int) newTopMargin;
        mHeaderView.setLayoutParams(params);
        invalidate();
        return params.topMargin;
    }

    public void headerRefreshing() {
        mHeaderState = REFRESHING;
        setHeaderTopMargin(0);
        mHeaderImageView.clearAnimation();
        AnimationDrawable drawable = (AnimationDrawable) getResources().getDrawable(R.drawable.meimei_showing);
        mHeaderImageView.setImageDrawable(drawable);
        drawable.start();
        if (mOnHeaderRefreshListener != null) {
            mOnHeaderRefreshListener.onHeaderRefresh(this);
        }
    }

    public void footerRefreshing() {
        mFooterState = REFRESHING;
        int top = mHeaderViewHeight + mFooterViewHeight;
        setHeaderTopMargin(-top);
        mFooterImageView.setVisibility(View.GONE);
        mFooterImageView.clearAnimation();
        mFooterImageView.setImageDrawable(null);
        mFooterProgressBar.setVisibility(View.VISIBLE);
        mFooterTextView.setText(R.string.pull_to_refresh_footer_refreshing_label);
        if (mOnFooterRefreshListener != null) {
            mOnFooterRefreshListener.onFooterRefresh(this);
        }
    }

    private void setHeaderTopMargin(int topMargin) {
        LayoutParams params = (LayoutParams) mHeaderView.getLayoutParams();
        params.topMargin = topMargin;
        mHeaderView.setLayoutParams(params);
        invalidate();
    }

    public void onHeaderRefreshComplete() {
        setHeaderTopMargin(-mHeaderViewHeight);
        mHeaderImageView.setVisibility(View.VISIBLE);
        mHeaderImageView.setImageResource(R.drawable.ic_pulltorefresh_arrow);
        mHeaderState = PULL_TO_REFRESH;
    }

    public void onHeaderRefreshComplete(CharSequence lastUpdated) {
        onHeaderRefreshComplete();
    }

    public void onFooterRefreshComplete() {
        setHeaderTopMargin(-mHeaderViewHeight);
        mFooterImageView.setVisibility(View.VISIBLE);
        mFooterImageView.setImageResource(R.drawable.ic_pulltorefresh_arrow_up);
        mFooterTextView.setText(R.string.pull_to_refresh_footer_pull_label);
        mFooterProgressBar.setVisibility(View.GONE);
        mFooterState = PULL_TO_REFRESH;
    }

    public void onFooterRefreshComplete(int size) {
        if (size > 0) {
            mFooterView.setVisibility(View.VISIBLE);
        } else {
            mFooterView.setVisibility(View.GONE);
        }
        setHeaderTopMargin(-mHeaderViewHeight);
        mFooterImageView.setVisibility(View.VISIBLE);
        mFooterImageView.setImageResource(R.drawable.ic_pulltorefresh_arrow_up);
        mFooterTextView.setText(R.string.pull_to_refresh_footer_pull_label);
        mFooterProgressBar.setVisibility(View.GONE);
        mFooterState = PULL_TO_REFRESH;
    }

    private int getHeaderTopMargin() {
        LayoutParams params = (LayoutParams) mHeaderView.getLayoutParams();
        return params.topMargin;
    }



    public void setOnHeaderRefreshListener(OnHeaderRefreshListener headerRefreshListener) {
        mOnHeaderRefreshListener = headerRefreshListener;
    }

    public void setOnFooterRefreshListener(OnFooterRefreshListener footerRefreshListener) {
        mOnFooterRefreshListener = footerRefreshListener;
    }

    public interface OnFooterRefreshListener {
        public void onFooterRefresh(PullToRefreshView view);
    }

    public interface OnHeaderRefreshListener {
        public void onHeaderRefresh(PullToRefreshView view);
    }

    public boolean isEnablePullTorefresh() {
        return enablePullTorefresh;
    }

    public void setEnablePullTorefresh(boolean enablePullTorefresh) {
        this.enablePullTorefresh = enablePullTorefresh;
    }

    public boolean isEnablePullLoadMoreDataStatus() {
        return enablePullLoadMoreDataStatus;
    }

    public void setEnablePullLoadMoreDataStatus(boolean enablePullLoadMoreDataStatus) {
        this.enablePullLoadMoreDataStatus = enablePullLoadMoreDataStatus;
    }

    public void setFooter(boolean footer){
        isFooter = footer;
    }
    /**
     * 头部刷新动画
     */
    public void changeDrawable() {
        int margin = params.topMargin;
        if(margin < HEADER_OFFERT) {
            mCurrentDragPercent = ((float) mHeaderViewHeight + margin)/(float) mHeaderViewHeight;
            mCurrentDragPercent *= mCurrentDragPercent;

            if(mCurrentDragPercent > 0.02 && mCurrentDragPercent < 0.9) {//下拉过程的动画
                isShow = false;
                if(showDrawable == null)
                    showDrawable = getResources().getDrawable(R.drawable.pull_end_image_frame_00);
                Drawable one = zoomDrawable(showDrawable, mCurrentDragPercent);
                mHeaderImageView.setImageDrawable(one);
            } else if(mCurrentDragPercent >= 0.9 && !isShow) {//刷新过程的动画
                AnimationDrawable drawable = (AnimationDrawable) getResources().getDrawable(R.drawable.meimei_show);
                mHeaderImageView.setImageDrawable(drawable);
                drawable.start();
                isShow = true;
            }
        }
    }
    /**
     * 改变图片的尺寸
     * @param drawable
     * @param s
     * @return
     */
    private Drawable zoomDrawable(Drawable drawable, float s) {
        int width = drawable.getIntrinsicWidth();
        int height = drawable.getIntrinsicHeight();
        Bitmap oldbmp = drawableToBitmap(drawable);// drawable转换成bitmap
        Matrix matrix = new Matrix(); // 创建操作图片用的Matrix对象
        matrix.postScale(s, s); // 设置缩放比例
        if(width <= 0 || height <= 0) return null;
        Bitmap newbmp = Bitmap.createBitmap(oldbmp, 0, 0, width, height, matrix, true); // 建立新的bitmap，其内容是对原bitmap的缩放后的图
        return new BitmapDrawable(getResources(), newbmp); // 把bitmap转换成drawable并返回
    }

    private Bitmap drawableToBitmap(Drawable drawable) {// drawable 转换成bitmap

        BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
        return bitmapDrawable.getBitmap();
    }
}

refresh_header.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="60dp"
    android:gravity="center_horizontal"
    android:orientation="vertical" >

    <ImageView
        android:id="@+id/pull_to_refresh_image"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"
        android:layout_centerHorizontal="true"
        android:scaleType="centerInside"
        android:padding="3dp" />

</RelativeLayout>

refresh_footer.xml代码：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/pull_to_refresh_header"
    android:layout_width="match_parent"
    android:layout_height="60dp" >

    <TextView
        android:id="@+id/pull_to_load_text"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"
        android:text="@string/pull_to_refresh_footer_pull_label"
        android:textColor="@color/black"
        android:textSize="16sp" />

    <ImageView
        android:id="@+id/pull_to_load_image"
        android:layout_width="wrap_content"
        android:layout_height="30dp"
        android:layout_centerVertical="true"
        android:layout_marginRight="8dp"
        android:layout_toLeftOf="@id/pull_to_load_text"
        android:contentDescription="@string/app_name"
        android:scaleType="centerInside"
        android:src="@drawable/ic_pulltorefresh_arrow_up" />

    <ProgressBar
        android:id="@+id/pull_to_load_progress"
        android:layout_width="30dip"
        android:layout_height="30dip"
        android:layout_centerVertical="true"
        android:layout_gravity="center"
        android:layout_marginRight="8dp"
        android:layout_toLeftOf="@id/pull_to_load_text"
        android:gravity="center"
        android:visibility="gone" />

</RelativeLayout>

Demo下载地址

版权声明：本文为博主原创文章，未经博主允许不得转载。

转载于:https://www.cnblogs.com/sidxu/p/4940371.html

ali0070209
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
仿最新美团外卖下拉刷新动画
03-11
仿最新美团外卖下拉刷新动画http://blog.csdn.net/baiyuliang2013/article/details/50854592
前端vue uni-app仿美团下拉框下拉筛选组件
chenchuang0128的博客
07-21 3809
在前端Web开发中，下拉筛选功能是一种非常常见的交互方式，它可以帮助用户快速选择所需的选项。本文将介绍如何利用Vue.js和uni-app框架来实现一个高效的下拉筛选功能。通过使用这两个强大的前端框架，我们可以轻松地创建具有响应式用户操作的下拉筛选组件。
【Android从零撸美团二】仿美团下拉刷新自定义动画
solocoder的博客
11-03 1806
这是【从零撸美团】系列文章第二篇。 项目地址：https://github.com/cachecats/LikeMeiTuan 今天写了下拉刷新，框架用的是 SmartRefreshLayout ，不为啥，因为 Github 上它有 9.5k 个 star，中文支持好节省时间。 先上图： 一、分析 美团的下拉加载动画初看挺简单的，就一个卖萌的小人。细看的话还稍微有点复杂，一共有三个状态。 刚开...
仿美团下拉刷新
10-19
仿美团、大众点评等的下拉刷新动画，动画可随意替换自己的动画资源
Android自定义控件之仿美团下拉刷新
热门推荐
阿拉灯神灯的专栏
11-01 1万+
美团的下拉刷新分为三个状态： 第一个状态为下拉刷新状态(pull to refresh)，在这个状态下是一个绿色的椭圆随着下拉的距离动态改变其大小。 第二个部分为放开刷新状态(release to refresh)，在这个状态下是一个帧动画，效果为从躺着变为站起来的动画。 第三个部分为刷新状态(refreshing)，在这个状态下也是一个帧动画，是摇头的动画。其中第二和第三个状态很简单，就是两
android仿美团下拉刷新效果
12-24
做的一个仿美团的一个效果，希望对大家有所帮助。
android仿美团下拉刷新
05-14
android仿美团下拉刷新，自定义控件，自定义View,android进阶技术。
android 高仿美团下拉刷新
12-15
实现跟美团刷新一模一样效果，放出来与大家分享，绝对不让你后悔下载
仿美团下拉刷新+上拉加载
Jason
10-14 2599
下拉刷新的案例比比皆是，在这里分享一个比较强大的开源库，学习下如何使用这个库。 昨天已经做了一个简单的动画，今天把动画应用上来，仿美团下拉刷新这个效果是库里面本来就有的效果，这里就简单的学习一下实现这种效果。
仿美团下拉刷新效果（大众点评下拉刷新吃包子的效果也可以这么实现）
AndroidRoad
12-04 4024
虽然现在有很多的下拉刷新的开源框架可以使用，并且使用起来也都是很方便。但是如果想要修改下拉刷新的显示效果，可能用那些开源框架实现起来就不是那么方便。                 并且在出去面试的时候，如果被人问道下拉刷新你是怎么做的，如果你告诉别人你是用的第三方的框架，那么对你的面试并没有什么好处，而且不利于你找到高薪的工作，但是如果，你说是自己写的，那你找工作成功的几率就会大很多，而且找
仿美团下拉刷新上拉加载
05-04
仿美团下拉刷新，上拉加载更多，超炫超酷。
文字碎片效果的下拉刷新，可以自定义refresh view
09-23
文字碎片效果的下拉刷新，可以自定义refresh view ，类似与ios上的CBStoreHouseRefreshControl
三种下拉刷新动画特效
10-04
三种下拉刷新动画特效
iOS-自定义下拉刷新上拉加载（可根据自己的需求改）
01-13
iOS-自定义下拉刷新上拉加载（可根据自己的需求改） 欢迎关注 http://blog.csdn.net/u014220518/article/details/54407135
listview下拉刷新上拉加载（仿美团外卖袋鼠动画）
12-10
listview下拉刷新上拉加载（仿美团外卖袋鼠动画）。
Android USB HID探索
paradisexiao的专栏
04-19 166
问题1：调用bulkTransfer返回-1。
Android常用框架，持续更新
zj907638274的博客
04-22 398
当前只是列出常用框架，大家根据需求去搜索即可，后续贴上讲的好的博客以及github开源库链接；
苹果App Store政策调整，模拟器游戏或成为新机遇
最新发布
cuckoomin的博客
04-22 377
随着智能手机的普及和技术的飞速发展，iPhone和Android手机已深入我们的日常生活，成为不可或缺的一部分。然而，随着模拟器游戏在iOS平台上的合法化，中国游戏厂商迎来了新的发展机遇。这不仅能够满足海外玩家对中国文化的好奇心，还能够通过游戏的形式传播中国文化，提升中国游戏在国际市场的知名度和影响力。同时，他们还需要深入了解海外市场的需求和特点，制定针对性的市场策略，以便更好地适应海外市场的竞争环境。面对新的政策环境和市场需求，中国游戏厂商需要不断创新和优化游戏内容，提升用户体验和满意度。
uniapp怎么修改下拉刷新动画出现的高度
07-14
你可以通过修改uniapp的全局配置来修改下拉刷新动画出现的高度。具体步骤如下： 1. 打开项目中的`pages.json`文件，找到全局配置项`"window"`。 2. 在`window`中添加`"pullRefresh"`字段，用于配置下拉刷新的相关...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值