工具类--PicUtil 图片转换计算大小

public class PicUtil {
   private static final String TAG = "PicUtil";

   /**
    * 根据一个网络连接(URL)获取bitmapDrawable图像
    * 
    * @param imageUri
    * @return
    */
   public static BitmapDrawable getfriendicon(URL imageUri) {

      BitmapDrawable icon = null;
      try {
         HttpURLConnection hp = (HttpURLConnection) imageUri
               .openConnection();
         icon = new BitmapDrawable(hp.getInputStream());// 将输入流转换成bitmap
         hp.disconnect();// 关闭连接
      } catch (Exception e) {
      }
      return icon;
   }

   /**
    * 根据一个网络连接(String)获取bitmapDrawable图像
    * 
    * @param imageUri
    * @return
    */
   public static BitmapDrawable getcontentPic(String imageUri) {
      URL imgUrl = null;
      try {
         imgUrl = new URL(imageUri);
      } catch (MalformedURLException e1) {
         e1.printStackTrace();
      }
      BitmapDrawable icon = null;
      try {
         HttpURLConnection hp = (HttpURLConnection) imgUrl.openConnection();
         icon = new BitmapDrawable(hp.getInputStream());// 将输入流转换成bitmap
         hp.disconnect();// 关闭连接
      } catch (Exception e) {
      }
      return icon;
   }

