Android自定义图片集合_Android

本文主要包括以下内容：

  • 使用Xfermode设置圆角图片
  • 使用BitmapShader设置圆角图片
  • 滑动旋转缩放的bimp图片
  • 图片颜色处理（滑动)
  • 图片 + 文字

其中1,2是两种不同方式处理图片圆角的情况。3，是通过Matrix进行图片缩放，旋转等。4，是通过Matrix操作图片的处理，包括去饱和，四角黑影，中心突出等。5，图片加文字组合显示。
如果暂时感觉这些看不懂：
先看看这两篇：

Android自定义控件深入学习 Android生成随机验证码

详解Android自定义控件属性TypedArray以及attrs

1、使用Xfermode设置圆角图片
主要代码

package com.example.customimage.view; 

import com.example.customimage.R; 

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.RectF;
import android.util.AttributeSet;
import android.util.Log;
import android.util.TypedValue;
import android.view.View; 

/**
 * 自定义View，实现圆角，圆形等效果
 */
public class XfermodeImageView extends View
{
 //类型
 private int type;
 private static final int TYPE_CIRCLE = 0; //圆形
 private static final int TYPE_RECT = 1; //矩形圆角 

 //原始图片
 private Bitmap mSrc; 

 //矩形圆角的幅度
 private int mRadius; 

 //控件的宽度
 private int mWidth; 

 // 控件的高度
 private int mHeight; 

 public XfermodeImageView(Context context, AttributeSet attrs)
 {
 this(context, attrs, 0);
 } 

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

 /**
 * 初始化一些自定义的参数
 *
 * @param context
 * @param attrs
 * @param defStyle
 */
 public XfermodeImageView(Context context, AttributeSet attrs, int defStyle)
 {
 super(context, attrs, defStyle); 

 TypedArray a = context.getTheme().obtainStyledAttributes(attrs,
  R.styleable.XfermodeImageView, defStyle, 0); 

 int n = a.getIndexCount();
 for (int i = 0; i < n; i++)
 {
  int attr = a.getIndex(i);
  switch (attr)
  {
  //原始图片，在布局里面获取
  case R.styleable.XfermodeImageView_src:
  mSrc = BitmapFactory.decodeResource(getResources(),
   a.getResourceId(attr, 0));
  break;
  //类型属性选择
  case R.styleable.XfermodeImageView_type:
  //自定义类型属性，0是圆形，1是矩形圆角
  type = a.getInt(attr, 0);// 默认为Circle
  break;
  //矩形圆角幅度的获取，默认是10dp
  case R.styleable.XfermodeImageView_borderRadius:
  mRadius = a.getDimensionPixelSize(attr, (int) TypedValue
   .applyDimension(TypedValue.COMPLEX_UNIT_DIP, 10f,
    getResources().getDisplayMetrics()));
  Log.i("Show", String.valueOf(mRadius));
  break;
  }
 }
 a.recycle();
 } 

 /**
 * 计算控件的高度和宽度
 */
 @Override
 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
 {
 // 设置宽度
 int specMode = MeasureSpec.getMode(widthMeasureSpec);
 int specSize = MeasureSpec.getSize(widthMeasureSpec); 

 //match_parent或者设置的精确值获取
 //MeasureSpec.EXACTLY
 if (specMode == MeasureSpec.EXACTLY)
 {
  mWidth = specSize;
 }
 else
 {
  // 由图片决定的宽
  //getPaddingLeft(),getPaddingRight()这两个值是控件属性的向内偏移的距离值，所以的一起计算
  //区别于layout_marginLeft,两个控件的左间距值设置
  int desireByImg = getPaddingLeft() + getPaddingRight()
   + mSrc.getWidth(); 

  // wrap_content
  if (specMode == MeasureSpec.AT_MOST)
  {
  //所以最小的值，宽度的话是左右内偏移距离之和
  mWidth = Math.min(desireByImg, specSize);
  } else 

  mWidth = desireByImg;
 } 

 // 设置高度，部分解释同上
 specMode = MeasureSpec.getMode(heightMeasureSpec);
 specSize = MeasureSpec.getSize(heightMeasureSpec); 

 //match_parent或者设置的精确值获取
 //MeasureSpec.EXACTLY
 if (specMode == MeasureSpec.EXACTLY)
 {
  mHeight = specSize;
 } else
 {
  int desire = getPaddingTop() + getPaddingBottom()
   + mSrc.getHeight(); 

  // wrap_content
  if (specMode == MeasureSpec.AT_MOST)
  {
  mHeight = Math.min(desire, specSize);
  } else
  mHeight = desire;
 } 

 //计算好的宽度以及高度是值，设置进去
 setMeasuredDimension(mWidth, mHeight);
 } 

 /**
 * 绘制image控件
 */
 @Override
 protected void onDraw(Canvas canvas)
 {
 switch (type)
 {
 // 如果是TYPE_CIRCLE绘制圆形
 case TYPE_CIRCLE:
  //圆形宽度和高度应该一致的，所以也要比较一下大小，取小的值
  int min = Math.min(mWidth, mHeight);
  // 圆形宽度和高度如果不一致，按小的值进行压缩
  mSrc = Bitmap.createScaledBitmap(mSrc, min, min, false);
  //绘制圆形
  canvas.drawBitmap(createCircleImage(mSrc, min), 0, 0, null);
  break;
 case TYPE_RECT:
  canvas.drawBitmap(createRoundConerImage(mSrc), 0, 0, null);
  break; 

 } 

 } 

