android图片处理方法

 /**
      * 将彩色图转换为灰度图
      * @param img 位图
      * @return  返回转换好的位图
      */
     public Bitmap convertGreyImg(Bitmap img) {
         int width = img.getWidth();         //获取位图的宽
         int height = img.getHeight();       //获取位图的高

         int []pixels = new int[width * height]; //通过位图的大小创建像素点数组

         img.getPixels(pixels, 0, width, 0, 0, width, height);
         int alpha = 0xFF << 24;
         for(int i = 0; i < height; i++)  {
             for(int j = 0; j < width; j++) {
                 int grey = pixels[width * i + j];

                 int red = ((grey  & 0x00FF0000 ) >> 16);
                 int green = ((grey & 0x0000FF00) >> 8);
                 int blue = (grey & 0x000000FF);

                 grey = (int)((float) red * 0.3 + (float)green * 0.59 + (float)blue * 0.11);
                 grey = alpha | (grey << 16) | (grey << 8) | grey;
                 pixels[width * i + j] = grey;
             }
         }
         Bitmap result = Bitmap.createBitmap(width, height, Config.RGB_565);
         result.setPixels(pixels, 0, width, 0, 0, width, height);
         return result;
     }

 

将一个图片切割成多个图片  
有种场景，我们想将一个图片切割成多个图片。比如我们在开发一个拼图的游戏，就首先要对图片进行切割。 
以下是封装好的两个类，可以实现图片的切割。仅供参考和学习。 
一个是ImagePiece类，此类保存了一个Bitmap对象和一个标识图片的顺序索引的int变量。 

 import android.graphics.Bitmap;
 public class ImagePiece {
     public int index = 0;
     public Bitmap bitmap = null;
 }

一个是ImageSplitter类，有一个静态方法split，传入的参数是要切割的Bitmap对象，和横向和竖向的切割片数。比如传入的是3、3，则横竖向都切割成3片，最终会将整个图片切割成3X3=9片。 

 import java.util.ArrayList;
 import java.util.List;

 import android.graphics.Bitmap;

 public class ImageSplitter {

     public static List<ImagePiece> split(Bitmap bitmap, int xPiece, int yPiece) {

         List<ImagePiece> pieces = new ArrayList<ImagePiece>(xPiece * yPiece);
         int width = bitmap.getWidth();
         int height = bitmap.getHeight();
         int pieceWidth = width / 3;
         int pieceHeight = height / 3;
         for (int i = 0; i < yPiece; i++) {
             for (int j = 0; j < xPiece; j++) {
                 ImagePiece piece = new ImagePiece();
                 piece.index = j + i * xPiece;
                 int xValue = j * pieceWidth;
                 int yValue = i * pieceHeight;
                 piece.bitmap = Bitmap.createBitmap(bitmap, xValue, yValue,
                         pieceWidth, pieceHeight);
                 pieces.add(piece);
             }
         }

         return pieces;
     }

 }

1、图标加灰色过滤；  
2、android的图片资源默认是静态的，单实例；如果两个IM好友的头像一样，最简单的都是用的软件自带头像，有一个在线，一个离线，直接改变头像的灰度，则两个用户的头像都会变灰或者在线，答案是：Drawable.mutate()。 

 Drawable mDrawable = context.getResources().getDrawable(R.drawable.face_icon);
 //Make this drawable mutable.
 //A mutable drawable is guaranteed to not share its state with any other drawable.
 mDrawable.mutate();
 ColorMatrix cm = new ColorMatrix();
 cm.setSaturation(0);
 ColorMatrixColorFilter cf = new ColorMatrixColorFilter(cm);
 mDrawable.setColorFilter(cf);

