WaterColourVoiceView

WaterColourVoiceView

package com.reacnnCn.android.view;

import com.reacnnCn.android.R;

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PorterDuffXfermode;
import android.graphics.RadialGradient;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Shader;
import android.graphics.Bitmap.Config;
import android.graphics.Paint.Style;
import android.graphics.PorterDuff.Mode;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.NinePatchDrawable;
import android.os.Handler;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.widget.ImageView;
 

public class WaterColourVoiceView extends ImageView implements Runnable {

	Paint mPaint = null;
	private final Paint mpaint = new Paint();
	private final Paint mCirclePaint = new Paint();

	private int mBorderThickness = 2;
	/**
	 * 内圆或者外圆的边框颜色
	 */
	private int mBorderColor = android.graphics.Color.YELLOW;
	/**
	 * 滑块颜色
	 */
	private int mSlidercolor = 0xffff73c9;

	private Rect mRect = null;

	private int DefaultMinSecond = 5;

	public WaterColourVoiceView(Context context, AttributeSet attrs, int defStyle) {
		super(context, attrs, defStyle);
		init(context);
	}

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

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

	void init(Context mContext) {
		mPaint = new Paint();
		mPaint.setAntiAlias(true);
		mPaint.setColor(0x40cccccc);
		new Thread(this).start();
		this.mpaint.setAntiAlias(true);
		this.mpaint.setStyle(Style.STROKE);
		mCirclePaint.setAntiAlias(true);
		if (isInEditMode()) {
			isDraw = true;
			mBorderThickness = 4;
		} else {
			mBorderThickness = mContext.getResources().getDimensionPixelSize(R.dimen.rotatethiness);
		}
	}