 /**
 * 根据原图和变长绘制圆形图片
 *
 * @param source
 * @param min
 * @return
 */
 private Bitmap createCircleImage(Bitmap source, int min)
 {
 final Paint paint = new Paint();
 //防止边缘的抗锯齿
 paint.setAntiAlias(true); 

 Bitmap target = Bitmap.createBitmap(min, min, Config.ARGB_8888);
 // 产生一个同样大小的画布
 Canvas canvas = new Canvas(target);
 // 首先绘制圆形,除以2就是半径了
 //最主要设置第三个参数为min/2，圆角幅度那么大就是圆形了
 canvas.drawCircle(min / 2, min / 2, min/2, paint);
 // 使用SRC_IN，参考上面的说明---上下层都显示。下层居上显示
 paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
 // 绘制图片
 canvas.drawBitmap(source, 0, 0, paint);
 return target;
 } 

 /**
 * 根据原图添加圆角
 *
 * @param source
 * @return
 */
 private Bitmap createRoundConerImage(Bitmap source)
 {
 final Paint paint = new Paint();
 paint.setAntiAlias(true);
 Bitmap target = Bitmap.createBitmap(mWidth, mHeight, Config.ARGB_8888);
 Canvas canvas = new Canvas(target);
 //绘制矩形
 RectF rect = new RectF(0, 0, source.getWidth(), source.getHeight());
 //设置圆角幅度
 canvas.drawRoundRect(rect, mRadius, mRadius, paint);
 // 使用SRC_IN，参考上面的说明---上下层都显示。下层居上显示
 paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
 canvas.drawBitmap(source, 0, 0, paint);
 return target;
 }
}

2、使用BitmapShader设置圆角图片

package com.example.customimage.view; 

import com.example.customimage.R; 

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.BitmapShader;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.RectF;
import android.graphics.Shader.TileMode;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Parcelable;
import android.util.AttributeSet;
import android.util.Log;
import android.util.TypedValue;
import android.widget.ImageView; 

/**
 *
 */
public class BitmapShaderImageView extends ImageView
{
 // 图片的类型，圆形or圆角
 private int type;
 public static final int TYPE_CIRCLE = 0;
 public static final int TYPE_RECT = 1;
 //圆角大小的默认值
 private static final int BODER_RADIUS_DEFAULT = 10;
 //圆角的大小
 private int mBorderRadius; 

 // 绘图的Paint
 private Paint mBitmapPaint;
 //圆角的半径
 private int mRadius;
 // 3x3 矩阵，主要用于缩小放大
 private Matrix mMatrix;
 // 渲染图像，使用图像为绘制图形着色
 private BitmapShader mBitmapShader;
 // view的宽度
 private int mWidth;
 //矩形
 private RectF mRoundRect; 

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

 public BitmapShaderImageView(Context context, AttributeSet attrs)
 {
 super(context, attrs);
 mMatrix = new Matrix();
 mBitmapPaint = new Paint();
 mBitmapPaint.setAntiAlias(true); 

 TypedArray a = context.obtainStyledAttributes(attrs,
  R.styleable.BitmapShaderImageView);
 //矩形圆角幅度的获取，默认是10dp
 mBorderRadius = a.getDimensionPixelSize(
  R.styleable.BitmapShaderImageView_borderRadius, (int) TypedValue
   .applyDimension(TypedValue.COMPLEX_UNIT_DIP,
    BODER_RADIUS_DEFAULT, getResources()
     .getDisplayMetrics()));
 //自定义类型属性，0是圆形，1是矩形圆角
 type = a.getInt(R.styleable.BitmapShaderImageView_type, TYPE_CIRCLE); 

 a.recycle();
 } 

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