   /**
    * 根据一个网络连接(URL)获取bitmap图像
    * 
    * @param imageUri
    * @return
    */
   public static Bitmap getusericon(URL imageUri) {
      // 显示网络上的图片
      URL myFileUrl = imageUri;
      Bitmap bitmap = null;
      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();
      }
      return bitmap;
   }

   /**
    * 根据一个网络连接(String)获取bitmap图像
    * 
    * @param imageUri
    * @return
    * @throws MalformedURLException
    */
   public static Bitmap getbitmap(String imageUri) {
      // 显示网络上的图片
      Bitmap bitmap = null;
      try {
         URL myFileUrl = new URL(imageUri);
         HttpURLConnection conn = (HttpURLConnection) myFileUrl
               .openConnection();
         conn.setDoInput(true);
         conn.connect();
         InputStream is = conn.getInputStream();
         bitmap = BitmapFactory.decodeStream(is);
         is.close();

         L.i(TAG, "image download finished." + imageUri);
      } catch (IOException e) {
         e.printStackTrace();
         return null;
      }
      return bitmap;
   }

   /**
    * 下载图片 同时写到本地SD卡中
    * 
    * @param context
    * @param imageUri
    * @return
    * @throws MalformedURLException
    */
   public static Bitmap getbitmapAndwrite(String imageUri, String filePath) {
      Bitmap bitmap = null;
      try {
         // 显示网络上的图片
         URL myFileUrl = new URL(imageUri);
         HttpURLConnection conn = (HttpURLConnection) myFileUrl
               .openConnection();
         conn.setDoInput(true);
         conn.connect();

         InputStream is = conn.getInputStream();
         File cacheFile = new File(filePath);
         BufferedOutputStream bos = null;
         bos = new BufferedOutputStream(new FileOutputStream(cacheFile));
         L.i(TAG, "write file to " + cacheFile.getCanonicalPath());

         byte[] buf = new byte[1024];
         int len = 0;
         // 将网络上的图片存储到本地
         while ((len = is.read(buf)) > 0) {
            bos.write(buf, 0, len);
         }

         is.close();
         bos.close();

         // 从本地加载图片
         bitmap = BitmapFactory.decodeFile(cacheFile.getCanonicalPath());
         // String name = MD5Util.MD5(imageUri);

      } catch (IOException e) {
         L.e("图片读取错误");
         // e.printStackTrace();
      } catch (Exception e) {
         // TODO: handle exception
         e.printStackTrace();
      }
      return bitmap;
   }

   public static boolean downpic(String picName, Bitmap bitmap) {
      boolean nowbol = false;
      try {
         File saveFile = new File("/mnt/sdcard/download/weibopic/" + picName
               + ".png");
         if (!saveFile.exists()) {
            saveFile.createNewFile();
         }
         FileOutputStream saveFileOutputStream;
         saveFileOutputStream = new FileOutputStream(saveFile);
         nowbol = bitmap.compress(Bitmap.CompressFormat.PNG, 100,
               saveFileOutputStream);
         saveFileOutputStream.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      } catch (Exception e) {
         e.printStackTrace();
      }
      return nowbol;
   }

   public static void writeTofiles(Context context, Bitmap bitmap,
         String filename) {
      BufferedOutputStream outputStream = null;
      try {
         outputStream = new BufferedOutputStream(context.openFileOutput(
               filename, Context.MODE_PRIVATE));
         bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      }
   }

   /**
    * 复制单个文件
    * 
    * @param oldPath
    *            String 原文件路径 如：c:/fqf.txt
    * @param newPath
    *            String 复制后路径 如：f:/fqf.txt
    * @return boolean
    */
   public static boolean copyFile(String oldPath, String newPath) {
      boolean isok = true;
      try {
         int bytesum = 0;
         int byteread = 0;
         File oldfile = new File(oldPath);
         if (oldfile.exists()) { // 文件存在时
            InputStream inStream = new FileInputStream(oldPath); // 读入原文件
            FileOutputStream fs = new FileOutputStream(newPath);
            byte[] buffer = new byte[1024];
            int length;
            while ((byteread = inStream.read(buffer)) != -1) {
               bytesum += byteread; // 字节数 文件大小
               // System.out.println(bytesum);
               fs.write(buffer, 0, byteread);
            }
            fs.flush();
            fs.close();
            inStream.close();
         } else {
            isok = false;
         }
      } catch (Exception e) {
         // System.out.println("复制单个文件操作出错");
         // e.printStackTrace();
         isok = false;
      }
      return isok;

   }

   /**
    * 将文件写入缓存系统中
    * 
    * @param filename
    * @param is
    * @return
    */
   public static String writefile(Context context, String filename,
         InputStream is) {
      BufferedInputStream inputStream = null;
      BufferedOutputStream outputStream = null;
      try {
         inputStream = new BufferedInputStream(is);
         outputStream = new BufferedOutputStream(context.openFileOutput(
               filename, Context.MODE_PRIVATE));
         byte[] buffer = new byte[1024];
         int length;
         while ((length = inputStream.read(buffer)) != -1) {
            outputStream.write(buffer, 0, length);
         }
      } catch (Exception e) {
      } finally {
         if (inputStream != null) {
            try {
               inputStream.close();
            } catch (IOException e) {
               e.printStackTrace();
            }
         }
         if (outputStream != null) {
            try {
               outputStream.flush();
               outputStream.close();
            } catch (IOException e) {
               e.printStackTrace();
            }
         }
      }
      return context.getFilesDir() + "/" + filename + ".jpg";
   }

   // 放大缩小图片
   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) {
      if (bitmap == null) {
         return null;
      }

      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.SRC_IN));
      // Draw a rectangle using the paint with our linear gradient
      canvas.drawRect(0, height, width, bitmapWithReflection.getHeight()
            + reflectionGap, paint);

      return bitmapWithReflection;
   }

   /**
    * 将drawable资源文件下的指定文件存储的sd卡中
    * 
    * @param context
    * @param drawableId
    *            资源文件对应的id
    * @param filePath
    *            存储到sd卡的路径+图片文件名称(含后缀名)
    */
   public static void copyImage2SDCard(Context context, Integer drawableId,
         String filePath) {

      try {
         InputStream is = context.getResources().openRawResource(drawableId);
         File cacheFile = new File(filePath);
         BufferedOutputStream bos = null;
         bos = new BufferedOutputStream(new FileOutputStream(cacheFile));
         byte[] buf = new byte[1024];
         int len = 0;
         while ((len = is.read(buf)) > 0) {
            bos.write(buf, 0, len);
         }

         is.close();
         bos.close();

      } catch (IOException e) {
         L.e("图片读取错误");
      } catch (Exception e) {
         e.printStackTrace();
      }
   }

   public static Bitmap getSmallBitmap(String filePath) {

      final BitmapFactory.Options options = new BitmapFactory.Options();
      options.inJustDecodeBounds = true;
      BitmapFactory.decodeFile(filePath, options);

      // Calculate inSampleSize
      options.inSampleSize = calculateInSampleSize(options, 480, 800);

      // Decode bitmap with inSampleSize set
      options.inJustDecodeBounds = false;

      Bitmap bm = BitmapFactory.decodeFile(filePath, options);
      if (bm == null) {
         return null;
      }
      int degree = readPictureDegree(filePath);
      bm = rotateBitmap(bm, degree);
      ByteArrayOutputStream baos = null;
      try {
         baos = new ByteArrayOutputStream();
         bm.compress(Bitmap.CompressFormat.JPEG, 30, baos);

      } finally {
         try {
            if (baos != null)
               baos.close();
         } catch (IOException e) {
            e.printStackTrace();
         }
      }
      return bm;

   }

   private static int calculateInSampleSize(BitmapFactory.Options options,
         int reqWidth, int reqHeight) {
      // Raw height and width of image
      final int height = options.outHeight;
      final int width = options.outWidth;
      int inSampleSize = 1;

      if (height > reqHeight || width > reqWidth) {

         // Calculate ratios of height and width to requested height and
         // width
         final int heightRatio = Math.round((float) height
               / (float) reqHeight);
         final int widthRatio = Math.round((float) width / (float) reqWidth);

         // Choose the smallest ratio as inSampleSize value, this will
         // guarantee
         // a final image with both dimensions larger than or equal to the
         // requested height and width.
         inSampleSize = heightRatio < widthRatio ? widthRatio : heightRatio;
      }

      return inSampleSize;
   }

   private static int readPictureDegree(String path) {
      int degree = 0;
      try {
         ExifInterface exifInterface = new ExifInterface(path);
         int orientation = exifInterface.getAttributeInt(
               ExifInterface.TAG_ORIENTATION,
               ExifInterface.ORIENTATION_NORMAL);
         switch (orientation) {
         case ExifInterface.ORIENTATION_ROTATE_90:
            degree = 90;
            break;
         case ExifInterface.ORIENTATION_ROTATE_180:
            degree = 180;
            break;
         case ExifInterface.ORIENTATION_ROTATE_270:
            degree = 270;
            break;
         }
      } catch (IOException e) {
         e.printStackTrace();
      }
      return degree;
   }

   private static Bitmap rotateBitmap(Bitmap bitmap, int rotate) {
      if (bitmap == null)
         return null;

      int w = bitmap.getWidth();
      int h = bitmap.getHeight();

      // Setting post rotate to 90
      Matrix mtx = new Matrix();
      mtx.postRotate(rotate);
      return Bitmap.createBitmap(bitmap, 0, 0, w, h, mtx, true);
   }
}