Android加载动画系列——NewsLoadingAnim

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

#android #创意动画 #NewsLoadingAnim 

Android加载动画系列——NewsLoadingAnim

阅读类应用在加载新章节的时候增加一个加载动画，会让应用变得更加友好，富有创意的动画效果更能够达到加分的效果，今天就让我们来实现一款富有创意的加载动画吧~

让我们先来看看效果图：


1、NewsLoadingAnim.java源码如下：

public class NewsLoadingAnim extends View {
    private float mWidth = 0f;
    private float mPadding= 0f;
    private Paint mPaint;

    private float cornerRadius= 0f;
    RectF rectFTopRight = new RectF();
    RectF rectFBottomRight = new RectF();
    RectF rectFTopLeft = new RectF();
    RectF rectFBottomLeft = new RectF();
    RectF rectFSquare = new RectF();
    RectF rectFSquareBG = new RectF();

    float marggingSquareH= 0f;
    float marggingSquareV= 0f;
    float marggingLineH= 0f;
    float marggingLineV= 0f;

    private int mValue = 100;

    public void setValue(int value) {
        stopAnim();
        if (value<= 100) {
            this.mValue = value;
            postInvalidate();
            if (this.mValue == 100) {
                startAnim();
            }
        } else {
            this.mValue = 100;
        }
    }

    public NewsLoadingAnim(Contextcontext) {
        this(context,null);
    }

    public NewsLoadingAnim(Contextcontext, AttributeSet attrs) {
        this(context,attrs, 0);
    }

    public NewsLoadingAnim(Contextcontext, AttributeSet attrs, int defStyleAttr) {
        super(context,attrs, defStyleAttr);
        initPaint();

    }

   private void initPaint() {
        cornerRadius = dip2px(3.0f);
        mPaint = new Paint();
        mPaint.setAntiAlias(true);
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setColor(Color.WHITE);
    }

    @Override
    protected void onDraw(Canvascanvas) {
        super.onDraw(canvas);

        canvas.save();


        mPaint.setStrokeWidth(dip2px(1.0f));
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setColor(Color.WHITE);


        rectFSquareBG.top = mPadding;
        rectFSquareBG.left = mPadding;
        rectFSquareBG.right = mWidth - mPadding;
        rectFSquareBG.bottom = mWidth - mPadding;

        drawContent(canvas, mStep);

        if (mValue <= 25) {
            if (mValue <= 5)
                mValue = 5;
            drawLineToRight(canvas, mValue);
           drawContentSquareLineToRight(canvas, mValue);
        } else if (mValue > 25 &&mValue <= 50) {
            drawLineToBottom(canvas, mValue);
           drawContentSquareLineToBottom(canvas, mValue);
        } else if (mValue > 50 &&mValue <= 75) {
            drawLineToLeft(canvas, mValue);
           drawContentSquareLineToLeft(canvas, mValue);
        } else if (mValue > 75) {
            if (mValue > 100)
                mValue = 100;
            drawLineToTop(canvas, mValue);
           drawContentSquareLineToTop(canvas, mValue);

        }

        if (mValue <= 16) {
            drawLine(canvas, 1, mValue);
        } else if (mValue > 16 &&mValue <= 32) {
            drawLine(canvas, 2, mValue);
        } else if (mValue > 32 &&mValue <= 48) {
            drawLine(canvas, 3, mValue);
        } else if (mValue > 48 &&mValue <= 64) {
            drawLine(canvas, 4, mValue);
        } else if (mValue > 64 &&mValue <= 80) {
            drawLine(canvas, 5, mValue);
        } else if (mValue > 80) {
            drawLine(canvas, 6, mValue);
        }


        canvas.restore();


    }

    private void drawLineToRight(Canvascanvas, int value) {

        if (value<= 20) {

            canvas.drawLine(rectFSquareBG.left + cornerRadius, rectFSquareBG.top,
                    rectFSquareBG.width()* value / 20.f - cornerRadius, rectFSquareBG.top, mPaint);


        } else {
            canvas.drawLine(rectFSquareBG.left + cornerRadius, rectFSquareBG.top,
                    rectFSquareBG.right - cornerRadius, rectFSquareBG.top, mPaint);
            rectFTopRight.top = mPadding;
            rectFTopRight.left = mWidth - mPadding- cornerRadius * 2;
            rectFTopRight.bottom = mPadding+ cornerRadius * 2;
            rectFTopRight.right = mWidth - mPadding;
            canvas.drawArc(rectFTopRight, -90, 90.0f / 5 * (value- 20), false, mPaint);

        }

    }