 // 如果类型是圆形，则强制改变view的宽高一致，以小值为准
 if (type == TYPE_CIRCLE)
 {
  mWidth = Math.min(getMeasuredWidth(), getMeasuredHeight());
  //圆形的半径
  mRadius = mWidth / 2;
  setMeasuredDimension(mWidth, mWidth);
 } 

 } 

 // 初始化BitmapShader,获取到图片资源
 // 等待画布的准备好，然后在画布上加上Paint就是了
 //就是说图片的载体是Paint
 private void setUpShader()
 {
 Drawable drawable = getDrawable();
 if (drawable == null)
 {
  return;
 } 

 Bitmap bmp = drawableToBitamp(drawable);
 // 将bmp作为着色器，就是在指定区域内绘制bmp
 //TileMode.CLAMP 拉伸
 mBitmapShader = new BitmapShader(bmp, TileMode.CLAMP, TileMode.CLAMP);
 float scale = 1.0f;
 if (type == TYPE_CIRCLE)
 {
  // 拿到bitmap宽或高的小值
  int bSize = Math.min(bmp.getWidth(), bmp.getHeight());
  scale = mWidth * 1.0f / bSize; 

 } else if (type == TYPE_RECT)
 {
  if (!(bmp.getWidth() == getWidth() && bmp.getHeight() == getHeight()))
  {
  // 如果图片的宽或者高与view的宽高不匹配，计算出需要缩放的比例；缩放后的图片的宽高，一定要大于我们view的宽高；所以我们这里取大值；
  scale = Math.max(getWidth() * 1.0f / bmp.getWidth(),
   getHeight() * 1.0f / bmp.getHeight());
  } 

 }
 // shader的变换矩阵，我们这里主要用于放大或者缩小
 // scale * scale 的矩阵
 mMatrix.setScale(scale, scale);
 // 设置变换矩阵
 mBitmapShader.setLocalMatrix(mMatrix);
 // 设置shader
 mBitmapPaint.setShader(mBitmapShader);
 } 

 @Override
 protected void onDraw(Canvas canvas)
 {
 if (getDrawable() == null)
 {
  return;
 }
 setUpShader(); 

 if (type == TYPE_RECT)
 {
  //绘制矩形
  canvas.drawRoundRect(mRoundRect, mBorderRadius, mBorderRadius,
   mBitmapPaint);
 } else
 {
  //绘制圆形
  canvas.drawCircle(mRadius, mRadius, mRadius, mBitmapPaint);
 }
 } 

 @Override
 protected void onSizeChanged(int w, int h, int oldw, int oldh)
 {
 super.onSizeChanged(w, h, oldw, oldh); 

 // 圆角图片的范围
 if (type == TYPE_RECT)
  mRoundRect = new RectF(0, 0, w, h);
 } 

 //drawable转bitmap
 private Bitmap drawableToBitamp(Drawable drawable)
 {
 //从控件的src获取背景，也是drawable文件获取
 if (drawable instanceof BitmapDrawable)
 {
  BitmapDrawable bd = (BitmapDrawable) drawable;
  return bd.getBitmap();
 } 

 //如果没有绘图一个，只不过是空白的图片
 int w = drawable.getIntrinsicWidth();
 int h = drawable.getIntrinsicHeight(); 

 Bitmap bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
 Canvas canvas = new Canvas(bitmap);
 drawable.setBounds(0, 0, w, h);
 drawable.draw(canvas);
 return bitmap;
 } 

 private static final String STATE_INSTANCE = "state_instance";
 private static final String STATE_TYPE = "state_type";
 private static final String STATE_BORDER_RADIUS = "state_border_radius"; 

 //屏幕旋转后，取出保存的值
 @Override
 protected Parcelable onSaveInstanceState()
 {
 Bundle bundle = new Bundle();
 bundle.putParcelable(STATE_INSTANCE, super.onSaveInstanceState());
 bundle.putInt(STATE_TYPE, type);
 bundle.putInt(STATE_BORDER_RADIUS, mBorderRadius);
 return bundle;
 } 

 //屏幕旋转，变量的保存，因为外面设置值，如果不保存，一旋转就变成个xml里面设置的值
 @Override
 protected void onRestoreInstanceState(Parcelable state)
 {
 if (state instanceof Bundle)
 {
  Bundle bundle = (Bundle) state;
  super.onRestoreInstanceState(((Bundle) state)
   .getParcelable(STATE_INSTANCE));
  this.type = bundle.getInt(STATE_TYPE);
  this.mBorderRadius = bundle.getInt(STATE_BORDER_RADIUS);
 } else
 {
  super.onRestoreInstanceState(state);
 } 

 } 

 //设置矩形圆角幅度后，重新绘制控件
 public void setBorderRadius(int borderRadius)
 {
 int pxVal = dp2px(borderRadius);
 if (this.mBorderRadius != pxVal)
 {
  this.mBorderRadius = pxVal;
  invalidate();
 }
 } 

 //设置是圆形还是矩形圆角
 public void setType(int type)
 {
 if (this.type != type)
 {
  this.type = type;
  if (this.type != TYPE_RECT && this.type != TYPE_CIRCLE)
  {
  this.type = TYPE_CIRCLE;
  }
  requestLayout();
 } 

 } 

 //dp转px
 public int dp2px(int dpVal)
 {
 return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
  dpVal, getResources().getDisplayMetrics());
 } 

}

3、滑动旋转缩放的bimp图片

package com.example.customimage.view; 

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PaintFlagsDrawFilter;
import android.graphics.PointF;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.widget.ImageView; 

public class MatrixImageView extends ImageView {
 private static final int MODE_NONE = 0x00123;// 默认的触摸模式
 private static final int MODE_DRAG = 0x00321;// 拖拽模式
 private static final int MODE_ZOOM = 0x00132;// 缩放or旋转模式 

 private int mode;// 当前的触摸模式 

 private float preMove = 1F;// 上一次手指移动的距离
 private float saveRotate = 0F;// 保存了的角度值
 private float rotate = 0F;// 旋转的角度 

 private float[] preEventCoor;// 上一次各触摸点的坐标集合 

 private PointF startPointF, midPointF;// 起点、中点对象
 private Matrix currentMatrix, savedMatrix;// 当前和保存了的Matrix对象 

 //原始图片
 private Bitmap mSrc; 

 //控件的宽度
 private int mWidth; 

 // 控件的高度
 private int mHeight; 

 private PaintFlagsDrawFilter mDrawFilter; 

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