生成缩略图，抠自android launcher源码：  

 /*
  * Copyright (C) 2008 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.launcher;

 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 import android.graphics.drawable.PaintDrawable;
 import android.graphics.Bitmap;
 import android.graphics.PixelFormat;
 import android.graphics.Canvas;
 import android.graphics.PaintFlagsDrawFilter;
 import android.graphics.Paint;
 import android.graphics.Rect;
 import android.content.res.Resources;
 import android.content.Context;

 /**
  * Various utilities shared amongst the Launcher's classes.
  */
 final class Utilities {
     private static int sIconWidth = -1;
     private static int sIconHeight = -1;

     private static final Paint sPaint = new Paint();
     private static final Rect sBounds = new Rect();
     private static final Rect sOldBounds = new Rect();
     private static Canvas sCanvas = new Canvas();

     static {
         sCanvas.setDrawFilter(new PaintFlagsDrawFilter(Paint.DITHER_FLAG,
                 Paint.FILTER_BITMAP_FLAG));
     }

     /**
      * Returns a Drawable representing the thumbnail of the specified Drawable.
      * The size of the thumbnail is defined by the dimension
      * android.R.dimen.launcher_application_icon_size.
      *
      * This method is not thread-safe and should be invoked on the UI thread only.
      *
      * @param icon The icon to get a thumbnail of.
      * @param context The application's context.
      *
      * @return A thumbnail for the specified icon or the icon itself if the
      *         thumbnail could not be created.
      */
     static Drawable createIconThumbnail(Drawable icon, Context context) {
         if (sIconWidth == -1) {
             final Resources resources = context.getResources();
             sIconWidth = sIconHeight = (int) resources.getDimension(android.R.dimen.app_icon_size);
         }

         int width = sIconWidth;
         int height = sIconHeight;

         float scale = 1.0f;
         if (icon instanceof PaintDrawable) {
             PaintDrawable painter = (PaintDrawable) icon;
             painter.setIntrinsicWidth(width);
             painter.setIntrinsicHeight(height);
         } else if (icon instanceof BitmapDrawable) {
             // Ensure the bitmap has a density.
             BitmapDrawable bitmapDrawable = (BitmapDrawable) icon;
             Bitmap bitmap = bitmapDrawable.getBitmap();
             if (bitmap.getDensity() == Bitmap.DENSITY_NONE) {
                 bitmapDrawable.setTargetDensity(context.getResources().getDisplayMetrics());
             }
         }
         int iconWidth = icon.getIntrinsicWidth();
         int iconHeight = icon.getIntrinsicHeight();

         if (width > 0 && height > 0) {
             if (width < iconWidth || height < iconHeight || scale != 1.0f) {
                 final float ratio = (float) iconWidth / iconHeight;

                 if (iconWidth > iconHeight) {
                     height = (int) (width / ratio);
                 } else if (iconHeight > iconWidth) {
                     width = (int) (height * ratio);
                 }

                 final Bitmap.Config c = icon.getOpacity() != PixelFormat.OPAQUE ?
                             Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565;
                 final Bitmap thumb = Bitmap.createBitmap(sIconWidth, sIconHeight, c);
                 final Canvas canvas = sCanvas;
                 canvas.setBitmap(thumb);
                 // Copy the old bounds to restore them later
                 // If we were to do oldBounds = icon.getBounds(),
                 // the call to setBounds() that follows would
                 // change the same instance and we would lose the
                 // old bounds
                 sOldBounds.set(icon.getBounds());
                 final int x = (sIconWidth - width) / 2;
                 final int y = (sIconHeight - height) / 2;
                 icon.setBounds(x, y, x + width, y + height);
                 icon.draw(canvas);
                 icon.setBounds(sOldBounds);
                 icon = new FastBitmapDrawable(thumb);
             } else if (iconWidth < width && iconHeight < height) {
                 final Bitmap.Config c = Bitmap.Config.ARGB_8888;
                 final Bitmap thumb = Bitmap.createBitmap(sIconWidth, sIconHeight, c);
                 final Canvas canvas = sCanvas;
                 canvas.setBitmap(thumb);
                 sOldBounds.set(icon.getBounds());
                 final int x = (width - iconWidth) / 2;
                 final int y = (height - iconHeight) / 2;
                 icon.setBounds(x, y, x + iconWidth, y + iconHeight);
                 icon.draw(canvas);
                 icon.setBounds(sOldBounds);
                 icon = new FastBitmapDrawable(thumb);
             }
         }

         return icon;
     }

     /**
      * Returns a Bitmap representing the thumbnail of the specified Bitmap.
      * The size of the thumbnail is defined by the dimension
      * android.R.dimen.launcher_application_icon_size.
      *
      * This method is not thread-safe and should be invoked on the UI thread only.
      *
      * @param bitmap The bitmap to get a thumbnail of.
      * @param context The application's context.
      *
      * @return A thumbnail for the specified bitmap or the bitmap itself if the
      *         thumbnail could not be created.
      */
     static Bitmap createBitmapThumbnail(Bitmap bitmap, Context context) {
         if (sIconWidth == -1) {
             final Resources resources = context.getResources();
             sIconWidth = sIconHeight = (int) resources.getDimension(
                     android.R.dimen.app_icon_size);
         }

         int width = sIconWidth;
         int height = sIconHeight;

         final int bitmapWidth = bitmap.getWidth();
         final int bitmapHeight = bitmap.getHeight();

         if (width > 0 && height > 0) {
             if (width < bitmapWidth || height < bitmapHeight) {
                 final float ratio = (float) bitmapWidth / bitmapHeight;

                 if (bitmapWidth > bitmapHeight) {
                     height = (int) (width / ratio);
                 } else if (bitmapHeight > bitmapWidth) {
                     width = (int) (height * ratio);
                 }

                 final Bitmap.Config c = (width == sIconWidth && height == sIconHeight) ?
                         bitmap.getConfig() : Bitmap.Config.ARGB_8888;
                 final Bitmap thumb = Bitmap.createBitmap(sIconWidth, sIconHeight, c);
                 final Canvas canvas = sCanvas;
                 final Paint paint = sPaint;
                 canvas.setBitmap(thumb);
                 paint.setDither(false);
                 paint.setFilterBitmap(true);
                 sBounds.set((sIconWidth - width) / 2, (sIconHeight - height) / 2, width, height);
                 sOldBounds.set(0, 0, bitmapWidth, bitmapHeight);
                 canvas.drawBitmap(bitmap, sOldBounds, sBounds, paint);
                 return thumb;
             } else if (bitmapWidth < width || bitmapHeight < height) {
                 final Bitmap.Config c = Bitmap.Config.ARGB_8888;
                 final Bitmap thumb = Bitmap.createBitmap(sIconWidth, sIconHeight, c);
                 final Canvas canvas = sCanvas;
                 final Paint paint = sPaint;
                 canvas.setBitmap(thumb);
                 paint.setDither(false);
                 paint.setFilterBitmap(true);
                 canvas.drawBitmap(bitmap, (sIconWidth - bitmapWidth) / 2,
                         (sIconHeight - bitmapHeight) / 2, paint);
                 return thumb;
             }
         }

         return bitmap;
     }
 }

 //Android Matrix类实现镜像方法
 public void drawRegion(Image image_src,

 int x_src, int y_src,

 int width, int height,

 int transform,

 int x_dest, int y_dest,

 int anchor){

 if((anchor&VCENTER) != 0){

 y_dest -= height/2;

 }else if((anchor&BOTTOM) != 0){

 y_dest -= height;

 }

 if((anchor&RIGHT) != 0){

 x_dest -= width;

 }else if((anchor&HCENTER) != 0){

 x_dest -= width/2;

 }

 Bitmap newMap = Bitmap.createBitmap(image_src.getBitmap(), x_src, y_src, width, height);

 Matrix mMatrix = new Matrix();

 Matrix temp = new Matrix();

 Matrix temp2 = new Matrix();

 float[] mirrorY = {

 -1, 0, 0,
 0, 1, 0,
 0, 0, 1

 };

 temp.setValues(mirrorY);

 switch(transform){

 case Sprite.TRANS_NONE:

 break;

 case Sprite.TRANS_ROT90:

 mMatrix.setRotate(90,width/2, height/2);

 break;

 case Sprite.TRANS_ROT180:

 mMatrix.setRotate(180,width/2, height/2);

 break;

 case Sprite.TRANS_ROT270:

 mMatrix.setRotate(270,width/2, height/2);

 break;

 case Sprite.TRANS_MIRROR:

 mMatrix.postConcat(temp);

 break;

 case Sprite.TRANS_MIRROR_ROT90:

 mMatrix.postConcat(temp);

 mMatrix.setRotate(90,width/2, height/2);

 break;

 case Sprite.TRANS_MIRROR_ROT180:

 mMatrix.postConcat(temp);

 mMatrix.setRotate(180,width/2, height/2);

 break;

 case Sprite.TRANS_MIRROR_ROT270:

 mMatrix.postConcat(temp);

 mMatrix.setRotate(270,width/2, height/2);

 break;

 }

 mMatrix.setTranslate(x_dest, y_dest);

 canvas.drawBitmap(newMap, mMatrix, mPaint);

 }

 //图片Url保存为位图并进行缩放操作
 //通过传入图片url获取位图方法
 public Bitmap returnBitMap(String url) {
         URL myFileUrl = null;
         Bitmap bitmap = null;
         try {
             myFileUrl = new URL(url);
         } catch (MalformedURLException e) {
             e.printStackTrace();
         }
         try {
             HttpURLConnection conn = (HttpURLConnection) myFileUrl
                     .openConnection();
             conn.setDoInput(true);
             conn.connect();
             InputStream is = conn.getInputStream();
             bitmap = BitmapFactory.decodeStream(is);
             is.close();
         } catch (IOException e) {
             e.printStackTrace();
         }
         Log.v(tag, bitmap.toString());

         return bitmap;
     }
 //通过传入位图,新的宽.高比进行位图的缩放操作
 public static Drawable resizeImage(Bitmap bitmap, int w, int h) {

         // load the origial Bitmap
         Bitmap BitmapOrg = bitmap;

         int width = BitmapOrg.getWidth();
         int height = BitmapOrg.getHeight();
         int newWidth = w;
         int newHeight = h;

         Log.v(tag, String.valueOf(width));
         Log.v(tag, String.valueOf(height));

         Log.v(tag, String.valueOf(newWidth));
         Log.v(tag, String.valueOf(newHeight));

         // calculate the scale
         float scaleWidth = ((float) newWidth) / width;
         float scaleHeight = ((float) newHeight) / height;

         // create a matrix for the manipulation
         Matrix matrix = new Matrix();
         // resize the Bitmap
         matrix.postScale(scaleWidth, scaleHeight);
         // if you want to rotate the Bitmap
         // matrix.postRotate(45);

         // recreate the new Bitmap
         Bitmap resizedBitmap = Bitmap.createBitmap(BitmapOrg, 0, 0, width,
                 height, matrix, true);

         // make a Drawable from Bitmap to allow to set the Bitmap
         // to the ImageView, ImageButton or what ever
         return new BitmapDrawable(resizedBitmap);

     }

 1.图片加载方法，方便用户加载图片
 /***
 * 加载本地图片
 * @param context：主运行函数实例
 * @param bitAdress：图片地址，一般指向R下的drawable目录
 * @return
 */
 public final Bitmap CreatImage(Context context, int bitAdress) {
 Bitmap bitmaptemp = null;
 bitmaptemp = BitmapFactory.decodeResource(context.getResources(),
 bitAdress);
 return bitmaptemp;
 }
 2.图片平均分割方法，将大图平均分割为N行N列，方便用户使用
 /***
 * 图片分割
 *
 * @param g
 * ：画布
 * @param paint
 * ：画笔
 * @param imgBit
 * ：图片
 * @param x
 * ：X轴起点坐标
 * @param y
 * ：Y轴起点坐标
 * @param w
 * ：单一图片的宽度
 * @param h
 * ：单一图片的高度
 * @param line
 * ：第几列
 * @param row
 * ：第几行
 */
 public final void cuteImage(Canvas g, Paint paint, Bitmap imgBit, int x,
 int y, int w, int h, int line, int row) {
 g.clipRect(x, y, x + w, h + y);
 g.drawBitmap(imgBit, x – line * w, y – row * h, paint);
 g.restore();
 }
 3.图片缩放，对当前图片进行缩放处理
 /***
 * 图片的缩放方法
 *
 * @param bgimage
 * ：源图片资源
 * @param newWidth
 * ：缩放后宽度
 * @param newHeight
 * ：缩放后高度
 * @return
 */
 public Bitmap zoomImage(Bitmap bgimage, int newWidth, int newHeight) {
 // 获取这个图片的宽和高
 int width = bgimage.getWidth();
 int height = bgimage.getHeight();
 // 创建操作图片用的matrix对象
 Matrix matrix = new Matrix();
 // 计算缩放率，新尺寸除原始尺寸
 float scaleWidth = ((float) newWidth) / width;
 float scaleHeight = ((float) newHeight) / height;
 // 缩放图片动作
 matrix.postScale(scaleWidth, scaleHeight);
 Bitmap bitmap = Bitmap.createBitmap(bgimage, 0, 0, width, height,
 matrix, true);
 return bitmap;
 }
 4.绘制带有边框的文字，一般在游戏中起文字的美化作用
 /***
 * 绘制带有边框的文字
 *
 * @param strMsg
 * ：绘制内容
 * @param g
 * ：画布
 * @param paint
 * ：画笔
 * @param setx
 * ：：X轴起始坐标
 * @param sety
 * ：Y轴的起始坐标
 * @param fg
 * ：前景色
 * @param bg
 * ：背景色
 */
 public void drawText(String strMsg, Canvas g, Paint paint, int setx,
 int sety, int fg, int bg) {
 paint.setColor(bg);
 g.drawText(strMsg, setx + 1, sety, paint);
 g.drawText(strMsg, setx, sety – 1, paint);
 g.drawText(strMsg, setx, sety + 1, paint);
 g.drawText(strMsg, setx – 1, sety, paint);
 paint.setColor(fg);
 g.drawText(strMsg, setx, sety, paint);
 g.restore();
 }
 5.Android 图片透明度处理代码
 /**
 * 图片透明度处理
 *
 * @param sourceImg
 *            原始图片
 * @param number
 *            透明度
 * @return
 */
 public static Bitmap setAlpha(Bitmap sourceImg, int number) {
 int[] argb = new int[sourceImg.getWidth() * sourceImg.getHeight()];
 sourceImg.getPixels(argb, 0, sourceImg.getWidth(), 0, 0,sourceImg.getWidth(), sourceImg.getHeight());// 获得图片的ARGB值
 number = number * 255 / 100;
 for (int i = 0; i < argb.length; i++) {
 argb = (number << 24) | (argb & 0×00FFFFFF);// 修改最高2位的值
 }
 sourceImg = Bitmap.createBitmap(argb, sourceImg.getWidth(), sourceImg.getHeight(), Config.ARGB_8888);
 return sourceImg;
 }
 6.图片翻转
 Resources res = this.getContext().getResources();
 img = BitmapFactory.decodeResource(res, R.drawable.slogo);
 Matrix matrix = new Matrix();
 matrix.postRotate(90);        /*翻转90度*/
 int width = img.getWidth();
 int height = img.getHeight();
 r_img = Bitmap.createBitmap(img, 0, 0, width, height, matrix, true);

 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.LinearGradient;
 import android.graphics.Matrix;
 import android.graphics.Paint;
 import android.graphics.PixelFormat;
 import android.graphics.PorterDuffXfermode;
 import android.graphics.Rect;
 import android.graphics.RectF;
 import android.graphics.Bitmap.Config;
 import android.graphics.PorterDuff.Mode;
 import android.graphics.Shader.TileMode;
 import android.graphics.drawable.Drawable;
 /**
 *
 * @author superdev
 * @version 1.0
 *
 */
 public class ImageUtil {

 /**
 * 放大缩小图片
 */
 public static Bitmap zoomBitmap(Bitmap bitmap, int w, int h) {
    int width = bitmap.getWidth();
    int height = bitmap.getHeight();
    Matrix matrix = new Matrix();
    float scaleWidht = ((float) w / width);
    float scaleHeight = ((float) h / height);
    matrix.postScale(scaleWidht, scaleHeight);
    Bitmap newbmp = Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, true);
    return newbmp;
 }

 /**
 * 将Drawable转化为Bitmap
 */
 public static Bitmap drawableToBitmap(Drawable drawable) {
    int width = drawable.getIntrinsicWidth();
    int height = drawable.getIntrinsicHeight();
    Bitmap bitmap = Bitmap.createBitmap(width, height, drawable.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565);
    Canvas canvas = new Canvas(bitmap);
    drawable.setBounds(0, 0, width, height);
    drawable.draw(canvas);
    return bitmap;

 }

 /**
 * 获得圆角图片的方法
 */
 public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, float roundPx) {

    Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Config.ARGB_8888);
    Canvas canvas = new Canvas(output);

    final int color = 0xff424242;
    final Paint paint = new Paint();
    final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
    final RectF rectF = new RectF(rect);

    paint.setAntiAlias(true);
    canvas.drawARGB(0, 0, 0, 0);
    paint.setColor(color);
    canvas.drawRoundRect(rectF, roundPx, roundPx, paint);

    paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
    canvas.drawBitmap(bitmap, rect, rect, paint);

    return output;
 }

 /**
 * 获得带倒影的图片方法
 */
 public static Bitmap createReflectionImageWithOrigin(Bitmap bitmap) {
    final int reflectionGap = 4;
    int width = bitmap.getWidth();
    int height = bitmap.getHeight();

    Matrix matrix = new Matrix();
    matrix.preScale(1, -1);

    Bitmap reflectionImage = Bitmap.createBitmap(bitmap, 0, height / 2, width, height / 2, matrix, false);

    Bitmap bitmapWithReflection = Bitmap.createBitmap(width, (height + height / 2), Config.ARGB_8888);

    Canvas canvas = new Canvas(bitmapWithReflection);
    canvas.drawBitmap(bitmap, 0, 0, null);
    Paint deafalutPaint = new Paint();
    canvas.drawRect(0, height, width, height + reflectionGap, deafalutPaint);

    canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);

    Paint paint = new Paint();
    LinearGradient shader = new LinearGradient(0, bitmap.getHeight(), 0, bitmapWithReflection.getHeight() + reflectionGap, 0x70ffffff, 0x00ffffff, TileMode.CLAMP);
    paint.setShader(shader);
    // Set the Transfer mode to be porter duff and destination in
    paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));
    // Draw a rectangle using the paint with our linear gradient
    canvas.drawRect(0, height, width, bitmapWithReflection.getHeight() + reflectionGap, paint);
    return bitmapWithReflection;
 }
 }

 private byte[] Bitmap2Bytes(Bitmap bm){
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    bm.compress(Bitmap.CompressFormat.PNG, 100, baos);
    return baos.toByteArray();
 }
 private Bitmap Bytes2Bimap(byte[] b){
             if(b.length!=0){
                 return BitmapFactory.decodeByteArray(b, 0, b.length);
             }
             else {
                 return null;
             }
       }

  /**
      * create the bitmap from a byte array
      *生成水印图片
      * @param src the bitmap object you want proecss
      * @param watermark the water mark above the src
      * @return return a bitmap object ,if paramter's length is 0,return null
      */
     private Bitmap createBitmap( Bitmap src, Bitmap watermark )
     {
         String tag = "createBitmap";
         Log.d( tag, "create a new bitmap" );
         if( src == null )
         {
             return null;
         }

         int w = src.getWidth();
         int h = src.getHeight();
         int ww = watermark.getWidth();
         int wh = watermark.getHeight();
         //create the new blank bitmap
         Bitmap newb = Bitmap.createBitmap( w, h, Config.ARGB_8888 );//创建一个新的和SRC长度宽度一样的位图
         Canvas cv = new Canvas( newb );
         //draw src into
         cv.drawBitmap( src, 0, 0, null );//在 0，0坐标开始画入src
         //draw watermark into
         cv.drawBitmap( watermark, w - ww + 5, h - wh + 5, null );//在src的右下角画入水印
         //save all clip
         cv.save( Canvas.ALL_SAVE_FLAG );//保存
         //store
         cv.restore();//存储
         return newb;
     }
    /** 重新编码Bitmap
    *
    * @param src
    *          需要重新编码的Bitmap
    *
    * @param format
    *          编码后的格式（目前只支持png和jpeg这两种格式）
    *
    * @param quality
    *          重新生成后的bitmap的质量
    *
    * @return
    *          返回重新生成后的bitmap
    */
  private static Bitmap codec(Bitmap src, Bitmap.CompressFormat format,
                                     int quality) {
             ByteArrayOutputStream os = new ByteArrayOutputStream();
             src.compress(format, quality, os);

             byte[] array = os.toByteArray();
             return BitmapFactory.decodeByteArray(array, 0, array.length);
         }

 //Stream转换成Byte
 static byte[] streamToBytes(InputStream is) {
       ByteArrayOutputStream os = new ByteArrayOutputStream(1024);
       byte[] buffer = new byte[1024];
       int len;
       try {
              while ((len = is.read(buffer)) >= 0) {
              os.write(buffer, 0, len);
              }
           } catch (java.io.IOException e) {

           }
           return os.toByteArray();
 }
 //把View转换成Bitmap

     /**
      * 把一个View的对象转换成bitmap
      */
     static Bitmap getViewBitmap(View v) {

         v.clearFocus();
         v.setPressed(false);

         //能画缓存就返回false
         boolean willNotCache = v.willNotCacheDrawing();
         v.setWillNotCacheDrawing(false);
         int color = v.getDrawingCacheBackgroundColor();
         v.setDrawingCacheBackgroundColor(0);
         if (color != 0) {
             v.destroyDrawingCache();
         }
         v.buildDrawingCache();
         Bitmap cacheBitmap = v.getDrawingCache();
         if (cacheBitmap == null) {
             Log.e(TAG, "failed getViewBitmap(" + v + ")", new RuntimeException());
             return null;
         }
         Bitmap bitmap = Bitmap.createBitmap(cacheBitmap);
         // Restore the view
         v.destroyDrawingCache();
         v.setWillNotCacheDrawing(willNotCache);
         v.setDrawingCacheBackgroundColor(color);
         return bitmap;
     }

 读取raw资源文件中的mp3文件，然后通过音乐播放器播放：

     /**
      * 把mp3文件写入卡
      *
      * @param fileName
      *             输出的文件名（全路径）
      * @param context
          *             context对象
      */
     private void writeMP3ToSDcard(String fileName, Context context) {
         byte[] buffer = new byte[1024 * 8];
         int read;
         BufferedInputStream bin = new BufferedInputStream(context.getResources().openRawResource(R.raw.ring));
         try {
             BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(fileName));
             while ((read = bin.read(buffer)) > -1) {
                 bout.write(buffer, 0, read);
             }
             bout.flush();
             bout.close();
             bin.close();
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }


 Intent intent = new Intent();
 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
 intent.setAction(android.content.Intent.ACTION_VIEW);
 intent.setDataAndType(Uri.fromFile(newFile("XXXXmp3的文件全路径")),"audio/*");
 startActivity(intent);

