程序员自我救赎

/**
* Created by limxing on 16/1/7.
*/
public class LoadView extends ImageView {
private float degrees = 0f;
private Matrix max;
private int width;
private int height;
private Bitmap bitmap;

public LoadView(Context context) {
super(context);
init();
}

public LoadView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}

public LoadView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init();
}

Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
degrees += 30f;
max.setRotate(degrees, width, height);
setImageMatrix(max);
if(degrees==360){
degrees=0;
}
}
};

private void init() {
setScaleType(ScaleType.MATRIX);
bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.loading);
setImageBitmap(bitmap);
max = new Matrix();

width = bitmap.getWidth() / 2;
height = bitmap.getHeight() / 2;
Timer time=new Timer();
time.schedule(new TimerTask() {
@Override
public void run() {
handler.sendEmptyMessage(0);
}
},0,80);
}
}

public class BitmapHelper {

/**
* get the orientation of the bitmap {@link ExifInterface}
*
* @param path
* @return
*/
public static int getDegress(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;
}

/**
* rotate the bitmap
*
* @param bitmap
* @param degress
* @return
*/
public static Bitmap rotateBitmap(Bitmap bitmap, int degress) {
if (bitmap != null) {
Matrix m = new Matrix();
m.postRotate(degress);
bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), m, true);
return bitmap;
}
return bitmap;
}

/**
* caculate the bitmap sampleSize
*
* @param
* @return
*/
public static int caculateInSampleSize(Options options, int rqsW, int rqsH) {
int height = options.outHeight;
int width = options.outWidth;
//主要修改这里，让最宽的对应设定的宽，高同理
if (width > height) {
int temp = width;
width = height;
height = temp;
}
if (rqsW > rqsH) {
int rqsT = rqsH;
rqsH = rqsW;
rqsW = rqsT;
}

int inSampleSize = 1;
if (rqsW == 0 || rqsH == 0) return 1;
if (height > rqsH || width > rqsW) {
int heightRatio = Math.round((float) height / (float) rqsH);
int widthRatio = Math.round((float) width / (float) rqsW);
inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
}
return inSampleSize;
}
/**
* 根据需要压缩到某尺寸压缩指定路径的图片，并得到图片对象
*
* @param path
* @param rqsW
* @param rqsH
* @return
*/
public static Bitmap compressBitmap(String path, int rqsW, int rqsH) {
Options options = getBitmapOptions(path);
options.inSampleSize = caculateInSampleSize(options, rqsW, rqsH);
return BitmapFactory.decodeFile(path, options);
}

/**
* 压缩指定路径图片，并将其保存在缓存目录中，通过isDelSrc判定是否删除源文件，并获取到缓存后的图片路径
*
* @param context
* @param srcPath
* @param rqsW
* @param rqsH
* @param isDelSrc
* @return
*/
public static String compressBitmap(Context context, String srcPath, int rqsW, int rqsH, boolean isDelSrc) {
int degree = getDegress(srcPath);
Bitmap bitmap = compressBitmap(srcPath, rqsW, rqsH);//根据长宽以及图片的长宽得到缩放图片
File srcFile = new File(srcPath);
String desPath = getImageCacheDir(context) + srcFile.getName();
try {
if (degree != 0) bitmap = rotateBitmap(bitmap, degree);
File file = new File(desPath);
FileOutputStream fos = new FileOutputStream(file);
bitmap.compress(CompressFormat.JPEG, 80, fos);//80是图片质量
fos.close();
if (isDelSrc) srcFile.deleteOnExit();

} catch (Exception e) {
}

bitmap.recycle();
System.gc();

return desPath;
}

/**
* 压缩某个输入流中的图片，可以解决网络输入流压缩问题，并得到图片对象
*
* @return Bitmap {@link Bitmap}
*/
public static Bitmap compressBitmap(InputStream is, int reqsW, int reqsH) {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ReadableByteChannel channel = Channels.newChannel(is);
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (channel.read(buffer) != -1) {
buffer.flip();
while (buffer.hasRemaining()) baos.write(buffer.get());
buffer.clear();
}
byte[] bts = baos.toByteArray();
Bitmap bitmap = compressBitmap(bts, reqsW, reqsH);
is.close();
channel.close();
baos.close();
return bitmap;
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
return null;
}
}