 // 初始化
 init();
 } 

 /**
 * 初始化
 */
 private void init() {
 // 实例化对象 

 currentMatrix = new Matrix();
 savedMatrix = new Matrix();
 startPointF = new PointF();
 midPointF = new PointF();
 mDrawFilter = new PaintFlagsDrawFilter(0, Paint.ANTI_ALIAS_FLAG|Paint.FILTER_BITMAP_FLAG);
 // 模式初始化
 mode = MODE_NONE; 

 Drawable drawable = getDrawable();
 mSrc = drawableToBitamp(drawable); 

 } 

 /**
 * 计算控件的高度和宽度
 */
 @Override
 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
 {
 // 设置宽度
 int specMode = MeasureSpec.getMode(widthMeasureSpec);
 int specSize = MeasureSpec.getSize(widthMeasureSpec); 

 //match_parent或者设置的精确值获取
 //MeasureSpec.EXACTLY
 if (specMode == MeasureSpec.EXACTLY)
 {
  mWidth = specSize;
 }
 else
 {
  // 由图片决定的宽
  //getPaddingLeft(),getPaddingRight()这两个值是控件属性的向内偏移的距离值，所以的一起计算
  //区别于layout_marginLeft,两个控件的左间距值设置
  int desireByImg = getPaddingLeft() + getPaddingRight()
   + mSrc.getWidth(); 

  // wrap_content
  if (specMode == MeasureSpec.AT_MOST)
  {
  //所以最小的值，宽度的话是左右内偏移距离之和
  mWidth = Math.min(desireByImg, specSize);
  } else 

  mWidth = desireByImg;
 } 

 // 设置高度，部分解释同上
 specMode = MeasureSpec.getMode(heightMeasureSpec);
 specSize = MeasureSpec.getSize(heightMeasureSpec); 

 //match_parent或者设置的精确值获取
 //MeasureSpec.EXACTLY
 if (specMode == MeasureSpec.EXACTLY)
 {
  mHeight = specSize;
 } else
 {
  int desire = getPaddingTop() + getPaddingBottom()
   + mSrc.getHeight(); 

  // wrap_content
  if (specMode == MeasureSpec.AT_MOST)
  {
  mHeight = Math.min(desire, specSize);
  } else
  mHeight = desire;
 } 

 //计算好的宽度以及高度是值，设置进去
 setMeasuredDimension(mWidth, mHeight);
 } 

 //drawable转bitmap
 private Bitmap drawableToBitamp(Drawable drawable)
 {
 //从控件的src获取背景，也是drawable文件获取
 if (drawable instanceof BitmapDrawable)
 {
  BitmapDrawable bd = (BitmapDrawable) drawable;
  return bd.getBitmap();
 } 

 //如果没有绘图一个，只不过是空白的图片
 int w = drawable.getIntrinsicWidth();
 int h = drawable.getIntrinsicHeight(); 

 Bitmap bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
 Canvas canvas = new Canvas(bitmap);
 drawable.setBounds(0, 0, w, h);
 drawable.draw(canvas);
 return bitmap;
 } 

 final Paint paint = new Paint();
 @Override
 protected void onDraw(Canvas canvas) {
 //消除锯齿, 图片旋转后的锯齿消除不成功，实在不行图片边缘加一些白色像素点
 canvas.setDrawFilter(mDrawFilter);
 //画经过Matrix变化后的图
 canvas.drawBitmap(mSrc, currentMatrix, null);
 } 

 @Override
 public boolean onTouchEvent(MotionEvent event) {
 switch (event.getAction() & MotionEvent.ACTION_MASK) {
 case MotionEvent.ACTION_DOWN:// 单点接触屏幕时
  savedMatrix.set(currentMatrix);
  startPointF.set(event.getX(), event.getY());
  //单点触摸是移动模式
  mode = MODE_DRAG;
  preEventCoor = null;
  break;
 case MotionEvent.ACTION_POINTER_DOWN:// 第二个点接触屏幕时
  preMove = calSpacing(event);
  if (preMove > 10F) {
  savedMatrix.set(currentMatrix);
  // 计算两个触摸点的中点坐标
  calMidPoint(midPointF, event);
  //两点是旋转或者缩放模式
  mode = MODE_ZOOM;
  }
  preEventCoor = new float[4];
  preEventCoor[0] = event.getX(0);
  preEventCoor[1] = event.getX(1);
  preEventCoor[2] = event.getY(0);
  preEventCoor[3] = event.getY(1);
  saveRotate = calRotation(event);
  break;
 case MotionEvent.ACTION_UP:// 单点离开屏幕时
 case MotionEvent.ACTION_POINTER_UP:// 第二个点离开屏幕时
  mode = MODE_NONE;
  preEventCoor = null;
  break;
 case MotionEvent.ACTION_MOVE:// 触摸点移动时
  /*
  * 单点触控拖拽平移
  */
  if (mode == MODE_DRAG) {
  currentMatrix.set(savedMatrix);
  float dx = event.getX() - startPointF.x;
  float dy = event.getY() - startPointF.y;
  currentMatrix.postTranslate(dx, dy);
  }
  /*
  * 两点触控拖放旋转
  */
  else if (mode == MODE_ZOOM && event.getPointerCount() == 2) {
  float currentMove = calSpacing(event);
  currentMatrix.set(savedMatrix);
  /*
   * 指尖移动距离大于10F缩放
   */
  if (currentMove > 10F) {
   float scale = currentMove / preMove;
   currentMatrix.postScale(scale, scale, midPointF.x, midPointF.y);
  }
  /*
   * 保持两点时旋转
   */
  if (preEventCoor != null) {
   rotate = calRotation(event);
   r = rotate - saveRotate;
   currentMatrix.postRotate(r, getMeasuredWidth() / 2, getMeasuredHeight() / 2);
  }
  }
  break;
 } 

 setImageMatrix(currentMatrix);
 return true;
 } 

 float r; 

 /**
 * 计算两个触摸点间的距离
 */
 private float calSpacing(MotionEvent event) {
 float x = event.getX(0) - event.getX(1);
 float y = event.getY(0) - event.getY(1);
 return (float) Math.sqrt(x * x + y * y);
 } 

 /**
 * 计算两个触摸点的中点坐标
 */
 private void calMidPoint(PointF point, MotionEvent event) {
 float x = event.getX(0) + event.getX(1);
 float y = event.getY(0) + event.getY(1);
 point.set(x / 2, y / 2);
 } 

 /**
 * 计算旋转角度
 *
 * @param 事件对象
 * @return 角度值
 */
 private float calRotation(MotionEvent event) {
 double deltaX = (event.getX(0) - event.getX(1));
 double deltaY = (event.getY(0) - event.getY(1));
 double radius = Math.atan2(deltaY, deltaX);
 return (float) Math.toDegrees(radius);
 } 

}

4、图片颜色处理（滑动)

package com.example.customimage.view; 

import com.example.customimage.R;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.ColorMatrixColorFilter;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PorterDuff.Mode;
import android.graphics.PorterDuffXfermode;
import android.graphics.RadialGradient;
import android.graphics.Shader.TileMode;
import android.util.AttributeSet;
import android.view.View; 