    private void drawLineToBottom(Canvascanvas, int value) {
        drawLineToRight(canvas, 25);
        if (value<= 45) {

            canvas.drawLine(rectFSquareBG.right, rectFSquareBG.top + cornerRadius,
                    rectFSquareBG.right, rectFSquareBG.height()* (value - 25) / 20.f, mPaint);
        } else {
            canvas.drawLine(rectFSquareBG.right, rectFSquareBG.top + cornerRadius,
                    rectFSquareBG.right, rectFSquareBG.bottom - cornerRadius, mPaint);

            rectFBottomRight.top = mWidth - mPadding- cornerRadius * 2;
            rectFBottomRight.left = mWidth - mPadding- cornerRadius * 2;
            rectFBottomRight.bottom = mWidth - mPadding;
            rectFBottomRight.right = mWidth - mPadding;
            canvas.drawArc(rectFBottomRight, 0, 90.0f / 5 * (value- 45), false, mPaint);
        }
   }

    private void drawLineToLeft(Canvascanvas, int value) {
        drawLineToBottom(canvas, 50);

        if (value<= 70) {

            canvas.drawLine(rectFSquareBG.right - cornerRadius,
                    rectFSquareBG.bottom,
                    rectFSquareBG.left + rectFSquareBG.width()- rectFSquareBG.width() * (value - 50) / 20.f,
                    rectFSquareBG.bottom, mPaint);

        } else {
            canvas.drawLine(rectFSquareBG.right - cornerRadius,
                    rectFSquareBG.bottom,
                    rectFSquareBG.left + cornerRadius,
                    rectFSquareBG.bottom, mPaint);


            rectFBottomLeft.top = mWidth - mPadding- cornerRadius * 2;
            rectFBottomLeft.left = mPadding;
            rectFBottomLeft.bottom = mWidth - mPadding;
            rectFBottomLeft.right = mPadding+ cornerRadius * 2;
            canvas.drawArc(rectFBottomLeft, 90, 90.f / 5 * (value- 70), false, mPaint);
        }
    }

    private void drawLineToTop(Canvascanvas, int value) {
        drawLineToLeft(canvas, 75);
        if (value<= 95) {
            canvas.drawLine(rectFSquareBG.left, rectFSquareBG.bottom - cornerRadius,
                    rectFSquareBG.left,
                    rectFSquareBG.top +
                            rectFSquareBG.height()- rectFSquareBG.height() * (value - 75) / 20.f,
                    mPaint);
        } else {

            canvas.drawLine(rectFSquareBG.left, rectFSquareBG.bottom - cornerRadius,
                    rectFSquareBG.left,
                    rectFSquareBG.top + cornerRadius,
                    mPaint);


            rectFTopLeft.top = mPadding;
            rectFTopLeft.left = mPadding;
            rectFTopLeft.bottom = mPadding+ cornerRadius * 2;
            rectFTopLeft.right = mPadding+ cornerRadius * 2;
            canvas.drawArc(rectFTopLeft, 180, 90.f / 5 * (value- 95), false, mPaint);
        }
    }


    private void drawContentSquareLineToRight(Canvascanvas, int value) {
        canvas.drawLine(rectFSquare.left, rectFSquare.top,
                rectFSquare.left + rectFSquare.width()* (value) / 25.f, rectFSquare.top, mPaint);
    }

    private void drawContentSquareLineToBottom(Canvascanvas, int value) {
       drawContentSquareLineToRight(canvas, 25);
        canvas.drawLine(rectFSquare.right,
                rectFSquare.top,
                rectFSquare.right,
                rectFSquare.top + rectFSquare.height()* (value - 25) / 25.f, mPaint);
    }

    private void drawContentSquareLineToLeft(Canvascanvas, int value) {
       drawContentSquareLineToBottom(canvas, 50);
        canvas.drawLine(rectFSquare.right,
                rectFSquare.bottom,
                rectFSquare.left + rectFSquare.width()- rectFSquare.width() * (value - 50) / 25.f,
                rectFSquare.bottom, mPaint);
    }