	/**
	 * 线程处理
	 */
	public void run() {
		while (!Thread.currentThread().isInterrupted()) {
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				Thread.currentThread().interrupt();
			}
			postInvalidate();
		}
	}

	int startAngle = 0;

	public static Bitmap getCroppedBitmap(Bitmap bmp, int radius) {
		Bitmap scaledSrcBmp;
		int diameter = radius * 2;
		if (bmp.getWidth() != diameter || bmp.getHeight() != diameter)
			scaledSrcBmp = Bitmap.createScaledBitmap(bmp, diameter, diameter,
					false);
		else
			scaledSrcBmp = bmp;
		Bitmap output = Bitmap.createBitmap(scaledSrcBmp.getWidth(),
				scaledSrcBmp.getHeight(), Config.ARGB_8888);
		Canvas canvas = new Canvas(output);

		final Paint paint = new Paint();
		final Rect rect = new Rect(0, 0, scaledSrcBmp.getWidth(),
				scaledSrcBmp.getHeight());

		paint.setAntiAlias(true);
		paint.setFilterBitmap(true);
		paint.setDither(true);
		canvas.drawARGB(0, 0, 0, 0);
		paint.setColor(Color.parseColor("#BAB399"));
		canvas.drawCircle(scaledSrcBmp.getWidth() / 2,
				scaledSrcBmp.getHeight() / 2, scaledSrcBmp.getWidth() / 2,
				paint);
		paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
		canvas.drawBitmap(scaledSrcBmp, rect, rect, paint);
		return output;
	}

	private boolean isDraw = true;

	final int iStartPosition = 35;
	int iPosition = iStartPosition;

	@SuppressLint("DrawAllocation")
	@Override
	protected void onDraw(Canvas canvas) {
		Drawable drawable = getDrawable();
		if (drawable == null) {
			return;
		}
		if (getWidth() == 0 || getHeight() == 0) {
			return;
		}
		this.measure(0, 0);

		if (drawable.getClass() == NinePatchDrawable.class)
			return;

		Bitmap b = ((BitmapDrawable) drawable).getBitmap();
		Bitmap bitmap = b.copy(Bitmap.Config.ARGB_8888, true);

		int TinkissWidth = 2;
		int ww = getWidth(), hh = getHeight();
		int radiusr = iStartPosition * TinkissWidth - mBorderThickness - 1;
		int radius = (ww < hh ? ww : hh) / 2; // 最外围的半径

		if (isWateDraw) {
			iPosition += 1;
			if (iPosition > (radius / TinkissWidth)) {
				iPosition = iStartPosition;
			}
			mCirclePaint.setShader(new RadialGradient(ww / 2, hh / 2, radius,
					new int[] { 0x60cccccc, 0x00000000 }, null,
					Shader.TileMode.MIRROR));
			canvas.drawCircle(ww / 2, hh / 2, iPosition * TinkissWidth + 1,
					mCirclePaint);
			mPaint.setColor(Color.WHITE);
			canvas.drawCircle(ww / 2, hh / 2, (iPosition - 1) * TinkissWidth,
					mPaint);
		}

		Bitmap roundBitmap = getCroppedBitmap(bitmap, radiusr);
		final Paint paint = new Paint();
		paint.setAntiAlias(true);
		paint.setFilterBitmap(true);
		paint.setDither(true);

		paint.setColor(android.graphics.Color.GREEN);
		canvas.drawCircle(ww / 2, hh / 2, radiusr + mBorderThickness + 1, paint);
		paint.setColor(mBorderColor);
		// 外围边框
		canvas.drawCircle(ww / 2, hh / 2, radiusr + mBorderThickness, paint);
		canvas.drawBitmap(roundBitmap, ww / 2 - radiusr, hh / 2 - radiusr, null);
		double mlength = Math.PI * 2 * radiusr;
		DefaultMinSecond = (int) (mlength / 20);
		if (isInEditMode()) {
			mpaint.setColor(mSlidercolor);

			mpaint.setStrokeWidth(mBorderThickness);
			mpaint.setAntiAlias(true);
			mpaint.setDither(true);

			RectF rect2 = new RectF(ww / 2 - radiusr - 2, hh / 2 - radiusr - 2,
					ww / 2 + radiusr + mBorderThickness - 2, hh / 2 + radiusr
							+ mBorderThickness - 2);

			canvas.drawArc(rect2, 270, 30, false, mpaint);
			canvas.drawArc(rect2, 90, 30, false, mpaint);
			canvas.drawArc(rect2, 0, 30, false, mpaint);
			canvas.drawArc(rect2, 180, 30, false, mpaint);
			canvas.drawArc(rect2, 45, 30, false, mpaint);
			canvas.drawArc(rect2, 135, 30, false, mpaint);
			canvas.drawArc(rect2, 225, 30, false, mpaint);
			canvas.drawArc(rect2, 315, 30, false, mpaint);
		}

		if (mRect == null) {
			mRect = new Rect(ww / 2 - radiusr, hh / 2 - radiusr, ww / 2
					+ radiusr + mBorderThickness, hh / 2 + radiusr
					+ mBorderThickness);
		}
		if (!isDraw) {
			mpaint.setColor(mSlidercolor);
			mpaint.setStrokeWidth(mBorderThickness);
			mpaint.setAntiAlias(true);
			mpaint.setDither(true);
			RectF rect2 = new RectF(ww / 2 - radiusr - 2, hh / 2 - radiusr - 2,
					ww / 2 + radiusr + mBorderThickness - 2, hh / 2 + radiusr
							+ mBorderThickness - 2);
			canvas.drawArc(rect2, startAngle, 20, false, mpaint);
			startAngle += 5;
			if (startAngle == 360)
				startAngle = 0;
			if (isStart) {
				isDraw = false;
				invalidate();
			}
		}
	}

	Shader mSweepGradient = null;

	private boolean isWateDraw = true;
	Object mObject2 = new Object();

	public void StartWate() {
		synchronized (mObject2) {
			iPosition = iStartPosition;
			isWateDraw = true;
			invalidate();
		}
	}

	public void StopWate() {
		synchronized (mObject2) {
			iPosition = iStartPosition;
			isWateDraw = false;
			invalidate();
		}
	}

	public void toggleWate() {
		if (isWateDraw) {
			StopWate();
		} else {
			StartWate();
		}
	}

	public void toggle() {
		if (isStart) {
			Stop();
		} else {
			Start();
		}
	}

	public void Begin(int minseconds) {
		StartWate();
		iPosition = iStartPosition;
		mHandler.sendMessageDelayed(mHandler.obtainMessage(1),
				minseconds * 1000);
	}

	@SuppressLint("HandlerLeak")
	Handler mHandler = new Handler() {
		public void dispatchMessage(android.os.Message msg) {
			super.dispatchMessage(msg);
			switch (msg.what) {
			case 1:
				StopWate();
				beginTrans();
				setImageDrawable(getResources().getDrawable(R.drawable.app));
				break;
			case 2:
				Stop();
				break;
			default:
				break;
			}
		};
	};

	private void beginTrans() {
		Start();
		mHandler.sendMessageDelayed(mHandler.obtainMessage(2), 5000);
	}

	public void End() {
		StopWate();
		Stop();
	}

	private boolean isStart = false;
	Object mObject = new Object();

	public void Start() {
		synchronized (mObject) {
			isStart = true;
			isDraw = false;
			invalidate();
		}
	}

	public void Stop() {
		synchronized (mObject) {
			isStart = false;
			isDraw = true;
			invalidate();
		}
	}

	@Override
	public boolean onTouchEvent(MotionEvent event) {
		if (event.getAction() == MotionEvent.ACTION_DOWN) {
			if (mRect != null) {
				if (mRect.contains((int) event.getX(), (int) event.getY())) {
					Log.e(VIEW_LOG_TAG, "Click");
					BitmapClick();
				} else {
					Log.e(VIEW_LOG_TAG, "Not Click");
				}
			} else {
				Log.e(VIEW_LOG_TAG, "mRect=null");
			}
		}
		return super.onTouchEvent(event);
	}

	private void BitmapClick() {
		Begin(DefaultMinSecond);
		setImageDrawable(getResources().getDrawable(R.drawable.app));
		if (mClickListener != null) {
			mClickListener.OnClickListener(this);
		}
	}

	private OnVoiceClickListener mClickListener = null;

	public void SetOnVoiceClickListener(
			OnVoiceClickListener mOnVoiceClickListener) {
		this.mClickListener = mOnVoiceClickListener;
	}

	public interface OnVoiceClickListener {
		void OnClickListener(View view);

		void BeginVoiceListener(View view);

		void EndVoiceListener(View view);

		void BeginRotatingListener(View view);
	}

}