public class DreamEffectView extends View {
 private Paint mBitmapPaint, mShaderPaint;// 位图画笔和Shader图形的画笔
 private PorterDuffXfermode mXfermode;// 图形混合模式
 private int x, y;// 位图起点坐标
 //控件的宽度
 private int mWidth;
 // 控件的高度
 private int mHeight;
 //原始图片
 private Bitmap mSrc;
 //生成暗角的图片
 private Bitmap darkCornerBitmap;
 public final static int BITMAP_NULL = 0; //原图
 private final static int BITMAP_DEAST = 1; //去饱和
 private final static int BITMAP_CENTER = 2; //中心突出
 private final static int BITMAP_DARKCORNER = 3; //四角黑暗 

 private int mnSelectMode = 0; 

 public DreamEffectView(Context context, AttributeSet attrs)
 {
 this(context, attrs, 0);
 } 

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

 public DreamEffectView(Context context, AttributeSet attrs, int defStyle) {
 super(context, attrs,defStyle); 

 TypedArray a = context.getTheme().obtainStyledAttributes(attrs,
  R.styleable.DreamEffectView, defStyle, 0); 

 int n = a.getIndexCount();
 for (int i = 0; i < n; i++)
 {
  int attr = a.getIndex(i);
  switch (attr)
  {
  //原始图片，在布局里面获取
  case R.styleable.DreamEffectView_src:
  mSrc = BitmapFactory.decodeResource(getResources(),
   a.getResourceId(attr, 0));
  break;
  case R.styleable.DreamEffectView_mode:
  mnSelectMode = a.getInt(attr, 0);
  break;
  }
 }
 a.recycle(); 

 // 实例化混合模式
 mXfermode = new PorterDuffXfermode(Mode.SCREEN); 

 // 初始化画笔
 initPaint();
 } 

 /**
 * 计算控件的高度和宽度
 */
 @Override
 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
 {
 // 设置宽度
 int specMode = MeasureSpec.getMode(widthMeasureSpec);
 int specSize = MeasureSpec.getSize(widthMeasureSpec); 

 if (specMode == MeasureSpec.EXACTLY)
 {
  mWidth = specSize;
 }
 else
 {
  int desireByImg = getPaddingLeft() + getPaddingRight()
   + mSrc.getWidth(); 

  // wrap_content
  if (specMode == MeasureSpec.AT_MOST)
  {
  //所以最小的值，宽度的话是左右内偏移距离之和
  mWidth = Math.min(desireByImg, specSize);
  } else 

  mWidth = desireByImg;
 } 

 // 设置高度，部分解释同上
 specMode = MeasureSpec.getMode(heightMeasureSpec);
 specSize = MeasureSpec.getSize(heightMeasureSpec); 

 if (specMode == MeasureSpec.EXACTLY)
 {
  mHeight = specSize;
 } else
 {
  int desire = getPaddingTop() + getPaddingBottom()
   + mSrc.getHeight(); 

  // wrap_content
  if (specMode == MeasureSpec.AT_MOST)
  {
  mHeight = Math.min(desire, specSize);
  } else
  mHeight = desire;
 } 

 x = mWidth / 2 - mSrc.getWidth() / 2;
 y = mHeight / 2 - mSrc.getHeight() / 2; 

 //计算好的宽度以及高度是值，设置进去
 setMeasuredDimension(mWidth, mHeight);
 } 

 /**
 * 初始化画笔
 */
 private void initPaint() {
 // 实例化画笔
 mBitmapPaint = new Paint(Paint.ANTI_ALIAS_FLAG); 

 // 实例化Shader图形的画笔
 mShaderPaint = new Paint();
 switch (mnSelectMode) {
 case BITMAP_NULL: 

  break;
 case BITMAP_DEAST:
  // 去饱和、提亮、色相矫正
  mBitmapPaint.setColorFilter(new ColorMatrixColorFilter(
   new float[] { 0.8587F, 0.2940F, -0.0927F, 0, 6.79F, 0.0821F, 0.9145F, 0.0634F, 0, 6.79F,
    0.2019F, 0.1097F, 0.7483F, 0, 6.79F, 0, 0, 0, 1, 0 })); 

  break;
 case BITMAP_CENTER:
  // 去饱和、提亮、色相矫正
  mBitmapPaint.setColorFilter(new ColorMatrixColorFilter(
   new float[] { 0.8587F, 0.2940F, -0.0927F, 0, 6.79F, 0.0821F, 0.9145F, 0.0634F, 0, 6.79F,
    0.2019F, 0.1097F, 0.7483F, 0, 6.79F, 0, 0, 0, 1, 0 }));
  // 设置径向渐变，渐变中心当然是图片的中心也是屏幕中心，渐变半径我们直接拿图片的高度但是要稍微小一点
  // 中心颜色为透明而边缘颜色为黑色
  mShaderPaint.setShader(new RadialGradient(mWidth / 2, mWidth / 2, mSrc.getHeight() * 7 / 8, Color.TRANSPARENT,
   Color.BLACK, TileMode.CLAMP));
  break;
 case BITMAP_DARKCORNER:
  // 去饱和、提亮、色相矫正
  mBitmapPaint.setColorFilter(new ColorMatrixColorFilter(
   new float[] { 0.8587F, 0.2940F, -0.0927F, 0, 6.79F, 0.0821F, 0.9145F, 0.0634F, 0, 6.79F,
    0.2019F, 0.1097F, 0.7483F, 0, 6.79F, 0, 0, 0, 1, 0 }));
  // 根据我们源图的大小生成暗角Bitmap
  darkCornerBitmap = Bitmap.createBitmap(mSrc.getWidth(), mSrc.getHeight(), Bitmap.Config.ARGB_8888); 

  // 将该暗角Bitmap注入Canvas
  Canvas canvas = new Canvas(darkCornerBitmap); 

  // 计算径向渐变半径
  float radiu = canvas.getHeight() * (2F / 3F); 

  // 实例化径向渐变
  RadialGradient radialGradient = new RadialGradient(canvas.getWidth() / 2F, canvas.getHeight() / 2F, radiu, new int[] { 0, 0, 0xAA000000 }, new float[] { 0F, 0.7F, 1.0F }, TileMode.CLAMP); 

  // 实例化一个矩阵
  Matrix matrix = new Matrix(); 

  // 设置矩阵的缩放
  matrix.setScale(canvas.getWidth() / (radiu * 2F), 1.0F); 

  // 设置矩阵的预平移
  matrix.preTranslate(((radiu * 2F) - canvas.getWidth()) / 2F, 0); 

  // 将该矩阵注入径向渐变
  radialGradient.setLocalMatrix(matrix); 

  // 设置画笔Shader
  mShaderPaint.setShader(radialGradient); 

  // 绘制矩形
  canvas.drawRect(0, 0, canvas.getWidth(), canvas.getHeight(), mShaderPaint);
  break;
 default:
  break;
 }
 } 