    private void drawContentSquareLineToTop(Canvascanvas, int value) {
       drawContentSquareLineToLeft(canvas, 75);
        canvas.drawLine(rectFSquare.left, rectFSquare.bottom,
                rectFSquare.left,
                rectFSquare.top +
                        rectFSquare.height()- rectFSquare.height() * (value - 75) / 25.f,
                mPaint);

    }


    private void drawContent(Canvascanvas, int step) {


        if (step == 1) {

            marggingSquareH = 0f + mAnimatedValue* (mWidth / 2 - cornerRadius) / 0.25f;
            marggingSquareV = 0f;
            marggingLineH = 0f + mAnimatedValue* (mWidth / 2 - cornerRadius) / 0.25f;
            marggingLineV = 0f;


        } else if (step == 2) {

            marggingSquareH = mWidth / 2 - cornerRadius;
            marggingSquareV = 0 + (mWidth / 2 - cornerRadius) / 0.25f * (mAnimatedValue- 0.25f);
            marggingLineH = mWidth / 2 - cornerRadius;
            marggingLineV = 0 + (-mWidth / 2 + cornerRadius) / 0.25f * (mAnimatedValue- 0.25f);


        } else if (step == 3) {
            marggingSquareH = (mWidth / 2 - cornerRadius) - (mWidth / 2 - cornerRadius) / 0.25f * (mAnimatedValue- 0.5f);
            marggingSquareV = mWidth / 2 - cornerRadius;
            marggingLineH = (mWidth / 2 - cornerRadius) - (mWidth / 2 - cornerRadius) / 0.25f * (mAnimatedValue- 0.5f);
            marggingLineV = -mWidth / 2 + cornerRadius;


        } else if (step == 4) {
            marggingSquareH = 0;
            marggingSquareV = (mWidth / 2 - cornerRadius) - (mWidth / 2 - cornerRadius) / 0.25f * (mAnimatedValue- 0.75f);
            marggingLineH = 0;
            marggingLineV = (-mWidth / 2 + cornerRadius) - (-mWidth / 2 + cornerRadius) / 0.25f * (mAnimatedValue- 0.75f);
        }
        if (mValue == 100) {
            mPaint.setStyle(Paint.Style.FILL);
            mPaint.setColor(Color.argb(100, 255, 255, 255));
            rectFSquare.top = mPadding+ cornerRadius + marggingSquareV;
            rectFSquare.left = mPadding+ cornerRadius + marggingSquareH;
            rectFSquare.bottom = mWidth / 2 - mPadding+ marggingSquareV;
            rectFSquare.right = mWidth / 2 - mPadding+ marggingSquareH;
            canvas.drawRect(rectFSquare, mPaint);
        }
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setColor(Color.WHITE);
    }


    private void drawShortLine(Canvascanvas, float line_width_short, int value, int positon){

        positon = positon - 1;



        canvas.drawLine(mWidth / 2 + mPadding+ cornerRadius / 2 - marggingLineH,
                mPadding+ cornerRadius + cornerRadius- marggingLineV + rectFSquare.height()/ 3 * positon,
                mWidth / 2 + mPadding+ cornerRadius / 2 - marggingLineH+ line_width_short / 16.0f * value,
                mPadding+ cornerRadius + cornerRadius- marggingLineV + rectFSquare.height()/ 3 * positon, mPaint);

    }


    private void drawlongLine(Canvascanvas, float line_width_long, int value, int positon){
        positon = positon - 4;
        canvas.drawLine(mPadding+ cornerRadius,
                mPadding+ cornerRadius + rectFSquare.height()/ 3*positon + mWidth / 2 + marggingLineV,
                mPadding+ cornerRadius + line_width_long / 16.0f * (value),
                mPadding+ cornerRadius + rectFSquare.height()/ 3*positon + mWidth / 2 + marggingLineV, mPaint);
    }


