GithHub地址：https://github.com/81813780/AVLoadingIndicatorView
該開源庫實現了28種載入中樣式，但是我們一般專案中為了統一風格，所有頁面的載入中效果都是一致的，所以我們一般也只會用到其中的一兩種效果，如果集成了該庫，但我們只用到了其中一種或者兩種效果，那麼就顯得有點太浪費了，因此我們可以通過分析原始碼實現，只新增我們需要的效果即可，因此也就有了本篇文章，手動整合也很簡單，此處作簡要記錄。

1，新增核心類：AVLoadingIndicatorView，繼承自View，程式碼如下：

public class AVLoadingIndicatorView
 
 extends View {

    private static final String TAG="AVLoadingIndicatorView";

    // 當xml中沒有指定樣式時，預設使用該樣式，xml中沒有指定顏色時，預設為白色（本類中110行設定的預設為白色）
    private static final BallPulseIndicator DEFAULT_INDICATOR=new BallPulseIndicator();

    private static final int MIN_SHOW_TIME = 500; // ms
    private static final
 
 int MIN_DELAY = 500; // ms

    private long mStartTime = -1;

    private boolean mPostedHide = false;

    private boolean mPostedShow = false;

    private boolean mDismissed = false;

    private final Runnable mDelayedHide = new Runnable() {

        @Override
        public void run() {
            mPostedHide =
 
 false;
            mStartTime = -1;
            setVisibility(View.GONE);
        }
    };

    private final Runnable mDelayedShow = new Runnable() {

        @Override
        public void run() {
            mPostedShow = false;
            if (!mDismissed) {
                mStartTime = System.currentTimeMillis();
                setVisibility(View.VISIBLE);
            }
        }
    };

    int mMinWidth;
    int mMaxWidth;
    int mMinHeight;
    int mMaxHeight;

    private Indicator mIndicator;
    private int mIndicatorColor;

    private boolean mShouldStartAnimationDrawable;

    public AVLoadingIndicatorView(Context context) {
        super(context);
        init(context, null,0,0);
    }

    public AVLoadingIndicatorView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context, attrs,0,R.style.AVLoadingIndicatorView);
    }

    public AVLoadingIndicatorView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context, attrs,defStyleAttr,R.style.AVLoadingIndicatorView);
    }

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    public AVLoadingIndicatorView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        init(context,attrs,defStyleAttr,R.style.AVLoadingIndicatorView);
    }

    private void init(Context context,AttributeSet attrs,int defStyleAttr, int defStyleRes) {
        mMinWidth = 24;
        mMaxWidth = 48;
        mMinHeight = 24;
        mMaxHeight = 48;

        final TypedArray a = context.obtainStyledAttributes(
                attrs, R.styleable.AVLoadingIndicatorView);

        mMinWidth = a.getDimensionPixelSize(R.styleable.AVLoadingIndicatorView_minWidth, mMinWidth);
        mMaxWidth = a.getDimensionPixelSize(R.styleable.AVLoadingIndicatorView_maxWidth, mMaxWidth);
        mMinHeight = a.getDimensionPixelSize(R.styleable.AVLoadingIndicatorView_minHeight, mMinHeight);
        mMaxHeight = a.getDimensionPixelSize(R.styleable.AVLoadingIndicatorView_maxHeight, mMaxHeight);

        String indicatorName=a.getString(R.styleable.AVLoadingIndicatorView_indicatorName);
        mIndicatorColor=a.getColor(R.styleable.AVLoadingIndicatorView_indicatorColor, Color.WHITE);
        setIndicator(indicatorName);
        if (mIndicator==null){
            setIndicator(DEFAULT_INDICATOR);
        }
        a.recycle();
    }

    public Indicator getIndicator() {
        return mIndicator;
    }

    public void setIndicator(Indicator d) {
        if (mIndicator != d) {
            if (mIndicator != null) {
                mIndicator.setCallback(null);
                unscheduleDrawable(mIndicator);
            }

            mIndicator = d;
            //need to set indicator color again if you didn't specified when you update the indicator .
            setIndicatorColor(mIndicatorColor);
            if (d != null) {
                d.setCallback(this);
            }
            postInvalidate();
        }
    }


    /**
     * setIndicatorColor(0xFF00FF00)
     * or
     * setIndicatorColor(Color.BLUE)
     * or
     * setIndicatorColor(Color.parseColor("#FF4081"))
     * or
     * setIndicatorColor(0xFF00FF00)
     * or
     * setIndicatorColor(getResources().getColor(android.R.color.black))
     * @param color
     */
    public void setIndicatorColor(int color){
        this.mIndicatorColor=color;
        mIndicator.setColor(color);
    }


    /**
     * You should pay attention to pass this parameter with two way:
     * for example:
     * 1. Only class Name,like "SimpleIndicator".(This way would use default package name with
     * "com.wang.avi.indicators")
     * 2. Class name with full package,like "com.my.android.indicators.SimpleIndicator".
     * @param indicatorName the class must be extend Indicator .
     */
    public void setIndicator(String indicatorName){
        if (TextUtils.isEmpty(indicatorName)){
            return;
        }
        StringBuilder drawableClassName=new StringBuilder();
        if (!indicatorName.contains(".")){
            String defaultPackageName=getClass().getPackage().getName();
            drawableClassName.append(defaultPackageName)
                    .append(".indicators")
                    .append(".");
        }
        drawableClassName.append(indicatorName);
        try {
            Class<?> drawableClass = Class.forName(drawableClassName.toString());
            Indicator indicator = (Indicator) drawableClass.newInstance();
            setIndicator(indicator);
        } catch (ClassNotFoundException e) {
            Log.e(TAG,"Didn't find your class , check the name again !");
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public void smoothToShow(){
        startAnimation(AnimationUtils.loadAnimation(getContext(),android.R.anim.fade_in));
        setVisibility(VISIBLE);
    }

    public void smoothToHide(){
        startAnimation(AnimationUtils.loadAnimation(getContext(),android.R.anim.fade_out));
        setVisibility(GONE);
    }

    public void hide() {
        mDismissed = true;
        removeCallbacks(mDelayedShow);
        long diff = System.currentTimeMillis() - mStartTime;
        if (diff >= MIN_SHOW_TIME || mStartTime == -1) {
            // The progress spinner has been shown long enough
            // OR was not shown yet. If it wasn't shown yet,
            // it will just never be shown.
            setVisibility(View.GONE);
        } else {
            // The progress spinner is shown, but not long enough,
            // so put a delayed message in to hide it when its been
            // shown long enough.
            if (!mPostedHide) {
                postDelayed(mDelayedHide, MIN_SHOW_TIME - diff);
                mPostedHide = true;
            }
        }
    }

    public void show() {
        // Reset the start time.
        mStartTime = -1;
        mDismissed = false;
        removeCallbacks(mDelayedHide);
        if (!mPostedShow) {
            postDelayed(mDelayedShow, MIN_DELAY);
            mPostedShow = true;
        }
    }

    @Override
    protected boolean verifyDrawable(Drawable who) {
        return who == mIndicator
                || super.verifyDrawable(who);
    }

    void startAnimation() {
        if (getVisibility() != VISIBLE) {
            return;
        }

        if (mIndicator instanceof Animatable) {
            mShouldStartAnimationDrawable = true;
        }
        postInvalidate();
    }

    void stopAnimation() {
        if (mIndicator instanceof Animatable) {
            mIndicator.stop();
            mShouldStartAnimationDrawable = false;
        }
        postInvalidate();
    }

    @Override
    public void setVisibility(int v) {
        if (getVisibility() != v) {
            super.setVisibility(v);
            if (v == GONE || v == INVISIBLE) {
                stopAnimation();
            } else {
                startAnimation();
            }
        }
    }

    @Override
    protected void onVisibilityChanged(View changedView, int visibility) {
        super.onVisibilityChanged(changedView, visibility);
        if (visibility == GONE || visibility == INVISIBLE) {
            stopAnimation();
        } else {
            startAnimation();
        }
    }

    @Override
    public void invalidateDrawable(Drawable dr) {
        if (verifyDrawable(dr)) {
            final Rect dirty = dr.getBounds();
            final int scrollX = getScrollX() + getPaddingLeft();
            final int scrollY = getScrollY() + getPaddingTop();

            invalidate(dirty.left + scrollX, dirty.top + scrollY,
                    dirty.right + scrollX, dirty.bottom + scrollY);
        } else {
            super.invalidateDrawable(dr);
        }
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        updateDrawableBounds(w, h);
    }

    private void updateDrawableBounds(int w, int h) {
        // onDraw will translate the canvas so we draw starting at 0,0.
        // Subtract out padding for the purposes of the calculations below.
        w -= getPaddingRight() + getPaddingLeft();
        h -= getPaddingTop() + getPaddingBottom();

        int right = w;
        int bottom = h;
        int top = 0;
        int left = 0;

        if (mIndicator != null) {
            // Maintain aspect ratio. Certain kinds of animated drawables
            // get very confused otherwise.
            final int intrinsicWidth = mIndicator.getIntrinsicWidth();
            final int intrinsicHeight = mIndicator.getIntrinsicHeight();
            final float intrinsicAspect = (float) intrinsicWidth / intrinsicHeight;
            final float boundAspect = (float) w / h;
            if (intrinsicAspect != boundAspect) {
                if (boundAspect > intrinsicAspect) {
                    // New width is larger. Make it smaller to match height.
                    final int width = (int) (h * intrinsicAspect);
                    left = (w - width) / 2;
                    right = left + width;
                } else {
                    // New height is larger. Make it smaller to match width.
                    final int height = (int) (w * (1 / intrinsicAspect));
                    top = (h - height) / 2;
                    bottom = top + height;
                }
            }
            mIndicator.setBounds(left, top, right, bottom);
        }
    }

    @Override
    protected synchronized void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        drawTrack(canvas);
    }

    void drawTrack(Canvas canvas) {
        final Drawable d = mIndicator;
        if (d != null) {
            // Translate canvas so a indeterminate circular progress bar with padding
            // rotates properly in its animation
            final int saveCount = canvas.save();

            canvas.translate(getPaddingLeft(), getPaddingTop());

            d.draw(canvas);
            canvas.restoreToCount(saveCount);

            if (mShouldStartAnimationDrawable && d instanceof Animatable) {
                ((Animatable) d).start();
                mShouldStartAnimationDrawable = false;
            }
        }
    }

    @Override
    protected synchronized void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int dw = 0;
        int dh = 0;

        final Drawable d = mIndicator;
        if (d != null) {
            dw = Math.max(mMinWidth, Math.min(mMaxWidth, d.getIntrinsicWidth()));
            dh = Math.max(mMinHeight, Math.min(mMaxHeight, d.getIntrinsicHeight()));
        }

        updateDrawableState();

        dw += getPaddingLeft() + getPaddingRight();
        dh += getPaddingTop() + getPaddingBottom();

        final int measuredWidth = resolveSizeAndState(dw, widthMeasureSpec, 0);
        final int measuredHeight = resolveSizeAndState(dh, heightMeasureSpec, 0);
        setMeasuredDimension(measuredWidth, measuredHeight);
    }

    @Override
    protected void drawableStateChanged() {
        super.drawableStateChanged();
        updateDrawableState();
    }

    private void updateDrawableState() {
        final int[] state = getDrawableState();
        if (mIndicator != null && mIndicator.isStateful()) {
            mIndicator.setState(state);
        }
    }

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    @Override
    public void drawableHotspotChanged(float x, float y) {
        super.drawableHotspotChanged(x, y);

        if (mIndicator != null) {
            mIndicator.setHotspot(x, y);
        }
    }

    @Override
    protected void onAttachedToWindow() { 
 

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
Android自定義View——實現水波紋效果類似剩余流量球
     
 string   三個點   pre   ber   block   span   初始化   move   理解   
最近突然手癢就想搞個貝塞爾曲線做個水波紋效果玩玩，終於功夫不負有心人最後實現了想要的效果，一起來看下吧：

效果圖鎮樓

一：先一步一步來分解一下實現的過程

需要繪制一個正弦曲線(sin 

  
 

    

    
    
Android 自定義View實現拖拽效果
     
 
								
								            
						
                騰訊QQ有那種紅點拖動效果,今天就來實現一個簡單的自定義View拖動效果,再回到原處,並非完全仿QQ紅點拖動

先來看一下效果圖



簡單說一下實現步驟

1.建立一個類繼承View

2.繪製出一個 

  
 

    

    
    
Android 自定義View實現圓形環繞效果
     
  
 
  
  
 之前專案中需要實現一個四周環繞中心圓形頭像的效果，感覺還是自定義比較方便，於是就自己封裝了一個控制元件去實現。先貼張圖顯示最終效果。 
  
 首先自定義一個View繼承自LinearLayout,通過動態新增childView的方式將子控制元件新增到View中。思路是先新增中間圓形頭像 

  
 

    

    
    
自定義view實現水波紋效果
     
  
  
  
 自定義view實現水波紋效果 
  
  參考csdn大神 啟艦的部落格http://blog.csdn.net/harvic880925/article/details/50995587，自己實現了一遍，碰到的坑有2個：  1、記得呼叫mPath.reset(),否則每次的path內容會疊 

  
 

    

    
    
Android 自定義view實現水波紋效果
     
 
                今天主要分享水波紋效果：1.標準正餘弦水波紋；2.非標準圓形液柱水波紋；雖說都是水波紋，但兩者在實現上差異是比較大的，一個通過正餘弦函式模擬水波紋效果，另外一個會運用到影象的混合模式（PorterDuffXfermode）；先看效果：                      

  
 

    

    
    
Android自定義View實現水波紋效果
     
 
                本篇博文介紹一個Android自定義View的案例，後續博文會接下自定義View的相關流程和繪製原理。通過自定義控制元件實現。觸控式螢幕幕實現水波紋效果。實現步驟第1步.自定義MyWave繼承Viewpublic class MyWave extends View {}第2步 

  
 

    

    
    
Android自定義View——實現水波紋效果類似剩餘流量球
     
 
							
							
							
  最近突然手癢就想搞個貝塞爾曲線做個水波紋效果玩玩，終於功夫不負有心人最後實現了想要的效果，一起來看下吧：




效果圖鎮樓





一：先一步一步來分解一下實現的過程


需要繪製一個正弦曲線(sin)或者餘弦曲線(cos)
通過水平平移曲線來的到像水 

  
 

    

    
    
Android：自定義View實現水波進度效果
     
 
                
首先上效果圖：

簡介：
1.自動適應螢幕大小；
2.水波自動橫向滾動；
3.各種繪製引數可通過修改常量進行控制。

程式碼不多，註釋也比較詳細，全部貼上：
（一）自定義元件：

/**
 * 水波進度效果.
 */
public class WaterWaveView e 

  
 

    

    
    
翻翻git之---自定義View實現水位上漲效果 WaveProgressView
     
 
							
							
							



P1 （廢話部分，技術內容在P2）

上週陸續收到一些想嘗試性換工作的小夥伴們的簡歷，相關的負責的HR妹子已經電話轟炸過去了，如果有興趣的小夥伴可以看下http://blog.csdn.net/ddwhan0123/article/details/507 

  
 

    

    
    
Android自定義View實現圓弧進度效果
     
 
                前言：Android開發中，自定義View實現自己想要的效果已成為一項必備的技能，當然自定義View也是Android開發中比較難的部分，涉及到的知識有Canvas（畫布）,Paint（畫筆）等，自定義控制元件分為三種：一是直接繼承自View，完全的自定義；二是在原有控制元件 

  
 

    

    
    
自定義View實現的28種效果的載入中樣式
     
 
							
							
							GithHub地址：https://github.com/81813780/AVLoadingIndicatorView
該開源庫實現了28種載入中樣式，但是我們一般專案中為了統一風格，所有頁面的載入中效果都是一致的，所以我們一般也只會用到其中的一兩種效果，如果 

  
 

    

    
    
Android -- 自定義view實現keep歡迎頁倒計時效果
     
 super   onfinish   -m   use   new   getc   awt   ttr   alt   1，最近打開keep的app的時候，發現它的歡迎頁面的倒計時效果還不錯，所以打算自己來寫寫，然後就有了這篇文章。
2，還是老規矩，先看一下我們今天實現的效果

 　　相較於我們常見的倒計時 

  
 

    

    
    
移動開發----Android模仿打字機效果的自定義View實現
     
  
 
 
  
   前言 
    在做splash介面的時候，需要做類似於打字機打字的效果，字一個一個地蹦出來，顯示每一個字都帶有打字的聲音。 
   效果演示 
   
    
   實現原理： 
    這個其實不難實現，通過一個定時器不斷呼叫TextView的setText就行了，在setTex 

  
 

    

    
    
android 自定義view實現圓盤抽獎的效果
     
 
							
							
							廢話不多說直接上程式碼。



import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import andro 

  
 

    

    
    
自定義view實現圓盤抽獎的效果
     
 
							
							
							package comjiang.lunview;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import and 

  
 

    

    
    
Android自定義view實現載入中、載入失敗、無資料
     
 
							
							
							一、概述

Android中經常在有的app中可以見到“載入中”並不是以彈出對話方塊的形式顯示的，而是佔用整個螢幕，如果載入失敗就會出現載入失敗頁面，點選載入失敗頁面中任意區域，都可以重新載入。今天就和大家一起學習如何通過自定義view的方式實現載入中、載入失敗 

  
 

    

    
    
Android自定義View實現類似水波擴散效果
     
 
                自定義View一共分為6步第一步public SpreadView(Context context) {
    this(context,null,0);
}

public SpreadView(Context context, @Nullable AttributeSe 

  
 

    

    
    
Android 自定義View實現圓形切圖的效果
     
 
							
							
							使用自定義View實現圓形ImageView的效果 


目前圓形邊框還需要調整,這裡有點問題



實現思路

使用一個Paint,將得到的Bitmap設定成paint的Shader,設定完成後,使用Matrix調整圖片至居中,使用RectF約束邊框,最後完成 

  
 

    

    
    
Android_自定義View的三種實現方式
     
 
                
自定義控制元件的實現有三種方式，分別是：組合控制元件、繼承控制元件和自繪控制元件

一:組合控制元件
1:新建一個Android專案，建立自定義的佈局檔案add_delete.xml

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

  
 

    

    
    
android 自定義view實現錶盤效果
     
 
                
週末沒事在家想幹點啥,記得一年多前面試,那公司直接發個面試題讓我做,其中就有讓我做一個簡單的錶盤效果,不過當時沒做出來,所以也沒好意思去面試,今天就實現下,大概分如下幾步
第一步：畫一個簡單的圓
第二步：繪製刻度
第三步：繪製時,分,表指標
第四步：繪製當前時間文字
第五步