 @Override
 protected void onDraw(Canvas canvas) {
 canvas.drawColor(Color.BLACK); 

 // 新建图层
 int sc = canvas.saveLayer(x, y, x + mSrc.getWidth(), y + mSrc.getHeight(), null, Canvas.ALL_SAVE_FLAG); 

 // 绘制混合颜色
 canvas.drawColor(0xcc1c093e); 

 // 设置混合模式
 mBitmapPaint.setXfermode(mXfermode); 

 // 绘制位图
 canvas.drawBitmap(mSrc, x, y, mBitmapPaint); 

 // 还原混合模式
 mBitmapPaint.setXfermode(null); 

 // 还原画布
 canvas.restoreToCount(sc); 

 switch (mnSelectMode) {
 case BITMAP_NULL: 

  break;
 case BITMAP_DEAST:
  break;
 case BITMAP_CENTER:
  // 绘制一个跟图片大小一样的矩形
  canvas.drawRect(x, y, x + mSrc.getWidth(), y + mSrc.getHeight(),mShaderPaint);
  break;
 case BITMAP_DARKCORNER:
  // 绘制我们画好的径向渐变图
  canvas.drawBitmap(darkCornerBitmap, x, y, null);
  break;
 default:
  break;
 }
 }
}

1）、实现 去饱和、提亮、色相矫正 效果的部分代码 

mBitmapPaint.setColorFilter(new ColorMatrixColorFilter(
 new float[] { 0.8587F, 0.2940F, -0.0927F, 0, 6.79F, 0.0821F, 0.9145F, 0.0634F, 0, 6.79F,
  0.2019F, 0.1097F, 0.7483F, 0, 6.79F, 0, 0, 0, 1, 0 }));

2）、实现中心颜色为透明而边缘颜色为黑色效果的部分代码   

mShaderPaint.setShader(new RadialGradient(mWidth / 2, mWidth / 2, mSrc.getHeight() * 7 / 8, Color.TRANSPARENT,
 Color.BLACK, TileMode.CLAMP));

3）、实现四角黑暗效果的部分代码

// 根据我们源图的大小生成暗角Bitmap
darkCornerBitmap = Bitmap.createBitmap(mSrc.getWidth(), mSrc.getHeight(), Bitmap.Config.ARGB_8888); 

// 将该暗角Bitmap注入Canvas
Canvas canvas = new Canvas(darkCornerBitmap); 

// 计算径向渐变半径
float radiu = canvas.getHeight() * (2F / 3F); 

// 实例化径向渐变
RadialGradient radialGradient = new RadialGradient(canvas.getWidth() / 2F, canvas.getHeight() / 2F, radiu, new int[] { 0, 0, 0xAA000000 }, new float[] { 0F, 0.7F, 1.0F }, TileMode.CLAMP); 

// 实例化一个矩阵
Matrix matrix = new Matrix(); 

// 设置矩阵的缩放
matrix.setScale(canvas.getWidth() / (radiu * 2F), 1.0F); 

// 设置矩阵的预平移
matrix.preTranslate(((radiu * 2F) - canvas.getWidth()) / 2F, 0); 

// 将该矩阵注入径向渐变
radialGradient.setLocalMatrix(matrix); 

// 设置画笔Shader
mShaderPaint.setShader(radialGradient); 

// 绘制矩形
canvas.drawRect(0, 0, canvas.getWidth(), canvas.getHeight(), mShaderPaint);

5、图片 + 文字

package com.example.customimage.view; 

import com.example.customimage.R; 

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.RectF;
import android.graphics.Bitmap.Config;
import android.graphics.Paint.Style;
import android.graphics.Rect;
import android.text.TextPaint;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.util.Log;
import android.util.TypedValue;
import android.view.View; 

public class ImageViewText extends View{ 

 //类型
 private int type;
 private static final int TYPE_CIRCLE = 0; //圆形
 private static final int TYPE_RECT = 1; //矩形圆角
 //原始图片
 private Bitmap mImage;
 //控件的宽度
 private int mWidth; 

 // 控件的高度
 private int mHeight; 

 //矩形圆角的幅度
 private int mRadius;
 //图片下面的文字
 private String mTitle;
 private int mTextColor;
 private int mTextSize;
 private Rect rect;
 private Paint mPaint;
 private Rect mTextBound; 

 public ImageViewText(Context context, AttributeSet attrs)
 {
 this(context, attrs, 0);
 } 

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