    private void drawLine(Canvascanvas, int count, int mValue) {


        float line_width_short= (mWidth - mPadding - cornerRadius- marggingLineH) -
                (mWidth / 2 + mPadding+ cornerRadius / 2 - marggingLineH);
        float line_width_long= (mWidth - mPadding - cornerRadius) -
                (mPadding+ cornerRadius);

        if (count ==1) {
            drawShortLine(canvas,line_width_short, mValue, 1);
        } else if (count ==2) {
            drawShortLine(canvas,line_width_short, 16, 1);
            drawShortLine(canvas,line_width_short, mValue - 16, 2);


        } else if (count ==3) {
            drawShortLine(canvas, line_width_short, 16, 1);
            drawShortLine(canvas,line_width_short, 16, 2);
            drawShortLine(canvas,line_width_short, mValue-32, 3);

        } else if (count ==4) {


            drawShortLine(canvas, line_width_short,16, 1);
            drawShortLine(canvas,line_width_short, 16, 2);
            drawShortLine(canvas,line_width_short, 16, 3);
           drawlongLine(canvas,line_width_long,mValue-48,4);

        } else if (count ==5) {


            drawShortLine(canvas,line_width_short, 16, 1);
            drawShortLine(canvas,line_width_short, 16, 2);
            drawShortLine(canvas,line_width_short, 16, 3);
           drawlongLine(canvas,line_width_long,16,4);
            drawlongLine(canvas,line_width_long,mValue-64,5);


        } else if (count ==6) {
            drawShortLine(canvas,line_width_short, 16, 1);
            drawShortLine(canvas,line_width_short, 16, 2);
            drawShortLine(canvas,line_width_short, 16, 3);
            drawlongLine(canvas,line_width_long,16,4);
           drawlongLine(canvas,line_width_long,16,5);
            canvas.drawLine(mPadding+ cornerRadius,
                    mPadding+ cornerRadius + rectFSquare.height()/ 3 * 2 + mWidth / 2 + marggingLineV,
                    mPadding + cornerRadius+ line_width_long / 20.0f * (mValue - 80),
                    mPadding+ cornerRadius + rectFSquare.height()/ 3 * 2 + mWidth / 2 + marggingLineV, mPaint);

        }


    }


    public int dip2px(float dpValue){
        final float scale =getContext().getResources().getDisplayMetrics().density;
        return (int)(dpValue * scale + 0.5f);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec,int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec,heightMeasureSpec);

        if (getMeasuredWidth()> getHeight())
            mWidth =getMeasuredHeight();
        else
            mWidth =getMeasuredWidth();
        mPadding = dip2px(1);


    }


    private ValueAnimatorvalueAnimator;
    private int mStep = 1;
    float mAnimatedValue= 0f;

    public void startAnim(){
        stopAnim();
        startViewAnim(0f, 1f, 1000);
    }


    public void stopAnim(){
        if (valueAnimator!= null) {
            clearAnimation();
            valueAnimator.setRepeatCount(0);
            valueAnimator.cancel();
            valueAnimator.end();
            mAnimatedValue = 0f;
            mStep = 1;
            invalidate();
        }
        else
        {
            mAnimatedValue = 0f;
            mStep = 1;
            mValue=100;
            invalidate();
        }
    }


    private ValueAnimatorstartViewAnim(float startF, final float endF, long time) {
        valueAnimator =ValueAnimator.ofFloat(startF, endF);
        valueAnimator.setDuration(time);
        valueAnimator.setInterpolator(new LinearInterpolator());
        valueAnimator.setRepeatCount(ValueAnimator.INFINITE);//无限循环
        valueAnimator.setRepeatMode(ValueAnimator.RESTART);
        valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener(){
            @Override
            public void onAnimationUpdate(ValueAnimatorvalueAnimator) {
                mAnimatedValue= (float) valueAnimator.getAnimatedValue();
                if (mAnimatedValue> 0 && mAnimatedValue <= 0.25f) {
                    mStep = 1;
                } else if (mAnimatedValue> 0.25f && mAnimatedValue <= 0.5f) {
                    mStep = 2;
                } else if (mAnimatedValue> 0.5f && mAnimatedValue <= 0.75f) {
                    mStep = 3;
                } else if (mAnimatedValue> 0.75f && mAnimatedValue <= 1.0f) {
                    mStep = 4;
                }

                invalidate();
            }
        });
        valueAnimator.addListener(new AnimatorListenerAdapter(){
            @Override
            public void onAnimationEnd(Animatoranimation) {
                super.onAnimationEnd(animation);

            }

            @Override
            public void onAnimationStart(Animatoranimation) {
                super.onAnimationStart(animation);
            }

            @Override
            public void onAnimationRepeat(Animatoranimation) {
                super.onAnimationRepeat(animation);
            }
        });
        if (!valueAnimator.isRunning()){
            valueAnimator.start();

        }

        return valueAnimator;
    }

}

 

 

