content: /*
   *   Copyright (C)  2016 android@19code.com
   *
   *   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.rsen.github.common;
  
  import android.content.Context;
  import android.graphics.Bitmap;
  import android.graphics.BitmapFactory;
  import android.graphics.Canvas;
  import android.graphics.Matrix;
  import android.graphics.Paint;
  import android.graphics.PorterDuff;
  import android.graphics.PorterDuffXfermode;
  import android.graphics.Rect;
  import android.graphics.RectF;
  import android.media.ExifInterface;
  import android.net.Uri;
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.OutputStream;
  
  /**
   * Create by h4de5ing 2016/5/21 021
   * https://github.com/sharinghuang/ASRabbit
   * unchecked
   */
  public class ImageUtils {
  
      public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
          final int height = options.outHeight;
          final int width = options.outWidth;
          int inSampleSize = 1;
          if (height > reqHeight || width > reqWidth) {
              final int halfHeight = height / 2;
              final int halfWidth = width / 2;
              while ((halfHeight / inSampleSize) > reqHeight && (halfWidth / inSampleSize) > reqWidth) {
                  inSampleSize *= 2;
              }
          }
          return inSampleSize;
      }
  
      public static int getPictureDegree(String imagePath) {
          int i = 0;
          try {
              ExifInterface localExifInterface = new ExifInterface(imagePath);
              int j = localExifInterface.getAttributeInt("Orientation", 1);
              switch (j) {
                  case 6:
                      i = 90;
                      break;
                  case 3:
                      i = 180;
                      break;
                  case 8:
                      i = 270;
                  case 4:
                  case 5:
                  case 7:
                  default:
                      break;
              }
          } catch (IOException localIOException) {
              localIOException.printStackTrace();
          }
          return i;
      }
  
      public static Bitmap rotaingImageView(int paramInt, Bitmap paramBitmap) {
          Matrix localMatrix = new Matrix();
          localMatrix.postRotate(paramInt);
          return Bitmap.createBitmap(paramBitmap, 0, 0, paramBitmap.getWidth(), paramBitmap.getHeight(), localMatrix, true);
      }
  
      public static Bitmap decodeScaleImage(String imagePath, int outWidth, int outHeight) {
          BitmapFactory.Options localOptions = new BitmapFactory.Options();
          localOptions.inJustDecodeBounds = true;
          BitmapFactory.decodeFile(imagePath, localOptions);
          int i = calculateInSampleSize(localOptions, outWidth, outHeight);
          localOptions.inSampleSize = i;
          localOptions.inJustDecodeBounds = false;
          Bitmap localBitmap1 = BitmapFactory.decodeFile(imagePath, localOptions);
          int j = getPictureDegree(imagePath);
          Bitmap localBitmap2 = null;
          if ((localBitmap1 != null) && (j != 0)) {
              localBitmap2 = rotaingImageView(j, localBitmap1);
              localBitmap1.recycle();
              localBitmap1 = null;
              return localBitmap2;
          }
          return localBitmap1;
      }
  
      public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, float roundPx) {
          if (bitmap == null) {
              return null;
          }
          Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.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(PorterDuff.Mode.SRC_IN));
          canvas.drawBitmap(bitmap, rect, rect, paint);
          return output;
      }
  
      public static Bitmap decodeUriAsBitmap(Context mContext, Uri uri) {
          Bitmap bitmap;
          try {
              bitmap = BitmapFactory.decodeStream(mContext.getContentResolver().openInputStream(uri));
          } catch (FileNotFoundException e) {
              return null;
          }
          return bitmap;
      }
  
      public static boolean bitmap2File(Bitmap bitmap, File imageFile) {
          OutputStream os;
          try {
              os = new FileOutputStream(imageFile);
              boolean isOK = bitmap.compress(Bitmap.CompressFormat.JPEG, 100, os);
              os.flush();
              os.close();
              return isOK;
          } catch (Exception e) {
              e.printStackTrace();
              return false;
          }
      }
  
      public static Bitmap compressImage(Bitmap image) {
          ByteArrayOutputStream baos = new ByteArrayOutputStream();
          image.compress(Bitmap.CompressFormat.JPEG, 100, baos);
          int options = 100;
          while (baos.toByteArray().length / 1024 > 100) {
              options -= 10;
              if (options > 0) {
                  baos.reset();
                  image.compress(Bitmap.CompressFormat.JPEG, options, baos);
              }
          }
          ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());
          return BitmapFactory.decodeStream(isBm, null, null);
      }
  
      public static Bitmap compressFixBitmap(Bitmap bitMap, int outWidth, int outHeight) {
          int width = bitMap.getWidth();
          int height = bitMap.getHeight();
          float scaleWidth = ((float) outWidth) / width;
          float scaleHeight = ((float) outHeight) / height;
          Matrix matrix = new Matrix();
          matrix.postScale(scaleWidth, scaleHeight);
          return Bitmap.createBitmap(bitMap, 0, 0, width, height, matrix, true);
      }
  }
  