 /**
 * 初始化所特有自定义类型
 *
 * @param context
 * @param attrs
 * @param defStyle
 */
 public ImageViewText(Context context, AttributeSet attrs, int defStyle)
 {
 super(context, attrs, defStyle); 

 TypedArray a = context.getTheme().obtainStyledAttributes(attrs, R.styleable.ImageViewText, defStyle, 0); 

 int n = a.getIndexCount(); 

 for (int i = 0; i < n; i++)
 {
  int attr = a.getIndex(i); 

  switch (attr)
  {
  //获取图片
  case R.styleable.ImageViewText_image:
  mImage = BitmapFactory.decodeResource(getResources(), a.getResourceId(attr, 0));
  break;
  //获取圆形还是方形
  case R.styleable.ImageViewText_type:
  type = a.getInt(attr, 0);
  break;
  //获取文字
  case R.styleable.ImageViewText_titleText:
  mTitle = a.getString(attr);
  break;
  //获取文字的图片
  case R.styleable.ImageViewText_titleTextColor:
  mTextColor = a.getColor(attr, Color.BLACK);
  break;
  //获取文字的大小
  case R.styleable.ImageViewText_titleTextSize:
  mTextSize = a.getDimensionPixelSize(attr, (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP,
   16, getResources().getDisplayMetrics()));
  break;
  //矩形圆角幅度的获取，默认是10dp
  case R.styleable.ImageViewText_borderRadius:
  mRadius = a.getDimensionPixelSize(attr, (int) TypedValue
   .applyDimension(TypedValue.COMPLEX_UNIT_DIP, 10f,
    getResources().getDisplayMetrics()));
  break;
  }
 }
 a.recycle();
 rect = new Rect();
 mPaint = new Paint();
 mTextBound = new Rect();
 mPaint.setTextSize(mTextSize);
 // 计算了描绘字体需要的范围
 mPaint.getTextBounds(mTitle, 0, mTitle.length(), mTextBound); 

 } 

 //测量控件的大小
 @Override
 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
 { 

 //设置宽度
 int specMode = MeasureSpec.getMode(widthMeasureSpec);
 int specSize = MeasureSpec.getSize(widthMeasureSpec);
 // match_parent , accurate 大小
 if (specMode == MeasureSpec.EXACTLY)
 {
  mWidth = specSize;
 } else
 {
  // 由图片决定的宽
  int desireByImg = getPaddingLeft() + getPaddingRight() + mImage.getWidth();
  // 由字体决定的宽
  int desireByTitle = getPaddingLeft() + getPaddingRight() + mTextBound.width();
  //wrap_content 大小
  if (specMode == MeasureSpec.AT_MOST)
  {
  //取小的值
  int desire = Math.max(desireByImg, desireByTitle);
  mWidth = Math.min(desire, specSize);
  }
 } 

 //设置高度
 specMode = MeasureSpec.getMode(heightMeasureSpec);
 // match_parent , accurate 大小
 if (specMode == MeasureSpec.EXACTLY)
 {
  mHeight = specSize;
 } else
 {
  //wrap_content 大小
  mHeight = getPaddingTop() + getPaddingBottom() + mImage.getHeight() + mTextBound.height();
 }
 //测量好的大小设置进去
 setMeasuredDimension(mWidth, mHeight);
 } 

 @Override
 protected void onDraw(Canvas canvas)
 {
 // 边框
 mPaint.setStrokeWidth(4);
 mPaint.setStyle(Paint.Style.STROKE);
 mPaint.setColor(Color.CYAN);
 canvas.drawRect(0, 0, getMeasuredWidth(), getMeasuredHeight(), mPaint); 

 mPaint.setColor(mTextColor);
 mPaint.setStyle(Style.FILL);
 //当前设置的宽度小于字体需要的宽度，将字体改为
 //绘制文字
 if (mTextBound.width() > mWidth)
 {
  TextPaint paint = new TextPaint(mPaint);
  String msg = TextUtils.ellipsize(mTitle, paint, (float) mWidth - getPaddingLeft() - getPaddingRight(),
   TextUtils.TruncateAt.END).toString();
  canvas.drawText(msg, getPaddingLeft(), mHeight - getPaddingBottom(), mPaint); 

 } else
 {
  //正常情况，将字体居中
  canvas.drawText(mTitle, mWidth / 2 - mTextBound.width() * 1.0f / 2, mHeight - getPaddingBottom(), mPaint);
 } 

  //计算居中的矩形范围
  rect.left = mWidth / 2 - mImage.getWidth() / 2 + getPaddingLeft();
  rect.right = mWidth / 2 + mImage.getWidth() / 2 + getPaddingRight();
  rect.top = (mHeight - mTextBound.height()) / 2 - mImage.getHeight() / 2 + getPaddingTop();
  rect.bottom = (mHeight - mTextBound.height()) / 2 + mImage.getHeight() / 2 + getPaddingBottom(); 

 switch (type)
 {
 // 如果是TYPE_CIRCLE绘制圆形
 case TYPE_CIRCLE:
  //圆形宽度和高度应该一致的，所以也要比较一下大小，取小的值
  int min = Math.min(mWidth, mHeight);
  // 圆形宽度和高度如果不一致，按小的值进行压缩
  mImage = Bitmap.createScaledBitmap(mImage, min, min, false);
  //绘制圆形
  canvas.drawBitmap(createCircleImage(mImage, min), null, rect, null);
  break;
 case TYPE_RECT:
  canvas.drawBitmap(createRoundConerImage(mImage), null, rect, null);
  break; 

 }
 } 

 /**
 * 根据原图和变长绘制圆形图片
 *
 * @param source
 * @param min
 * @return
 */
 private Bitmap createCircleImage(Bitmap source, int min)
 {
 final Paint paint = new Paint();
 //防止边缘的抗锯齿
 paint.setAntiAlias(true); 

 Bitmap target = Bitmap.createBitmap(min, min, Config.ARGB_8888);
 // 产生一个同样大小的画布
 Canvas canvas = new Canvas(target);
 // 首先绘制圆形,除以2就是半径了
 //最主要设置第三个参数为min/2，圆角幅度那么大就是圆形了
 canvas.drawCircle(min / 2, min / 2, min/2, paint);
 // 使用SRC_IN，参考上面的说明---上下层都显示。下层居上显示
 paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
 // 绘制图片
 canvas.drawBitmap(source, 0, 0, paint);
 return target;
 } 