2、接着在layout布局文件中使用我们自定义的动画控件

 

<com.cyril.loadinganim.NewsLoadingAnim
    android:id="@+id/newsloadanim"
    android:layout_width="50dp"
    android:layout_height="50dp"
    />
 

 

3、然后在Activity中实现动画的播放和停止，使用事例如下：

首相我们需要定义一些变量，用来辅助动画的效果
private NewsLoadingAnim newsLoadingAnim;
int mValueNews = 0;
private Timer mTimerNews = new Timer();
 
然后，我们需要借助Handler来重复刷新动画
private void stopNewsAnim() {
    newsLoadingAnim.stopAnim();
    if (mTimerNews != null) {
        mTimerNews.cancel();
    }
}


private void startNewsAnim() {
    mValueNews = 0;
    if (mTimerNews != null) {
        mTimerNews.cancel();
    }
    mTimerNews = new Timer();
    timerTaskNews();
}

public void timerTaskNews() {
    mTimerNews.schedule(new TimerTask() {
        @Override
        public void run() {
            if (mValueNews < 100) {
                mValueNews++;
                Message msg = mHandler.obtainMessage(1);
                msg.arg1 = mValueNews;
                mHandler.sendMessage(msg);
            } else {
                mTimerNews.cancel();
            }
        }
    }, 0, 10);
}

private Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
       if (msg.what == 1) {
            newsLoadingAnim.setValue(msg.arg1);
        }
    }
};
 
最后我们在onCreate中开始动画
newsLoadingAnim = (NewsLoadingAnim) findViewById(R.id.newsloadanim);
startNewsAnim();
 
 

4、  戳这里，小编带你去源码的下载地址：http://download.youkuaiyun.com/detail/zhimingshangyan/9582830

 