/**
* 压缩指定byte[]图片，并得到压缩后的图像
*
* @param bts
* @param reqsW
* @param reqsH
* @return
*/
public static Bitmap compressBitmap(byte[] bts, int reqsW, int reqsH) {
Options options = new Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeByteArray(bts, 0, bts.length, options);
options.inSampleSize = caculateInSampleSize(options, reqsW, reqsH);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeByteArray(bts, 0, bts.length, options);
｝

/**
* 压缩已存在的图片对象，并返回压缩后的图片
*
* @param bitmap
* @param reqsW
* @param reqsH
* @return
*/
public static Bitmap compressBitmap(Bitmap bitmap, int reqsW, int reqsH) {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bitmap.compress(CompressFormat.PNG, 100, baos);
byte[] bts = baos.toByteArray();
Bitmap res = compressBitmap(bts, reqsW, reqsH);
baos.close();
return res;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return bitmap;
}
}

/**
* 压缩资源图片，并返回图片对象
*
* @param res   {@link Resources}
* @param resID
* @param reqsW
* @param reqsH
* @return
*/
public static Bitmap compressBitmap(Resources res, int resID, int reqsW, int reqsH) {
Options options = new Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeResource(res, resID, options);
options.inSampleSize = caculateInSampleSize(options, reqsW, reqsH);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeResource(res, resID, options);
}
/**
* 得到指定路径图片的options
*
* @param srcPath
* @return Options {@link Options}
*/
public static Options getBitmapOptions(String srcPath) {
Options options = new Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(srcPath, options);
options.inJustDecodeBounds = false;
return options;
}

/**
* 获取图片缓存路径
*
* @param context
* @return
*/
private static String getImageCacheDir(Context context) {
String dir = FileUtils.getCacheDir() + "Image" + File.separator;
File file = new File(dir);
if (!file.exists()) file.mkdirs();
return dir;
}
}

public class NativeUtil {
private static int DEFAULT_QUALITY = 95;

public static void compressBitmap(Bitmap bit, String fileName,
boolean optimize) {
compressBitmap(bit, DEFAULT_QUALITY, fileName, optimize);

}

public static void compressBitmap(Bitmap bit, int quality, String fileName,
boolean optimize) {
Log.d("native", "compress of native");
if (bit.getConfig() != Config.ARGB_8888) {
Bitmap result = Bitmap.createBitmap(bit.getWidth(), bit.getHeight(),
Config.ARGB_8888);
Canvas canvas = new Canvas(result);
Rect rect = new Rect(0, 0, bit.getWidth(), bit.getHeight());
canvas.drawBitmap(bit, null, rect, null);
saveBitmap(result, quality, fileName, optimize);
result.recycle();
} else {
saveBitmap(bit, quality, fileName, optimize);
}

}

private static void saveBitmap(Bitmap bit, int quality, String fileName,
boolean optimize) {
compressBitmap(bit, bit.getWidth(), bit.getHeight(), quality,
fileName.getBytes(), optimize);

}

private static native String compressBitmap(Bitmap bit, int w, int h,
int quality, byte[] fileNameBytes, boolean optimize);

static {
System.loadLibrary("jpegbither");
System.loadLibrary("bitherjni");

}

}

<?xml version="1.0" encoding="UTF-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android" >

<!-- 设置背景色（白色） -->
<item android:id="@android:id/background">
<shape>
<corners android:radius="5dip" />

<gradient
android:endColor="#ffffff"
android:startColor="#ffffff" />
</shape>
</item>

<!-- 设置进度条颜色（蓝色） -->
<item android:id="@android:id/progress">
<clip>
<shape>
<corners android:radius="5dip" />

<gradient
android:endColor="#5d9eff"
android:startColor="#5d9eff" />
</shape>
</clip>
</item>

</layer-list>

<ProgressBar
android:id="@+id/download_item_size_pro"
style="?android:attr/progressBarStyleHorizontal"
android:layout_width="match_parent"
android:layout_height="3dp"
android:max="100"
android:progress="0"
android:progressDrawable="@drawable/bacprogress" />

public class Singleton {
    private volatile static Singleton singleton;
        private Singleton(){};
        public static Singleton getSingleton(){
            if(singleton==null) {
                synchronized (Singleton.class) {
                if (singleton == null) {
                singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}