 /**
 * 根据原图添加圆角
 *
 * @param source
 * @return
 */
 private Bitmap createRoundConerImage(Bitmap source)
 {
 final Paint paint = new Paint();
 paint.setAntiAlias(true);
 Bitmap target = Bitmap.createBitmap(mWidth, mHeight, Config.ARGB_8888);
 Canvas canvas = new Canvas(target);
 //绘制矩形
 RectF rect = new RectF(0, 0, source.getWidth(), source.getHeight());
 //设置圆角幅度
 canvas.drawRoundRect(rect, mRadius, mRadius, paint);
 // 使用SRC_IN，参考上面的说明---上下层都显示。下层居上显示
 paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
 canvas.drawBitmap(source, 0, 0, paint);
 return target;
 }
}

是不是很全的Android自定义图片集合，希望大家喜欢。

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索Android图片
Android自定义图片
android 图片集合、android 自定义图片、android自定义图片xml、vba 自定义属性的集合、c 自定义集合，以便于您获取更多的相关知识。

时间： 2024-08-06 12:38:05

Android自定义图片集合_Android的相关文章

Android自定义图片集合

本文主要包括以下内容: 使用Xfermode设置圆角图片 使用BitmapShader设置圆角图片 滑动旋转缩放的bimp图片 图片颜色处理(滑动) 图片 + 文字 其中1,2是两种不同方式处理图片圆角的情况.3,是通过Matrix进行图片缩放,旋转等.4,是通过Matrix操作图片的处理,包括去饱和,四角黑影,中心突出等.5,图片加文字组合显示. 如果暂时感觉这些看不懂: 先看看这两篇: Android自定义控件深入学习 Android生成随机验证码 详解Android自定义控件属性Typed

学习Android自定义Spinner适配器_Android

本文为大家分享Android自定义Spinner适配器的相关知识点,供大家参考,具体内容如下 一.大致效果 二.关键代码 在注释中讲重点吧. (1)Spinner的布局: car_brand_spinner.xml 即为弹出来的下拉列表的布局啦,后面的那个布局就不拿出来丢人现眼了,反正知道有一个Spinner的id为carBrandSpinner就可以了. <?xml version="1.0" encoding="utf-8"?> <Linear

Android 自定义Dialog 实例_Android

开发中经常需要请求网络获取数据,我们在请求网络到得到数据时当中需要等待一些时间,为了增加用户体验,我们一般会用一个Dialog来提示用户我们在加载网络数据. 今天我们来实现如下效果的加载中Dialog.   从图中我们可以看到要这个Dialog是图片还有文字组成的,(不过我这里使用代码实现的,没有用图片),以下是这个加载图形的代码: public class LVCircularRing extends View { private float mWidth = 0f; private floa

Android 自定义View步骤_Android

例子如下:Android 自定义View 密码框 例子 1 良好的自定义View 易用,标准,开放. 一个设计良好的自定义view和其他设计良好的类很像.封装了某个具有易用性接口的功能组合,这些功能能够有效地使用CPU和内存,并且十分开放的.但是,除了开始一个设计良好的类之外,一个自定义view应该: l 符合安卓标准 l 提供能够在Android XML布局中工作的自定义样式属性 l 发送可访问的事件 l 与多个Android平台兼容. Android框架提供了一套基本的类和XML标签来帮您创

Android自定义ActionBar实例_Android

本文实例讲述了Android自定义ActionBar的实现方法.分享给大家供大家参考.具体实现方法如下: Android 3.0及以上已经有了ActionBar的API,可以通过引入support package在3.0以下的平台引用这些API,但这儿呢,完全自定义一个ActionBar,不用引入额外jar包,参照的是开源的UI组件GreeenDroid,项目主页:https://github.com/cyrilmottier/GreenDroid .提取出关于ActionBar的相关文件,你可

Android 自定义标题栏背景_Android

设置标题栏背景 1> 准备背景图片: background_pix.png 注:用背景图片比用颜色好处,可以让背景看起来有凹凸感. 2> drawable文件夹下放xml文件 bitmap_repeat.xml <?xml version="1.0" encoding="utf-8"?> <bitmap xmlns:android="http://schemas.android.com/apk/res/android"

Android自定义等待对话框_Android

最近,看了好多的APP的等待对话框,发现自己的太lower,于是就研究了一番,最后经过苦心努力,实现一个. 自定义一个LoadingIndicatorView(extends View )类 编写values/attrs.xml,在其中编写styleable和item等标签元素 在布局文件中LoadingIndicatorView使用自定义的属性(注意namespace) 在LoadingIndicatorView的构造方法中通过TypedArray获取 描述就提供这些,一下是代码的展示,非常的

Android自定义 WebView浏览器_Android

WebView是Android中一个非常实用的组件,它和Safai.Chrome一样都是基于Webkit网页渲染引擎,可以通过加载HTML数据的方式便捷地展现软件的界面. 在布局文件中添加<EditText/>和<Button/>控件, 在布局文件中添加<WebView/>控件 在Activity中获取WebView对象 调用WebView对象的loadUrl()方法,参数:String路径 添加访问网络的权限android.permission.INTERNET 调用

Android自定义ViewPager实例_Android

本文实例讲述了Android自定义ViewPager的方法.分享给大家供大家参考,具体如下: package com.rong.activity; import android.content.Context; import android.graphics.Color; import android.util.AttributeSet; import android.view.MotionEvent; import android.view.VelocityTracker; import an