绘制图像倒影  

 private void
 _Init()
 {
   m_paint = new Paint(Paint.ANTI_ALIAS_FLAG);
   LinearGradient lg = new LinearGradient(
     0, 0, 0, m_nShadowH,
     0xB0FFFFFF, 0x00000000,
     Shader.TileMode.CLAMP);
   m_paint.setShader(lg);
   m_paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.MULTIPLY));
 }

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

   int nX = 0;
   int nY = 20;

   _DrawNormalImg(canvas, nX, nY);
   _DrawMirror(canvas, nX, nY);
 }

 private void
 _DrawNormalImg(Canvas canvas, int nX, int nY)
 {
   canvas.save(Canvas.MATRIX_SAVE_FLAG);
   canvas.translate(nX, nY);
   m_dw.draw(canvas);
   canvas.restore();
 }

 private void
 _DrawMirror(Canvas canvas, int nX, int nY)
 {
   int nW = m_dw.getIntrinsicWidth();
   int nH = m_dw.getIntrinsicHeight();

   ///////////////////////////////////
   //draw mirror image
   canvas.save(Canvas.MATRIX_SAVE_FLAG);
   canvas.scale(1.0f, -1.0f);
   canvas.translate(nX, -(nY + nH * 2));
   canvas.clipRect(0, nH, nW, nH - m_nShadowH);
   m_dw.draw(canvas);
   canvas.restore();

   //////////////////////////////
   //draw mask
   canvas.save();
   canvas.translate(nX, nY + nH);
   canvas.drawRect(0, 0, nW, m_nShadowH, m_paint);
   canvas.restore();
 }

Android 繪圖座標體系預設的原點在左上角，X 軸往右是越來越大的正值，而 Y 軸往下，則是越來越大的正值。要畫出垂直翻轉的圖片，其實也就是要垂直翻轉整個繪圖座標體系。在 Android 中，要如何做？答案就是 canvas.scale(1.0f, -1.0f)。很簡單吧，沒想到給 scale() 函式一個負值，就可以翻轉相對應的軸。 
在 Photoshop 中，做鏡像特效的第二步是要對這翻轉的圖片，加個由灰到黑的漸層 mask。 
在 Android 中，要畫漸層色，那就一定得用 LinearGradient 這個類別。至於要對背景圖加上個 mask，就請參考一下 Paint 的 setXfermode() 函式。_Init() 這個函式，就是負責生成一個由灰到黑漸層 mask 的 m_paint 物件。