//压缩图片大小

publicstatic Bitmap compressImage(Bitmap p_w_picpath) {  

       ByteArrayOutputStream baos = new ByteArrayOutputStream();  

       p_w_picpath.compress(Bitmap.CompressFormat.JPEG, 100, baos);//质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中

int options = 100;  

while ( baos.toByteArray().length / 1024>100) {  //循环判断如果压缩后图片是否大于100kb,大于继续压缩      

           baos.reset();//重置baos即清空baos

           p_w_picpath.compress(Bitmap.CompressFormat.JPEG, options, baos);//这里压缩options%，把压缩后的数据存放到baos中

           options -= 10;//每次都减少10

       }  

       ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());//把压缩后的数据baos存放到ByteArrayInputStream中

       Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);//把ByteArrayInputStream数据生成图片

return bitmap;  

   }  

/**

    * 将彩×××转换为灰度图

    * @param img 位图

    * @return  返回转换好的位图

    */

public Bitmap convertGreyImg(Bitmap img) {    

int width = img.getWidth();         //获取位图的宽  

int height = img.getHeight();       //获取位图的高  

int []pixels = newint[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;    

   }    

import android.graphics.Bitmap;  

publicclass ImagePiece {    

publicint index = 0;          

public Bitmap bitmap = null;    

}  

import java.util.ArrayList;    

import java.util.List;    

import android.graphics.Bitmap;    

publicclass ImageSplitter {    

publicstatic 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;    

   }    

}  

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);  

/*

* 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.

*/

finalclass Utilities {  

privatestaticint sIconWidth = -1;  

privatestaticint sIconHeight = -1;  

privatestaticfinal Paint sPaint = new Paint();  

privatestaticfinal Rect sBounds = new Rect();  

privatestaticfinal Rect sOldBounds = new Rect();  

privatestatic 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);  

       } elseif (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) {  

finalfloat ratio = (float) iconWidth / iconHeight;  

if (iconWidth > iconHeight) {  

                   height = (int) (width / ratio);  

               } elseif (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());  

finalint x = (sIconWidth - width) / 2;  

finalint y = (sIconHeight - height) / 2;  

               icon.setBounds(x, y, x + width, y + height);  

               icon.draw(canvas);  

               icon.setBounds(sOldBounds);  

               icon = new FastBitmapDrawable(thumb);  

           } elseif (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());  

finalint x = (width - iconWidth) / 2;  

finalint 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;  

finalint bitmapWidth = bitmap.getWidth();  

finalint bitmapHeight = bitmap.getHeight();  

if (width > 0 && height > 0) {  

if (width < bitmapWidth || height < bitmapHeight) {  

finalfloat ratio = (float) bitmapWidth / bitmapHeight;  

if (bitmapWidth > bitmapHeight) {  

                   height = (int) (width / ratio);  

               } elseif (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;  

           } elseif (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类实现镜像方法

publicvoid drawRegion(Image p_w_picpath_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;  

}elseif((anchor&BOTTOM) != 0){  

y_dest -= height;  

}  

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

x_dest -= width;  

}elseif((anchor&HCENTER) != 0){  

x_dest -= width/2;  

}  

Bitmap newMap = Bitmap.createBitmap(p_w_picpath_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;  

   }  

//通过传入位图,新的宽.高比进行位图的缩放操作

publicstatic 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

returnnew BitmapDrawable(resizedBitmap);  

   }  

1.图片加载方法，方便用户加载图片  

/***

* 加载本地图片

* @param context：主运行函数实例

* @param bitAdress：图片地址，一般指向R下的drawable目录

* @return

*/

publicfinal 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

* ：第几行

*/

publicfinalvoid 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 bgp_w_picpath

* ：源图片资源

* @param newWidth

* ：缩放后宽度

* @param newHeight

* ：缩放后高度

* @return

*/

public Bitmap zoomImage(Bitmap bgp_w_picpath, int newWidth, int newHeight) {  

// 获取这个图片的宽和高

int width = bgp_w_picpath.getWidth();  

int height = bgp_w_picpath.getHeight();  

// 创建操作图片用的matrix对象

Matrix matrix = new Matrix();  

// 计算缩放率，新尺寸除原始尺寸

float scaleWidth = ((float) newWidth) / width;  

float scaleHeight = ((float) newHeight) / height;  

// 缩放图片动作

matrix.postScale(scaleWidth, scaleHeight);  

Bitmap bitmap = Bitmap.createBitmap(bgp_w_picpath, 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

* ：背景色

*/

publicvoid 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

*/

publicstatic Bitmap setAlpha(Bitmap sourceImg, int number) {  

int[] argb = newint[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

*

*/

publicclass ImageUtil {  

/**

* 放大缩小图片

*/

publicstatic 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

*/

publicstatic 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;  

}  

/**

* 获得圆角图片的方法

*/

publicstatic Bitmap getRoundedCornerBitmap(Bitmap bitmap, float roundPx) {  

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

  Canvas canvas = new Canvas(output);  

finalint 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;  

}  

/**

* 获得带倒影的图片方法

*/

publicstatic Bitmap createReflectionImageWithOrigin(Bitmap bitmap) {  

finalint 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;  

}  

}  

privatebyte[] 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 {  

returnnull;  

           }  

     }  

/**

    * 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 )  

       {  

returnnull;  

       }  

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

  */

privatestatic 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

staticbyte[] streamToBytes(InputStream is) {  

     ByteArrayOutputStream os = new ByteArrayOutputStream(1024);  

byte[] buffer = newbyte[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());  

returnnull;  

       }  

       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对象

    */

privatevoid writeMP3ToSDcard(String fileName, Context context) {  

byte[] buffer = newbyte[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);  

privatevoid

_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));    

}    

@Overrideprotectedvoid

onDraw(Canvas canvas)    

{    

super.onDraw(canvas);    

int nX = 0;    

int nY = 20;    

 _DrawNormalImg(canvas, nX, nY);    

 _DrawMirror(canvas, nX, nY);    

}      

privatevoid

_DrawNormalImg(Canvas canvas, int nX, int nY)    

{    

 canvas.save(Canvas.MATRIX_SAVE_FLAG);    

 canvas.translate(nX, nY);        

 m_dw.draw(canvas);    

 canvas.restore();    

}    

privatevoid

_DrawMirror(Canvas canvas, int nX, int nY)    

{    

int nW = m_dw.getIntrinsicWidth();    

int nH = m_dw.getIntrinsicHeight();    

///  

//draw mirror p_w_picpath  

 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();    

}