Android加载动画
黎荣恒的博客
12-01 2645
在android开发中，诸如网络加载的过程会比较耗时间，那么当用户进行一个网络操作的时候App应该给出怎样的反应是事关我们项目体验，我们都知道网络操作的耗时是不可以避免或者是很难避免的，但是我们通过一个加网络加载的动画可以从另外一个方面提高用户体验，还能提高App的观赏性。 下面就是一个加载动画的实例，我们可以根据项目实际情况更换动画，非常方便使用。 1、创建android项目
Android加载动画系列——CircularLoadingAnim
绝不后退
07-21 1340
Android加载动画系列——CircularLoadingAnim        小编在逛掘金社区的时候，一不小心看到了一篇讲加载动画的文章，于是点进去看了看，被这些炫酷的加载动画深深地吸引了，于是小编觉得有必要自己动手记录一下这些炫酷的动画，顺便丰富一下自己的学习笔记。        让我们先来看看效果图：        在此我就不做过多的分析，直接上源码。 1、Circula
android 加载动画
09-09
android 各式各样的加载动画（***几十种加载动画样式任你选择****），有兴趣的盆友可以下载看看，美观，直接可以套入项目里用即可。
Android动画效果实现指南
最新发布
cao_xiang_qi8395的博客
06-17 515
本文详细介绍了Android动画效果的实现方法，包括帧动画、补间动画、动画优化和动画工具库等方面。通过掌握这些技巧，开发者可以更好地提升应用的用户体验。未来，随着技术的不断发展，动画效果在移动应用开发中的应用将更加广泛，开发者需要不断学习和实践，以适应这一趋势。性能优化：确保动画流畅运行，避免卡顿。用户体验：合理使用动画，避免过度动画导致用户不适。创新设计：尝试使用新的动画效果，提升应用独特性。最后，建议开发者关注业界动态，学习最新的动画技术和工具，不断提升自己的技能水平。
android加载动画
分享人生
12-11 675
http://blog.youkuaiyun.com/easyer2012/article/details/50483930
Android 加载动画
W2597645565的博客
06-13 929
1.仿京东小人加载动画 loading_animation.xml <?xml version="1.0" encoding="utf-8"?> <animation-list xmlns:android="http://schemas.android.com/apk/res/android" android:oneshot="false"> <...
Android加载动画系列——CircularZoomLoadingAnim
绝不后退
07-30 2531
Android加载动画系列——CircularZoomLoadingAnim        我们经常在应用中看到“正在加载中…”这样的文案，有时候设计要求文字后面的三个小点可以闪烁，我们就来实现一下三个小点跳动的效果。        让我们先来看看效果图： 1、CircularZoomLoadingAnim.java源码如下：    public class CircularZoo
Android加载动画系列——WifiLoadingAnim
绝不后退
07-30 1542
Android加载动画系列——WifiLoadingAnim        我们经常会遇到这样一种场景，加载网页的时候，刚好遇到网速不给力，然后就加载失败了，这个时候为了用户友好性原则，我们会给出一个加载失败的页面，有些设计会放置一张wifi的图片，如果把图片换成动画会不会更好呢？让我们来看看wifi加载动画怎么实现吧~        让我们先来看看效果图： 1、WifiLoadin
Android小项目——新闻APP（源码）
02-26
Android小项目——新闻APP（源码），一个很简单的可以练手的Android Demo Ps:下载之前可以先看一下这篇文章——https://blog.youkuaiyun.com/qq_34149526/article/details/80992341
AndroidStudio————实战演练——仿美团外卖菜单
04-06
在本项目中，"AndroidStudio————实战演练——仿美团外卖菜单"是一个专注于使用Android Studio开发的应用程序实战案例，目标是创建一个类似于美团外卖的菜单功能。这个项目涵盖了多个Android开发的关键知识点，...
安卓动画效果相关-Android——贝塞尔曲线动画——直播平台点赞效果.rar
07-29
Android——贝塞尔曲线动画——直播平台点赞效果.rar,太多无法一一验证是否可用，程序如果跑不起来需要自调，部分代码功能进行参考学习。
Android-漂亮的Android加载动画
08-12
漂亮的Android加载动画
Android加载动画LoadingDrawable.zip
07-18
一些酷炫的加载动画， 可以与任何View配合使用，作为加载动画或者Progressbar, 此外很适合与RecyclerRefreshLayout 配合使用作为刷新的loading 动画这个项目的思路源于这个动画链接 link. 或许你更喜欢使用Gif实现 : GifLoadingView.
Android loading...加载动画
06-21
android loading...加载动画 很好用，我自己也在用。
一个有趣的android加载动画
weixin_33796205的博客
04-24 207
前言 之前学习canvas画图的时候，写了一个Android的加载动画，代码托管在github上面。 这里是github的地址：github地址，欢迎star，欢迎关注 下面先附上实际运行的效果图。 主要的工作思路 需要绘制这样的动画，首先要学习Canvas的一些基本知识，这里我就不一一介绍了，推荐一个大神的教程，讲解的非常好。 这里是...
Android加载动画系列——CircularRingLoadingAnim
绝不后退
07-21 812
Android加载动画系列——CircularRingLoadingAnim        小编在逛掘金社区的时候，一不小心看到了一篇讲加载动画的文章，于是点进去看了看，被这些炫酷的加载动画深深地吸引了，于是小编觉得有必要自己动手记录一下这些炫酷的动画，顺便丰富一下自己的学习笔记。        让我们先来看看效果图：        在此我就不做过多的分析，直接上源码。 1、att
AVLoadingIndicatorView
Makenna's World
01-08 460
  Step 1 Add dependencies in build.gradle. dependencies { compile 'com.wang.avi:library:2.1.3' }   Step 2 Add the AVLoadingIndicatorView to your layout: Simple &lt;com.w...
Android - Loading 中间显示logo，外部ing转圈加载动画
Beluga_白鲸
08-13 9383
需求： 需求很简单，就是中间显示一个logo，外部是一个转圈的动画，这样看着就是一个loading。 这里通过dialog来实现，比较好集中代码。 图片： 全图 loading1 loading2 代码： 调用：这里使用了单例调用 LoadingDialog.getInstance(context).show();//显示 LoadingDialo...
Android加载动画简单实现教程
在Android开发中，加载动画是提升用户体验的重要环节，尤其是在应用或页面正在加载数据时。加载动画可以减轻用户的等待焦虑，同时传递应用正在响应的积极信号。在本篇中，我们将详细探讨Android加载动画的实现方式，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值