一、CloseUtils
public class CloseUtils {
private CloseUtils() {
throw new UnsupportedOperationException("u can't instantiate me...");
}
/**
* Close the io stream.
*
* @param closeables The closeables.
*/
public static void closeIO(final Closeable... closeables) {
if (closeables == null) return;
for (Closeable closeable : closeables) {
if (closeable != null) {
try {
closeable.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* Close the io stream quietly.
*
* @param closeables The closeables.
*/
public static void closeIOQuietly(final Closeable... closeables) {
if (closeables == null) return;
for (Closeable closeable : closeables) {
if (closeable != null) {
try {
closeable.close();
} catch (IOException ignored) {
}
}
}
}
}
二、ConvertUtils
public final class ConvertUtils {
private ConvertUtils() {
throw new UnsupportedOperationException("u can't instantiate me...");
}
private static final char hexDigits[] =
{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
/**
* Bytes to bits.
*
* @param bytes The bytes.
* @return bits
*/
public static String bytes2Bits(final byte[] bytes) {
if (bytes == null || bytes.length == 0) return "";
StringBuilder sb = new StringBuilder();
for (byte aByte : bytes) {
for (int j = 7; j >= 0; --j) {
sb.append(((aByte >> j) & 0x01) == 0 ? '0' : '1');
}
}
return sb.toString();
}
/**
* Bits to bytes.
*
* @param bits The bits.
* @return bytes
*/
public static byte[] bits2Bytes(String bits) {
int lenMod = bits.length() % 8;
int byteLen = bits.length() / 8;
// add "0" until length to 8 times
if (lenMod != 0) {
for (int i = lenMod; i < 8; i++) {
bits = "0" + bits;
}
byteLen++;
}
byte[] bytes = new byte[byteLen];
for (int i = 0; i < byteLen; ++i) {
for (int j = 0; j < 8; ++j) {
bytes[i] <<= 1;
bytes[i] |= bits.charAt(i * 8 + j) - '0';
}
}
return bytes;
}
/**
* Bytes to chars.
*
* @param bytes The bytes.
* @return chars
*/
public static char[] bytes2Chars(final byte[] bytes) {
if (bytes == null) return null;
int len = bytes.length;
if (len <= 0) return null;
char[] chars = new char[len];
for (int i = 0; i < len; i++) {
chars[i] = (char) (bytes[i] & 0xff);
}
return chars;
}
/**
* Chars to bytes.
*
* @param chars The chars.
* @return bytes
*/
public static byte[] chars2Bytes(final char[] chars) {
if (chars == null || chars.length <= 0) return null;
int len = chars.length;
byte[] bytes = new byte[len];
for (int i = 0; i < len; i++) {
bytes[i] = (byte) (chars[i]);
}
return bytes;
}
/**
* Bytes to hex string.
* <p>e.g. bytes2HexString(new byte[] { 0, (byte) 0xa8 }) returns "00A8"</p>
*
* @param bytes The bytes.
* @return hex string
*/
public static String bytes2HexString(final byte[] bytes) {
if (bytes == null) return "";
int len = bytes.length;
if (len <= 0) return "";
char[] ret = new char[len << 1];
for (int i = 0, j = 0; i < len; i++) {
ret[j++] = hexDigits[bytes[i] >> 4 & 0x0f];
ret[j++] = hexDigits[bytes[i] & 0x0f];
}
return new String(ret);
}
/**
* Hex string to bytes.
* <p>e.g. hexString2Bytes("00A8") returns { 0, (byte) 0xA8 }</p>
*
* @param hexString The hex string.
* @return the bytes
*/
public static byte[] hexString2Bytes(String hexString) {
if (isSpace(hexString)) return null;
int len = hexString.length();
if (len % 2 != 0) {
hexString = "0" + hexString;
len = len + 1;
}
char[] hexBytes = hexString.toUpperCase().toCharArray();
byte[] ret = new byte[len >> 1];
for (int i = 0; i < len; i += 2) {
ret[i >> 1] = (byte) (hex2Int(hexBytes[i]) << 4 | hex2Int(hexBytes[i + 1]));
}
return ret;
}
private static int hex2Int(final char hexChar) {
if (hexChar >= '0' && hexChar <= '9') {
return hexChar - '0';
} else if (hexChar >= 'A' && hexChar <= 'F') {
return hexChar - 'A' + 10;
} else {
throw new IllegalArgumentException();
}
}
/**
* Size of memory in unit to size of byte.
*
* @param memorySize Size of memory.
* @param unit The unit of memory size.
* <ul>
* <li>{@link MemoryConstants#BYTE}</li>
* <li>{@link MemoryConstants#KB}</li>
* <li>{@link MemoryConstants#MB}</li>
* <li>{@link MemoryConstants#GB}</li>
* </ul>
* @return size of byte
*/
public static long memorySize2Byte(final long memorySize,
@MemoryConstants.Unit final int unit) {
if (memorySize < 0) return -1;
return memorySize * unit;
}
/**
* Size of byte to size of memory in unit.
*
* @param byteSize Size of byte.
* @param unit The unit of memory size.
* <ul>
* <li>{@link MemoryConstants#BYTE}</li>
* <li>{@link MemoryConstants#KB}</li>
* <li>{@link MemoryConstants#MB}</li>
* <li>{@link MemoryConstants#GB}</li>
* </ul>
* @return size of memory in unit
*/
public static double byte2MemorySize(final long byteSize,
@MemoryConstants.Unit final int unit) {
if (byteSize < 0) return -1;
return (double) byteSize / unit;
}
/**
* Size of byte to fit size of memory.
* <p>to three decimal places</p>
*
* @param byteSize Size of byte.
* @return fit size of memory
*/
@SuppressLint("DefaultLocale")
public static String byte2FitMemorySize(final long byteSize) {
if (byteSize < 0) {
return "shouldn't be less than zero!";
} else if (byteSize < MemoryConstants.KB) {
return String.format("%.3fB", (double) byteSize);
} else if (byteSize < MemoryConstants.MB) {
return String.format("%.3fKB", (double) byteSize / MemoryConstants.KB);
} else if (byteSize < MemoryConstants.GB) {
return String.format("%.3fMB", (double) byteSize / MemoryConstants.MB);
} else {
return String.format("%.3fGB", (double) byteSize / MemoryConstants.GB);
}
}
/**
* Time span in unit to milliseconds.
*
* @param timeSpan The time span.
* @param unit The unit of time span.
* <ul>
* <li>{@link TimeConstants#MSEC}</li>
* <li>{@link TimeConstants#SEC }</li>
* <li>{@link TimeConstants#MIN }</li>
* <li>{@link TimeConstants#HOUR}</li>
* <li>{@link TimeConstants#DAY }</li>
* </ul>
* @return milliseconds
*/
public static long timeSpan2Millis(final long timeSpan, @TimeConstants.Unit final int unit) {
return timeSpan * unit;
}
/**
* Milliseconds to time span in unit.
*
* @param millis The milliseconds.
* @param unit The unit of time span.
* <ul>
* <li>{@link TimeConstants#MSEC}</li>
* <li>{@link TimeConstants#SEC }</li>
* <li>{@link TimeConstants#MIN }</li>
* <li>{@link TimeConstants#HOUR}</li>
* <li>{@link TimeConstants#DAY }</li>
* </ul>
* @return time span in unit
*/
public static long millis2TimeSpan(final long millis, @TimeConstants.Unit final int unit) {
return millis / unit;
}
/**
* Milliseconds to fit time span.
*
* @param millis The milliseconds.
* <p>millis <= 0, return null</p>
* @param precision The precision of time span.
* <ul>
* <li>precision = 0, return null</li>
* <li>precision = 1, return 天</li>
* <li>precision = 2, return 天, 小时</li>
* <li>precision = 3, return 天, 小时, 分钟</li>
* <li>precision = 4, return 天, 小时, 分钟, 秒</li>
* <li>precision >= 5，return 天, 小时, 分钟, 秒, 毫秒</li>
* </ul>
* @return fit time span
*/
@SuppressLint("DefaultLocale")
public static String millis2FitTimeSpan(long millis, int precision) {
if (millis <= 0 || precision <= 0) return null;
StringBuilder sb = new StringBuilder();
String[] units = {"天", "小时", "分钟", "秒", "毫秒"};
int[] unitLen = {86400000, 3600000, 60000, 1000, 1};
precision = Math.min(precision, 5);
for (int i = 0; i < precision; i++) {
if (millis >= unitLen[i]) {
long mode = millis / unitLen[i];
millis -= mode * unitLen[i];
sb.append(mode).append(units[i]);
}
}
return sb.toString();
}
/**
* Input stream to output stream.
*
* @param is The input stream.
* @return output stream
*/
public static ByteArrayOutputStream input2OutputStream(final InputStream is) {
if (is == null) return null;
try {
ByteArrayOutputStream os = new ByteArrayOutputStream();
byte[] b = new byte[MemoryConstants.KB];
int len;
while ((len = is.read(b, 0, MemoryConstants.KB)) != -1) {
os.write(b, 0, len);
}
return os;
} catch (IOException e) {
e.printStackTrace();
return null;
} finally {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* Output stream to input stream.
*
* @param out The output stream.
* @return input stream
*/
public ByteArrayInputStream output2InputStream(final OutputStream out) {
if (out == null) return null;
return new ByteArrayInputStream(((ByteArrayOutputStream) out).toByteArray());
}
/**
* Input stream to bytes.
*
* @param is The input stream.
* @return bytes
*/
public static byte[] inputStream2Bytes(final InputStream is) {
if (is == null) return null;
ByteArrayOutputStream baos = input2OutputStream(is);
if(baos != null){
return baos.toByteArray();
}
return null;
}
/**
* Bytes to input stream.
*
* @param bytes The bytes.
* @return input stream
*/
public static InputStream bytes2InputStream(final byte[] bytes) {
if (bytes == null || bytes.length <= 0) return null;
return new ByteArrayInputStream(bytes);
}
/**
* Output stream to bytes.
*
* @param out The output stream.
* @return bytes
*/
public static byte[] outputStream2Bytes(final OutputStream out) {
if (out == null) return null;
return ((ByteArrayOutputStream) out).toByteArray();
}
/**
* Bytes to output stream.
*
* @param bytes The bytes.
* @return output stream
*/
public static OutputStream bytes2OutputStream(final byte[] bytes) {
if (bytes == null || bytes.length <= 0) return null;
ByteArrayOutputStream os = null;
try {
os = new ByteArrayOutputStream();
os.write(bytes);
return os;
} catch (IOException e) {
e.printStackTrace();
return null;
} finally {
try {
if (os != null) {
os.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* Input stream to string.
*
* @param is The input stream.
* @param charsetName The name of charset.
* @return string
*/
public static String inputStream2String(final InputStream is, final String charsetName) {
if (is == null || isSpace(charsetName)) return "";
try {
return new String(inputStream2Bytes(is), charsetName);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
return "";
}
}
/**
* String to input stream.
*
* @param string The string.
* @param charsetName The name of charset.
* @return input stream
*/
public static InputStream string2InputStream(final String string, final String charsetName) {
if (string == null || isSpace(charsetName)) return null;
try {
return new ByteArrayInputStream(string.getBytes(charsetName));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
return null;
}
}
/**
* Output stream to string.
*
* @param out The output stream.
* @param charsetName The name of charset.
* @return string
*/
public static String outputStream2String(final OutputStream out, final String charsetName) {
if (out == null || isSpace(charsetName)) return "";
try {
return new String(outputStream2Bytes(out), charsetName);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
return "";
}
}
/**
* String to output stream.
*
* @param string The string.
* @param charsetName The name of charset.
* @return output stream
*/
public static OutputStream string2OutputStream(final String string, final String charsetName) {
if (string == null || isSpace(charsetName)) return null;
try {
return bytes2OutputStream(string.getBytes(charsetName));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
return null;
}
}
/**
* Bitmap to bytes.
*
* @param bitmap The bitmap.
* @param format The format of bitmap.
* @return bytes
*/
public static byte[] bitmap2Bytes(final Bitmap bitmap, final Bitmap.CompressFormat format) {
if (bitmap == null) return null;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bitmap.compress(format, 100, baos);
return baos.toByteArray();
}
/**
* Bytes to bitmap.
*
* @param bytes The bytes.
* @return bitmap
*/
public static Bitmap bytes2Bitmap(final byte[] bytes) {
return (bytes == null || bytes.length == 0)
? null
: BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
}
/**
* Drawable to bitmap.
*
* @param drawable The drawable.
* @return bitmap
*/
public static Bitmap drawable2Bitmap(final Drawable drawable) {
if (drawable instanceof BitmapDrawable) {
BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
if (bitmapDrawable.getBitmap() != null) {
return bitmapDrawable.getBitmap();
}
}
Bitmap bitmap;
if (drawable.getIntrinsicWidth() <= 0 || drawable.getIntrinsicHeight() <= 0) {
bitmap = Bitmap.createBitmap(1, 1,
drawable.getOpacity() != PixelFormat.OPAQUE
? Bitmap.Config.ARGB_8888
: Bitmap.Config.RGB_565);
} else {
bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(),
drawable.getIntrinsicHeight(),
drawable.getOpacity() != PixelFormat.OPAQUE
? Bitmap.Config.ARGB_8888
: Bitmap.Config.RGB_565);
}
Canvas canvas = new Canvas(bitmap);
drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
drawable.draw(canvas);
return bitmap;
}
/**
* Bitmap to drawable.
*
* @param bitmap The bitmap.
* @return drawable
*/
public static Drawable bitmap2Drawable(final Bitmap bitmap) {
return bitmap == null ? null : new BitmapDrawable(SReminderApp.getInstance().getResources(), bitmap);
}
/**
* Drawable to bytes.
*
* @param drawable The drawable.
* @param format The format of bitmap.
* @return bytes
*/
public static byte[] drawable2Bytes(final Drawable drawable,
final Bitmap.CompressFormat format) {
return drawable == null ? null : bitmap2Bytes(drawable2Bitmap(drawable), format);
}
/**
* Bytes to drawable.
*
* @param bytes The bytes.
* @return drawable
*/
public static Drawable bytes2Drawable(final byte[] bytes) {
return bytes == null ? null : bitmap2Drawable(bytes2Bitmap(bytes));
}
/**
* View to bitmap.
*
* @param view The view.
* @return bitmap
*/
public static Bitmap view2Bitmap(final View view) {
if (view == null) return null;
Bitmap ret =
Bitmap.createBitmap(view.getWidth(), view.getHeight(), Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(ret);
Drawable bgDrawable = view.getBackground();
if (bgDrawable != null) {
bgDrawable.draw(canvas);
} else {
canvas.drawColor(Color.WHITE);
}
view.draw(canvas);
return ret;
}
/**
* Value of dp to value of px.
*
* @param dpValue The value of dp.
* @return value of px
*/
public static int dp2px(final float dpValue) {
final float scale = Resources.getSystem().getDisplayMetrics().density;
return (int) (dpValue * scale + 0.5f);
}
/**
* Value of px to value of dp.
*
* @param pxValue The value of px.
* @return value of dp
*/
public static int px2dp(final float pxValue) {
final float scale = Resources.getSystem().getDisplayMetrics().density;
return (int) (pxValue / scale + 0.5f);
}
/**
* Value of sp to value of px.
*
* @param spValue The value of sp.
* @return value of px
*/
public static int sp2px(final float spValue) {
final float fontScale = Resources.getSystem().getDisplayMetrics().scaledDensity;
return (int) (spValue * fontScale + 0.5f);
}
/**
* Value of px to value of sp.
*
* @param pxValue The value of px.
* @return value of sp
*/
public static int px2sp(final float pxValue) {
final float fontScale = Resources.getSystem().getDisplayMetrics().scaledDensity;
return (int) (pxValue / fontScale + 0.5f);
}
///////////////////////////////////////////////////////////////////////////
// other utils methods
///////////////////////////////////////////////////////////////////////////
private static boolean isSpace(final String s) {
if (s == null) return true;
for (int i = 0, len = s.length(); i < len; ++i) {
if (!Character.isWhitespace(s.charAt(i))) {
return false;
}
}
return true;
}
}
三、DeviceUtils
public class DeviceUtils {
private DeviceUtils() {
throw new UnsupportedOperationException("u can't instantiate me...");
}
/**
* Return whether device is rooted.
*
* @return {@code true}: yes<br>{@code false}: no
*/
public static boolean isDeviceRooted() {
String su = "su";
String[] locations = {"/system/bin/", "/system/xbin/", "/sbin/", "/system/sd/xbin/",
"/system/bin/failsafe/", "/data/local/xbin/", "/data/local/bin/", "/data/local/",
"/system/sbin/", "/usr/bin/", "/vendor/bin/"};
for (String location : locations) {
if (new File(location + su).exists()) {
return true;
}
}
return false;
}
/**
* Return whether ADB is enabled.
*
* @return {@code true}: yes<br>{@code false}: no
*/
@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR1)
public static boolean isAdbEnabled() {
return Settings.Secure.getInt(
SReminderApp.getInstance().getContentResolver(),
Settings.Global.ADB_ENABLED, 0
) > 0;
}
/**
* Return the version name of device's system.
*
* @return the version name of device's system
*/
public static String getSDKVersionName() {
return android.os.Build.VERSION.RELEASE;
}
/**
* Return version code of device's system.
*
* @return version code of device's system
*/
public static int getSDKVersionCode() {
return android.os.Build.VERSION.SDK_INT;
}
/**
* Return the android id of device.
*
* @return the android id of device
*/
@SuppressLint("HardwareIds")
public static String getAndroidID() {
String id = Settings.Secure.getString(
SReminderApp.getInstance().getContentResolver(),
Settings.Secure.ANDROID_ID
);
return id == null ? "" : id;
}
/**
* Return the manufacturer of the product/hardware.
* <p>e.g. Xiaomi</p>
*
* @return the manufacturer of the product/hardware
*/
public static String getManufacturer() {
return Build.MANUFACTURER;
}
/**
* Return the model of device.
* <p>e.g. MI2SC</p>
*
* @return the model of device
*/
public static String getModel() {
String model = Build.MODEL;
if (model != null) {
model = model.trim().replaceAll("\\s*", "");
} else {
model = "";
}
return model;
}
/**
* Return an ordered list of ABIs supported by this device. The most preferred ABI is the first
* element in the list.
*
* @return an ordered list of ABIs supported by this device
*/
public static String[] getABIs() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
return Build.SUPPORTED_ABIS;
} else {
if (!TextUtils.isEmpty(Build.CPU_ABI2)) {
return new String[]{Build.CPU_ABI, Build.CPU_ABI2};
}
return new String[]{Build.CPU_ABI};
}
}
public static boolean isSepLiteAvailable() {
boolean result = false;
PackageManager pm = SReminderApp.getInstance().getPackageManager();
if (pm != null && pm.hasSystemFeature("com.samsung.feature.samsung_experience_mobile_lite")) {
result = true;
}
return result;
}
public static void forceWebViewDarkMode(WebSettings settings) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
boolean enable = false;
int uiMode = SReminderApp.getInstance().getResources().getConfiguration().uiMode;
int currentMode = uiMode & Configuration.UI_MODE_NIGHT_MASK;
if (currentMode == Configuration.UI_MODE_NIGHT_YES) {
enable = true;
}
settings.setForceDark(enable ? WebSettings.FORCE_DARK_ON : WebSettings.FORCE_DARK_OFF);
}
}
public static void forceWebViewDarkMode(WebSettings settings,boolean enable) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
settings.setForceDark(enable ? WebSettings.FORCE_DARK_ON : WebSettings.FORCE_DARK_OFF);
}
}
/**
* Note: Only support Q OS now (2020/01/02)
* @return whether the current mode is dark mode
*/
public static boolean isInDarkMode() {
/**
* Only support dark mode from Q
*/
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
return false;
}
int uiMode = SReminderApp.getInstance().getResources().getConfiguration().uiMode;
int currentMode = uiMode & Configuration.UI_MODE_NIGHT_MASK;
if (currentMode == Configuration.UI_MODE_NIGHT_YES) {
return true;
} else {
return false;
}
}
}
四、ImageUtils
public final class ImageUtils {
private ImageUtils() {
throw new UnsupportedOperationException("u can't instantiate me...");
}
/**
* Bitmap to bytes.
*
* @param bitmap The bitmap.
* @param format The format of bitmap.
* @return bytes
*/
public static byte[] bitmap2Bytes(final Bitmap bitmap, final CompressFormat format) {
if (bitmap == null) return null;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bitmap.compress(format, 100, baos);
return baos.toByteArray();
}
/**
* Bytes to bitmap.
*
* @param bytes The bytes.
* @return bitmap
*/
public static Bitmap bytes2Bitmap(final byte[] bytes) {
return (bytes == null || bytes.length == 0)
? null
: BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
}
/**
* Drawable to bitmap.
*
* @param drawable The drawable.
* @return bitmap
*/
public static Bitmap drawable2Bitmap(final Drawable drawable) {
if (drawable instanceof BitmapDrawable) {
BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
if (bitmapDrawable.getBitmap() != null) {
return bitmapDrawable.getBitmap();
}
}
Bitmap bitmap;
if (drawable.getIntrinsicWidth() <= 0 || drawable.getIntrinsicHeight() <= 0) {
bitmap = Bitmap.createBitmap(1, 1,
drawable.getOpacity() != PixelFormat.OPAQUE
? Bitmap.Config.ARGB_8888
: Bitmap.Config.RGB_565);
} else {
bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(),
drawable.getIntrinsicHeight(),
drawable.getOpacity() != PixelFormat.OPAQUE
? Bitmap.Config.ARGB_8888
: Bitmap.Config.RGB_565);
}
Canvas canvas = new Canvas(bitmap);
drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
drawable.draw(canvas);
return bitmap;
}
/**
* Bitmap to drawable.
*
* @param bitmap The bitmap.
* @return drawable
*/
public static Drawable bitmap2Drawable(final Bitmap bitmap) {
return bitmap == null ? null : new BitmapDrawable(SReminderApp.getInstance().getResources(), bitmap);
}
/**
* Drawable to bytes.
*
* @param drawable The drawable.
* @param format The format of bitmap.
* @return bytes
*/
public static byte[] drawable2Bytes(final Drawable drawable, final CompressFormat format) {
return drawable == null ? null : bitmap2Bytes(drawable2Bitmap(drawable), format);
}
/**
* Bytes to drawable.
*
* @param bytes The bytes.
* @return drawable
*/
public static Drawable bytes2Drawable(final byte[] bytes) {
return bitmap2Drawable(bytes2Bitmap(bytes));
}
/**
* View to bitmap.
*
* @param view The view.
* @return bitmap
*/
public static Bitmap view2Bitmap(final View view) {
if (view == null) return null;
Bitmap ret = Bitmap.createBitmap(view.getWidth(),
view.getHeight(),
Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(ret);
Drawable bgDrawable = view.getBackground();
if (bgDrawable != null) {
bgDrawable.draw(canvas);
} else {
canvas.drawColor(Color.WHITE);
}
view.draw(canvas);
return ret;
}
/**
* Return bitmap.
*
* @param file The file.
* @return bitmap
*/
public static Bitmap getBitmap(final File file) {
if (file == null) return null;
return BitmapFactory.decodeFile(file.getAbsolutePath());
}
/**
* Return bitmap.
*
* @param file The file.
* @param maxWidth The maximum width.
* @param maxHeight The maximum height.
* @return bitmap
*/
public static Bitmap getBitmap(final File file, final int maxWidth, final int maxHeight) {
if (file == null) return null;
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(file.getAbsolutePath(), options);
options.inSampleSize = calculateInSampleSize(options, maxWidth, maxHeight);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeFile(file.getAbsolutePath(), options);
}
/**
* Return bitmap.
*
* @param filePath The path of file.
* @return bitmap
*/
public static Bitmap getBitmap(final String filePath) {
if (isSpace(filePath)) return null;
return BitmapFactory.decodeFile(filePath);
}
/**
* Return bitmap.
*
* @param filePath The path of file.
* @param maxWidth The maximum width.
* @param maxHeight The maximum height.
* @return bitmap
*/
public static Bitmap getBitmap(final String filePath, final int maxWidth, final int maxHeight) {
if (isSpace(filePath)) return null;
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(filePath, options);
options.inSampleSize = calculateInSampleSize(options, maxWidth, maxHeight);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeFile(filePath, options);
}
/**
* Return bitmap.
*
* @param is The input stream.
* @return bitmap
*/
public static Bitmap getBitmap(final InputStream is) {
if (is == null) return null;
return BitmapFactory.decodeStream(is);
}
/**
* Return bitmap.
*
* @param is The input stream.
* @param maxWidth The maximum width.
* @param maxHeight The maximum height.
* @return bitmap
*/
public static Bitmap getBitmap(final InputStream is, final int maxWidth, final int maxHeight) {
if (is == null) return null;
byte[] bytes = input2Byte(is);
return getBitmap(bytes, 0, maxWidth, maxHeight);
}
/**
* Return bitmap.
*
* @param data The data.
* @param offset The offset.
* @return bitmap
*/
public static Bitmap getBitmap(final byte[] data, final int offset) {
if (data.length == 0) return null;
return BitmapFactory.decodeByteArray(data, offset, data.length);
}
/**
* Return bitmap.
*
* @param data The data.
* @param offset The offset.
* @param maxWidth The maximum width.
* @param maxHeight The maximum height.
* @return bitmap
*/
public static Bitmap getBitmap(final byte[] data,
final int offset,
final int maxWidth,
final int maxHeight) {
if (data.length == 0) return null;
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeByteArray(data, offset, data.length, options);
options.inSampleSize = calculateInSampleSize(options, maxWidth, maxHeight);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeByteArray(data, offset, data.length, options);
}
/**
* Return bitmap.
*
* @param resId The resource id.
* @return bitmap
*/
public static Bitmap getBitmap(@DrawableRes final int resId) {
Drawable drawable = ContextCompat.getDrawable(SReminderApp.getInstance(), resId);
Canvas canvas = new Canvas();
Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(),
drawable.getIntrinsicHeight(),
Bitmap.Config.ARGB_8888);
canvas.setBitmap(bitmap);
drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
drawable.draw(canvas);
return bitmap;
}
/**
* Return bitmap.
*
* @param resId The resource id.
* @param maxWidth The maximum width.
* @param maxHeight The maximum height.
* @return bitmap
*/
public static Bitmap getBitmap(@DrawableRes final int resId,
final int maxWidth,
final int maxHeight) {
BitmapFactory.Options options = new BitmapFactory.Options();
final Resources resources = SReminderApp.getInstance().getResources();
options.inJustDecodeBounds = true;
BitmapFactory.decodeResource(resources, resId, options);
options.inSampleSize = calculateInSampleSize(options, maxWidth, maxHeight);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeResource(resources, resId, options);
}
/**
* Return bitmap.
*
* @param fd The file descriptor.
* @return bitmap
*/
public static Bitmap getBitmap(final FileDescriptor fd) {
if (fd == null) return null;
return BitmapFactory.decodeFileDescriptor(fd);
}
/**
* Return bitmap.
*
* @param fd The file descriptor
* @param maxWidth The maximum width.
* @param maxHeight The maximum height.
* @return bitmap
*/
public static Bitmap getBitmap(final FileDescriptor fd,
final int maxWidth,
final int maxHeight) {
if (fd == null) return null;
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFileDescriptor(fd, null, options);
options.inSampleSize = calculateInSampleSize(options, maxWidth, maxHeight);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeFileDescriptor(fd, null, options);
}
/**
* Return the bitmap with the specified color.
*
* @param src The source of bitmap.
* @param color The color.
* @return the bitmap with the specified color
*/
public static Bitmap drawColor(@NonNull final Bitmap src, @ColorInt final int color) {
return drawColor(src, color, false);
}
/**
* Return the bitmap with the specified color.
*
* @param src The source of bitmap.
* @param color The color.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the bitmap with the specified color
*/
public static Bitmap drawColor(@NonNull final Bitmap src,
@ColorInt final int color,
final boolean recycle) {
if (isEmptyBitmap(src)) return null;
Bitmap ret = recycle ? src : src.copy(src.getConfig(), true);
Canvas canvas = new Canvas(ret);
canvas.drawColor(color, PorterDuff.Mode.DARKEN);
return ret;
}
/**
* Return the scaled bitmap.
*
* @param src The source of bitmap.
* @param newWidth The new width.
* @param newHeight The new height.
* @return the scaled bitmap
*/
public static Bitmap scale(final Bitmap src, final int newWidth, final int newHeight) {
return scale(src, newWidth, newHeight, false);
}
/**
* Return the scaled bitmap.
*
* @param src The source of bitmap.
* @param newWidth The new width.
* @param newHeight The new height.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the scaled bitmap
*/
public static Bitmap scale(final Bitmap src,
final int newWidth,
final int newHeight,
final boolean recycle) {
if (isEmptyBitmap(src)) return null;
Bitmap ret = Bitmap.createScaledBitmap(src, newWidth, newHeight, true);
if (recycle && !src.isRecycled() && ret != src) src.recycle();
return ret;
}
/**
* Return the scaled bitmap
*
* @param src The source of bitmap.
* @param scaleWidth The scale of width.
* @param scaleHeight The scale of height.
* @return the scaled bitmap
*/
public static Bitmap scale(final Bitmap src, final float scaleWidth, final float scaleHeight) {
return scale(src, scaleWidth, scaleHeight, false);
}
/**
* Return the scaled bitmap
*
* @param src The source of bitmap.
* @param scaleWidth The scale of width.
* @param scaleHeight The scale of height.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the scaled bitmap
*/
public static Bitmap scale(final Bitmap src,
final float scaleWidth,
final float scaleHeight,
final boolean recycle) {
if (isEmptyBitmap(src)) return null;
Matrix matrix = new Matrix();
matrix.setScale(scaleWidth, scaleHeight);
Bitmap ret = Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, true);
if (recycle && !src.isRecycled() && ret != src) src.recycle();
return ret;
}
/**
* Return the clipped bitmap.
*
* @param src The source of bitmap.
* @param x The x coordinate of the first pixel.
* @param y The y coordinate of the first pixel.
* @param width The width.
* @param height The height.
* @return the clipped bitmap
*/
public static Bitmap clip(final Bitmap src,
final int x,
final int y,
final int width,
final int height) {
return clip(src, x, y, width, height, false);
}
/**
* Return the clipped bitmap.
*
* @param src The source of bitmap.
* @param x The x coordinate of the first pixel.
* @param y The y coordinate of the first pixel.
* @param width The width.
* @param height The height.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the clipped bitmap
*/
public static Bitmap clip(final Bitmap src,
final int x,
final int y,
final int width,
final int height,
final boolean recycle) {
if (isEmptyBitmap(src)) return null;
Bitmap ret = Bitmap.createBitmap(src, x, y, width, height);
if (recycle && !src.isRecycled() && ret != src) src.recycle();
return ret;
}
/**
* Return the skewed bitmap.
*
* @param src The source of bitmap.
* @param kx The skew factor of x.
* @param ky The skew factor of y.
* @return the skewed bitmap
*/
public static Bitmap skew(final Bitmap src, final float kx, final float ky) {
return skew(src, kx, ky, 0, 0, false);
}
/**
* Return the skewed bitmap.
*
* @param src The source of bitmap.
* @param kx The skew factor of x.
* @param ky The skew factor of y.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the skewed bitmap
*/
public static Bitmap skew(final Bitmap src,
final float kx,
final float ky,
final boolean recycle) {
return skew(src, kx, ky, 0, 0, recycle);
}
/**
* Return the skewed bitmap.
*
* @param src The source of bitmap.
* @param kx The skew factor of x.
* @param ky The skew factor of y.
* @param px The x coordinate of the pivot point.
* @param py The y coordinate of the pivot point.
* @return the skewed bitmap
*/
public static Bitmap skew(final Bitmap src,
final float kx,
final float ky,
final float px,
final float py) {
return skew(src, kx, ky, px, py, false);
}
/**
* Return the skewed bitmap.
*
* @param src The source of bitmap.
* @param kx The skew factor of x.
* @param ky The skew factor of y.
* @param px The x coordinate of the pivot point.
* @param py The y coordinate of the pivot point.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the skewed bitmap
*/
public static Bitmap skew(final Bitmap src,
final float kx,
final float ky,
final float px,
final float py,
final boolean recycle) {
if (isEmptyBitmap(src)) return null;
Matrix matrix = new Matrix();
matrix.setSkew(kx, ky, px, py);
Bitmap ret = Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, true);
if (recycle && !src.isRecycled() && ret != src) src.recycle();
return ret;
}
/**
* Return the rotated bitmap.
*
* @param src The source of bitmap.
* @param degrees The number of degrees.
* @param px The x coordinate of the pivot point.
* @param py The y coordinate of the pivot point.
* @return the rotated bitmap
*/
public static Bitmap rotate(final Bitmap src,
final int degrees,
final float px,
final float py) {
return rotate(src, degrees, px, py, false);
}
/**
* Return the rotated bitmap.
*
* @param src The source of bitmap.
* @param degrees The number of degrees.
* @param px The x coordinate of the pivot point.
* @param py The y coordinate of the pivot point.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the rotated bitmap
*/
public static Bitmap rotate(final Bitmap src,
final int degrees,
final float px,
final float py,
final boolean recycle) {
if (isEmptyBitmap(src)) return null;
if (degrees == 0) return src;
Matrix matrix = new Matrix();
matrix.setRotate(degrees, px, py);
Bitmap ret = Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, true);
if (recycle && !src.isRecycled() && ret != src) src.recycle();
return ret;
}
/**
* Return the rotated degree.
*
* @param filePath The path of file.
* @return the rotated degree
*/
public static int getRotateDegree(final String filePath) {
try {
ExifInterface exifInterface = new ExifInterface(filePath);
int orientation = exifInterface.getAttributeInt(
ExifInterface.TAG_ORIENTATION,
ExifInterface.ORIENTATION_NORMAL
);
switch (orientation) {
case ExifInterface.ORIENTATION_ROTATE_90:
return 90;
case ExifInterface.ORIENTATION_ROTATE_180:
return 180;
case ExifInterface.ORIENTATION_ROTATE_270:
return 270;
default:
return 0;
}
} catch (IOException e) {
e.printStackTrace();
return -1;
}
}
/**
* Return the round bitmap.
*
* @param src The source of bitmap.
* @return the round bitmap
*/
public static Bitmap toRound(final Bitmap src) {
return toRound(src, 0, 0, false);
}
/**
* Return the round bitmap.
*
* @param src The source of bitmap.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the round bitmap
*/
public static Bitmap toRound(final Bitmap src, final boolean recycle) {
return toRound(src, 0, 0, recycle);
}
/**
* Return the round bitmap.
*
* @param src The source of bitmap.
* @param borderSize The size of border.
* @param borderColor The color of border.
* @return the round bitmap
*/
public static Bitmap toRound(final Bitmap src,
@IntRange(from = 0) int borderSize,
@ColorInt int borderColor) {
return toRound(src, borderSize, borderColor, false);
}
/**
* Return the round bitmap.
*
* @param src The source of bitmap.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @param borderSize The size of border.
* @param borderColor The color of border.
* @return the round bitmap
*/
public static Bitmap toRound(final Bitmap src,
@IntRange(from = 0) int borderSize,
@ColorInt int borderColor,
final boolean recycle) {
if (isEmptyBitmap(src)) return null;
int width = src.getWidth();
int height = src.getHeight();
int size = Math.min(width, height);
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
Bitmap ret = Bitmap.createBitmap(width, height, src.getConfig());
float center = size / 2f;
RectF rectF = new RectF(0, 0, width, height);
rectF.inset((width - size) / 2f, (height - size) / 2f);
Matrix matrix = new Matrix();
matrix.setTranslate(rectF.left, rectF.top);
if (width != height) {
matrix.preScale((float) size / width, (float) size / height);
}
BitmapShader shader = new BitmapShader(src, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
shader.setLocalMatrix(matrix);
paint.setShader(shader);
Canvas canvas = new Canvas(ret);
canvas.drawRoundRect(rectF, center, center, paint);
if (borderSize > 0) {
paint.setShader(null);
paint.setColor(borderColor);
paint.setStyle(Paint.Style.STROKE);
paint.setStrokeWidth(borderSize);
float radius = center - borderSize / 2f;
canvas.drawCircle(width / 2f, height / 2f, radius, paint);
}
if (recycle && !src.isRecycled() && ret != src) src.recycle();
return ret;
}
/**
* Return the round corner bitmap.
*
* @param src The source of bitmap.
* @param radius The radius of corner.
* @return the round corner bitmap
*/
public static Bitmap toRoundCorner(final Bitmap src, final float radius) {
return toRoundCorner(src, radius, 0, 0, false);
}
/**
* Return the round corner bitmap.
*
* @param src The source of bitmap.
* @param radius The radius of corner.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the round corner bitmap
*/
public static Bitmap toRoundCorner(final Bitmap src,
final float radius,
final boolean recycle) {
return toRoundCorner(src, radius, 0, 0, recycle);
}
/**
* Return the round corner bitmap.
*
* @param src The source of bitmap.
* @param radius The radius of corner.
* @param borderSize The size of border.
* @param borderColor The color of border.
* @return the round corner bitmap
*/
public static Bitmap toRoundCorner(final Bitmap src,
final float radius,
@IntRange(from = 0) int borderSize,
@ColorInt int borderColor) {
return toRoundCorner(src, radius, borderSize, borderColor, false);
}
/**
* Return the round corner bitmap.
*
* @param src The source of bitmap.
* @param radius The radius of corner.
* @param borderSize The size of border.
* @param borderColor The color of border.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the round corner bitmap
*/
public static Bitmap toRoundCorner(final Bitmap src,
final float radius,
@IntRange(from = 0) int borderSize,
@ColorInt int borderColor,
final boolean recycle) {
if (isEmptyBitmap(src)) return null;
int width = src.getWidth();
int height = src.getHeight();
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
Bitmap ret = Bitmap.createBitmap(width, height, src.getConfig());
BitmapShader shader = new BitmapShader(src, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
paint.setShader(shader);
Canvas canvas = new Canvas(ret);
RectF rectF = new RectF(0, 0, width, height);
float halfBorderSize = borderSize / 2f;
rectF.inset(halfBorderSize, halfBorderSize);
canvas.drawRoundRect(rectF, radius, radius, paint);
if (borderSize > 0) {
paint.setShader(null);
paint.setColor(borderColor);
paint.setStyle(Paint.Style.STROKE);
paint.setStrokeWidth(borderSize);
paint.setStrokeCap(Paint.Cap.ROUND);
canvas.drawRoundRect(rectF, radius, radius, paint);
}
if (recycle && !src.isRecycled() && ret != src) src.recycle();
return ret;
}
/**
* Return the round corner bitmap with border.
*
* @param src The source of bitmap.
* @param borderSize The size of border.
* @param color The color of border.
* @param cornerRadius The radius of corner.
* @return the round corner bitmap with border
*/
public static Bitmap addCornerBorder(final Bitmap src,
@IntRange(from = 1) final int borderSize,
@ColorInt final int color,
@FloatRange(from = 0) final float cornerRadius) {
return addBorder(src, borderSize, color, false, cornerRadius, false);
}
/**
* Return the round corner bitmap with border.
*
* @param src The source of bitmap.
* @param borderSize The size of border.
* @param color The color of border.
* @param cornerRadius The radius of corner.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the round corner bitmap with border
*/
public static Bitmap addCornerBorder(final Bitmap src,
@IntRange(from = 1) final int borderSize,
@ColorInt final int color,
@FloatRange(from = 0) final float cornerRadius,
final boolean recycle) {
return addBorder(src, borderSize, color, false, cornerRadius, recycle);
}
/**
* Return the round bitmap with border.
*
* @param src The source of bitmap.
* @param borderSize The size of border.
* @param color The color of border.
* @return the round bitmap with border
*/
public static Bitmap addCircleBorder(final Bitmap src,
@IntRange(from = 1) final int borderSize,
@ColorInt final int color) {
return addBorder(src, borderSize, color, true, 0, false);
}
/**
* Return the round bitmap with border.
*
* @param src The source of bitmap.
* @param borderSize The size of border.
* @param color The color of border.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the round bitmap with border
*/
public static Bitmap addCircleBorder(final Bitmap src,
@IntRange(from = 1) final int borderSize,
@ColorInt final int color,
final boolean recycle) {
return addBorder(src, borderSize, color, true, 0, recycle);
}
/**
* Return the bitmap with border.
*
* @param src The source of bitmap.
* @param borderSize The size of border.
* @param color The color of border.
* @param isCircle True to draw circle, false to draw corner.
* @param cornerRadius The radius of corner.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the bitmap with border
*/
private static Bitmap addBorder(final Bitmap src,
@IntRange(from = 1) final int borderSize,
@ColorInt final int color,
final boolean isCircle,
final float cornerRadius,
final boolean recycle) {
if (isEmptyBitmap(src)) return null;
Bitmap ret = recycle ? src : src.copy(src.getConfig(), true);
int width = ret.getWidth();
int height = ret.getHeight();
Canvas canvas = new Canvas(ret);
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
paint.setColor(color);
paint.setStyle(Paint.Style.STROKE);
paint.setStrokeWidth(borderSize);
if (isCircle) {
float radius = Math.min(width, height) / 2f - borderSize / 2f;
canvas.drawCircle(width / 2f, height / 2f, radius, paint);
} else {
int halfBorderSize = borderSize >> 1;
RectF rectF = new RectF(halfBorderSize, halfBorderSize,
width - halfBorderSize, height - halfBorderSize);
canvas.drawRoundRect(rectF, cornerRadius, cornerRadius, paint);
}
return ret;
}
/**
* Return the bitmap with reflection.
*
* @param src The source of bitmap.
* @param reflectionHeight The height of reflection.
* @return the bitmap with reflection
*/
public static Bitmap addReflection(final Bitmap src, final int reflectionHeight) {
return addReflection(src, reflectionHeight, false);
}
/**
* Return the bitmap with reflection.
*
* @param src The source of bitmap.
* @param reflectionHeight The height of reflection.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the bitmap with reflection
*/
public static Bitmap addReflection(final Bitmap src,
final int reflectionHeight,
final boolean recycle) {
if (isEmptyBitmap(src)) return null;
final int REFLECTION_GAP = 0;
int srcWidth = src.getWidth();
int srcHeight = src.getHeight();
Matrix matrix = new Matrix();
matrix.preScale(1, -1);
Bitmap reflectionBitmap = Bitmap.createBitmap(src, 0, srcHeight - reflectionHeight,
srcWidth, reflectionHeight, matrix, false);
Bitmap ret = Bitmap.createBitmap(srcWidth, srcHeight + reflectionHeight, src.getConfig());
Canvas canvas = new Canvas(ret);
canvas.drawBitmap(src, 0, 0, null);
canvas.drawBitmap(reflectionBitmap, 0, srcHeight + REFLECTION_GAP, null);
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
LinearGradient shader = new LinearGradient(
0, srcHeight,
0, ret.getHeight() + REFLECTION_GAP,
0x70FFFFFF,
0x00FFFFFF,
Shader.TileMode.MIRROR);
paint.setShader(shader);
paint.setXfermode(new PorterDuffXfermode(android.graphics.PorterDuff.Mode.DST_IN));
canvas.drawRect(0, srcHeight + REFLECTION_GAP, srcWidth, ret.getHeight(), paint);
if (!reflectionBitmap.isRecycled()) reflectionBitmap.recycle();
if (recycle && !src.isRecycled() && ret != src) src.recycle();
return ret;
}
/**
* Return the bitmap with text watermarking.
*
* @param src The source of bitmap.
* @param content The content of text.
* @param textSize The size of text.
* @param color The color of text.
* @param x The x coordinate of the first pixel.
* @param y The y coordinate of the first pixel.
* @return the bitmap with text watermarking
*/
public static Bitmap addTextWatermark(final Bitmap src,
final String content,
final int textSize,
@ColorInt final int color,
final float x,
final float y) {
return addTextWatermark(src, content, textSize, color, x, y, false);
}
/**
* Return the bitmap with text watermarking.
*
* @param src The source of bitmap.
* @param content The content of text.
* @param textSize The size of text.
* @param color The color of text.
* @param x The x coordinate of the first pixel.
* @param y The y coordinate of the first pixel.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the bitmap with text watermarking
*/
public static Bitmap addTextWatermark(final Bitmap src,
final String content,
final float textSize,
@ColorInt final int color,
final float x,
final float y,
final boolean recycle) {
if (isEmptyBitmap(src) || content == null) return null;
Bitmap ret = src.copy(src.getConfig(), true);
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
Canvas canvas = new Canvas(ret);
paint.setColor(color);
paint.setTextSize(textSize);
Rect bounds = new Rect();
paint.getTextBounds(content, 0, content.length(), bounds);
canvas.drawText(content, x, y + textSize, paint);
if (recycle && !src.isRecycled() && ret != src) src.recycle();
return ret;
}
/**
* Return the bitmap with image watermarking.
*
* @param src The source of bitmap.
* @param watermark The image watermarking.
* @param x The x coordinate of the first pixel.
* @param y The y coordinate of the first pixel.
* @param alpha The alpha of watermark.
* @return the bitmap with image watermarking
*/
public static Bitmap addImageWatermark(final Bitmap src,
final Bitmap watermark,
final int x, final int y,
final int alpha) {
return addImageWatermark(src, watermark, x, y, alpha, false);
}
/**
* Return the bitmap with image watermarking.
*
* @param src The source of bitmap.
* @param watermark The image watermarking.
* @param x The x coordinate of the first pixel.
* @param y The y coordinate of the first pixel.
* @param alpha The alpha of watermark.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the bitmap with image watermarking
*/
public static Bitmap addImageWatermark(final Bitmap src,
final Bitmap watermark,
final int x,
final int y,
final int alpha,
final boolean recycle) {
if (isEmptyBitmap(src)) return null;
Bitmap ret = src.copy(src.getConfig(), true);
if (!isEmptyBitmap(watermark)) {
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
Canvas canvas = new Canvas(ret);
paint.setAlpha(alpha);
canvas.drawBitmap(watermark, x, y, paint);
}
if (recycle && !src.isRecycled() && ret != src) src.recycle();
return ret;
}
/**
* Return the alpha bitmap.
*
* @param src The source of bitmap.
* @return the alpha bitmap
*/
public static Bitmap toAlpha(final Bitmap src) {
return toAlpha(src, false);
}
/**
* Return the alpha bitmap.
*
* @param src The source of bitmap.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the alpha bitmap
*/
public static Bitmap toAlpha(final Bitmap src, final Boolean recycle) {
if (isEmptyBitmap(src)) return null;
Bitmap ret = src.extractAlpha();
if (recycle && !src.isRecycled() && ret != src) src.recycle();
return ret;
}
/**
* Return the gray bitmap.
*
* @param src The source of bitmap.
* @return the gray bitmap
*/
public static Bitmap toGray(final Bitmap src) {
return toGray(src, false);
}
/**
* Return the gray bitmap.
*
* @param src The source of bitmap.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the gray bitmap
*/
public static Bitmap toGray(final Bitmap src, final boolean recycle) {
if (isEmptyBitmap(src)) return null;
Bitmap ret = Bitmap.createBitmap(src.getWidth(), src.getHeight(), src.getConfig());
Canvas canvas = new Canvas(ret);
Paint paint = new Paint();
ColorMatrix colorMatrix = new ColorMatrix();
colorMatrix.setSaturation(0);
ColorMatrixColorFilter colorMatrixColorFilter = new ColorMatrixColorFilter(colorMatrix);
paint.setColorFilter(colorMatrixColorFilter);
canvas.drawBitmap(src, 0, 0, paint);
if (recycle && !src.isRecycled() && ret != src) src.recycle();
return ret;
}
/**
* Return the blur bitmap fast.
* <p>zoom out, blur, zoom in</p>
*
* @param src The source of bitmap.
* @param scale The scale(0...1).
* @param radius The radius(0...25).
* @return the blur bitmap
*/
public static Bitmap fastBlur(final Bitmap src,
@FloatRange(
from = 0, to = 1, fromInclusive = false
) final float scale,
@FloatRange(
from = 0, to = 25, fromInclusive = false
) final float radius) {
return fastBlur(src, scale, radius, false, false);
}
/**
* Return the blur bitmap fast.
* <p>zoom out, blur, zoom in</p>
*
* @param src The source of bitmap.
* @param scale The scale(0...1).
* @param radius The radius(0...25).
* @return the blur bitmap
*/
public static Bitmap fastBlur(final Bitmap src,
@FloatRange(
from = 0, to = 1, fromInclusive = false
) final float scale,
@FloatRange(
from = 0, to = 25, fromInclusive = false
) final float radius,
final boolean recycle) {
return fastBlur(src, scale, radius, recycle, false);
}
/**
* Return the blur bitmap fast.
* <p>zoom out, blur, zoom in</p>
*
* @param src The source of bitmap.
* @param scale The scale(0...1).
* @param radius The radius(0...25).
* @param recycle True to recycle the source of bitmap, false otherwise.
* @param isReturnScale True to return the scale blur bitmap, false otherwise.
* @return the blur bitmap
*/
public static Bitmap fastBlur(final Bitmap src,
@FloatRange(
from = 0, to = 1, fromInclusive = false
) final float scale,
@FloatRange(
from = 0, to = 25, fromInclusive = false
) final float radius,
final boolean recycle,
final boolean isReturnScale) {
if (isEmptyBitmap(src)) return null;
int width = src.getWidth();
int height = src.getHeight();
Matrix matrix = new Matrix();
matrix.setScale(scale, scale);
Bitmap scaleBitmap =
Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, true);
Paint paint = new Paint(Paint.FILTER_BITMAP_FLAG | Paint.ANTI_ALIAS_FLAG);
Canvas canvas = new Canvas();
PorterDuffColorFilter filter = new PorterDuffColorFilter(
Color.TRANSPARENT, PorterDuff.Mode.SRC_ATOP);
paint.setColorFilter(filter);
canvas.scale(scale, scale);
canvas.drawBitmap(scaleBitmap, 0, 0, paint);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
scaleBitmap = renderScriptBlur(scaleBitmap, radius, recycle);
} else {
scaleBitmap = stackBlur(scaleBitmap, (int) radius, recycle);
}
if (scale == 1 || isReturnScale) {
if (recycle && !src.isRecycled() && scaleBitmap != src) src.recycle();
return scaleBitmap;
}
Bitmap ret = Bitmap.createScaledBitmap(scaleBitmap, width, height, true);
if (!scaleBitmap.isRecycled()) scaleBitmap.recycle();
if (recycle && !src.isRecycled() && ret != src) src.recycle();
return ret;
}
/**
* Return the blur bitmap using render script.
*
* @param src The source of bitmap.
* @param radius The radius(0...25).
* @return the blur bitmap
*/
@RequiresApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
public static Bitmap renderScriptBlur(final Bitmap src,
@FloatRange(
from = 0, to = 25, fromInclusive = false
) final float radius) {
return renderScriptBlur(src, radius, false);
}
/**
* Return the blur bitmap using render script.
*
* @param src The source of bitmap.
* @param radius The radius(0...25).
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the blur bitmap
*/
@RequiresApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
public static Bitmap renderScriptBlur(final Bitmap src,
@FloatRange(
from = 0, to = 25, fromInclusive = false
) final float radius,
final boolean recycle) {
RenderScript rs = null;
Bitmap ret = recycle ? src : src.copy(src.getConfig(), true);
try {
rs = RenderScript.create(SReminderApp.getInstance());
rs.setMessageHandler(new RenderScript.RSMessageHandler());
Allocation input = Allocation.createFromBitmap(rs,
ret,
Allocation.MipmapControl.MIPMAP_NONE,
Allocation.USAGE_SCRIPT);
Allocation output = Allocation.createTyped(rs, input.getType());
ScriptIntrinsicBlur blurScript = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
blurScript.setInput(input);
blurScript.setRadius(radius);
blurScript.forEach(output);
output.copyTo(ret);
} finally {
if (rs != null) {
rs.destroy();
}
}
return ret;
}
/**
* Return the blur bitmap using stack.
*
* @param src The source of bitmap.
* @param radius The radius(0...25).
* @return the blur bitmap
*/
public static Bitmap stackBlur(final Bitmap src, final int radius) {
return stackBlur(src, radius, false);
}
/**
* Return the blur bitmap using stack.
*
* @param src The source of bitmap.
* @param radius The radius(0...25).
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the blur bitmap
*/
public static Bitmap stackBlur(final Bitmap src, int radius, final boolean recycle) {
Bitmap ret = recycle ? src : src.copy(src.getConfig(), true);
if (radius < 1) {
radius = 1;
}
int w = ret.getWidth();
int h = ret.getHeight();
int[] pix = new int[w * h];
ret.getPixels(pix, 0, w, 0, 0, w, h);
int wm = w - 1;
int hm = h - 1;
int wh = w * h;
int div = radius + radius + 1;
int r[] = new int[wh];
int g[] = new int[wh];
int b[] = new int[wh];
int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
int vmin[] = new int[Math.max(w, h)];
int divsum = (div + 1) >> 1;
divsum *= divsum;
int dv[] = new int[256 * divsum];
for (i = 0; i < 256 * divsum; i++) {
dv[i] = (i / divsum);
}
yw = yi = 0;
int[][] stack = new int[div][3];
int stackpointer;
int stackstart;
int[] sir;
int rbs;
int r1 = radius + 1;
int routsum, goutsum, boutsum;
int rinsum, ginsum, binsum;
for (y = 0; y < h; y++) {
rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
for (i = -radius; i <= radius; i++) {
p = pix[yi + Math.min(wm, Math.max(i, 0))];
sir = stack[i + radius];
sir[0] = (p & 0xff0000) >> 16;
sir[1] = (p & 0x00ff00) >> 8;
sir[2] = (p & 0x0000ff);
rbs = r1 - Math.abs(i);
rsum += sir[0] * rbs;
gsum += sir[1] * rbs;
bsum += sir[2] * rbs;
if (i > 0) {
rinsum += sir[0];
ginsum += sir[1];
binsum += sir[2];
} else {
routsum += sir[0];
goutsum += sir[1];
boutsum += sir[2];
}
}
stackpointer = radius;
for (x = 0; x < w; x++) {
r[yi] = dv[rsum];
g[yi] = dv[gsum];
b[yi] = dv[bsum];
rsum -= routsum;
gsum -= goutsum;
bsum -= boutsum;
stackstart = stackpointer - radius + div;
sir = stack[stackstart % div];
routsum -= sir[0];
goutsum -= sir[1];
boutsum -= sir[2];
if (y == 0) {
vmin[x] = Math.min(x + radius + 1, wm);
}
p = pix[yw + vmin[x]];
sir[0] = (p & 0xff0000) >> 16;
sir[1] = (p & 0x00ff00) >> 8;
sir[2] = (p & 0x0000ff);
rinsum += sir[0];
ginsum += sir[1];
binsum += sir[2];
rsum += rinsum;
gsum += ginsum;
bsum += binsum;
stackpointer = (stackpointer + 1) % div;
sir = stack[(stackpointer) % div];
routsum += sir[0];
goutsum += sir[1];
boutsum += sir[2];
rinsum -= sir[0];
ginsum -= sir[1];
binsum -= sir[2];
yi++;
}
yw += w;
}
for (x = 0; x < w; x++) {
rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
yp = -radius * w;
for (i = -radius; i <= radius; i++) {
yi = Math.max(0, yp) + x;
sir = stack[i + radius];
sir[0] = r[yi];
sir[1] = g[yi];
sir[2] = b[yi];
rbs = r1 - Math.abs(i);
rsum += r[yi] * rbs;
gsum += g[yi] * rbs;
bsum += b[yi] * rbs;
if (i > 0) {
rinsum += sir[0];
ginsum += sir[1];
binsum += sir[2];
} else {
routsum += sir[0];
goutsum += sir[1];
boutsum += sir[2];
}
if (i < hm) {
yp += w;
}
}
yi = x;
stackpointer = radius;
for (y = 0; y < h; y++) {
// Preserve alpha channel: ( 0xff000000 & pix[yi] )
pix[yi] = (0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) | dv[bsum];
rsum -= routsum;
gsum -= goutsum;
bsum -= boutsum;
stackstart = stackpointer - radius + div;
sir = stack[stackstart % div];
routsum -= sir[0];
goutsum -= sir[1];
boutsum -= sir[2];
if (x == 0) {
vmin[y] = Math.min(y + r1, hm) * w;
}
p = x + vmin[y];
sir[0] = r[p];
sir[1] = g[p];
sir[2] = b[p];
rinsum += sir[0];
ginsum += sir[1];
binsum += sir[2];
rsum += rinsum;
gsum += ginsum;
bsum += binsum;
stackpointer = (stackpointer + 1) % div;
sir = stack[stackpointer];
routsum += sir[0];
goutsum += sir[1];
boutsum += sir[2];
rinsum -= sir[0];
ginsum -= sir[1];
binsum -= sir[2];
yi += w;
}
}
ret.setPixels(pix, 0, w, 0, 0, w, h);
return ret;
}
/**
* Save the bitmap.
*
* @param src The source of bitmap.
* @param filePath The path of file.
* @param format The format of the image.
* @return {@code true}: success<br>{@code false}: fail
*/
public static boolean save(final Bitmap src,
final String filePath,
final CompressFormat format) {
return save(src, getFileByPath(filePath), format, false);
}
/**
* Save the bitmap.
*
* @param src The source of bitmap.
* @param file The file.
* @param format The format of the image.
* @return {@code true}: success<br>{@code false}: fail
*/
public static boolean save(final Bitmap src, final File file, final CompressFormat format) {
return save(src, file, format, false);
}
/**
* Save the bitmap.
*
* @param src The source of bitmap.
* @param filePath The path of file.
* @param format The format of the image.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return {@code true}: success<br>{@code false}: fail
*/
public static boolean save(final Bitmap src,
final String filePath,
final CompressFormat format,
final boolean recycle) {
return save(src, getFileByPath(filePath), format, recycle);
}
/**
* Save the bitmap.
*
* @param src The source of bitmap.
* @param file The file.
* @param format The format of the image.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return {@code true}: success<br>{@code false}: fail
*/
public static boolean save(final Bitmap src,
final File file,
final CompressFormat format,
final boolean recycle) {
if (isEmptyBitmap(src) || !createFileByDeleteOldFile(file)) return false;
OutputStream os = null;
boolean ret = false;
try {
os = new BufferedOutputStream(new FileOutputStream(file));
ret = src.compress(format, 100, os);
if (recycle && !src.isRecycled()) src.recycle();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (os != null) {
os.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return ret;
}
/**
* Return whether it is a image according to the file name.
*
* @param file The file.
* @return {@code true}: yes<br>{@code false}: no
*/
public static boolean isImage(final File file) {
if (file == null || !file.exists()) {
return false;
}
return isImage(file.getPath());
}
/**
* Return whether it is a image according to the file name.
*
* @param filePath The path of file.
* @return {@code true}: yes<br>{@code false}: no
*/
public static boolean isImage(final String filePath) {
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
try {
Bitmap bitmap = BitmapFactory.decodeFile(filePath, options);
return options.outWidth != -1 && options.outHeight != -1;
} catch (Exception e) {
return false;
}
}
/**
* Return the type of image.
*
* @param filePath The path of file.
* @return the type of image
*/
public static String getImageType(final String filePath) {
return getImageType(getFileByPath(filePath));
}
/**
* Return the type of image.
*
* @param file The file.
* @return the type of image
*/
public static String getImageType(final File file) {
if (file == null) return "";
InputStream is = null;
try {
is = new FileInputStream(file);
String type = getImageType(is);
if (type != null) {
return type;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (is != null) {
is.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return getFileExtension(file.getAbsolutePath()).toUpperCase();
}
private static String getFileExtension(final String filePath) {
if (isSpace(filePath)) return filePath;
int lastPoi = filePath.lastIndexOf('.');
int lastSep = filePath.lastIndexOf(File.separator);
if (lastPoi == -1 || lastSep >= lastPoi) return "";
return filePath.substring(lastPoi + 1);
}
private static String getImageType(final InputStream is) {
if (is == null) return null;
try {
byte[] bytes = new byte[8];
return is.read(bytes, 0, 8) != -1 ? getImageType(bytes) : null;
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
private static String getImageType(final byte[] bytes) {
if (isJPEG(bytes)) return "JPEG";
if (isGIF(bytes)) return "GIF";
if (isPNG(bytes)) return "PNG";
if (isBMP(bytes)) return "BMP";
return null;
}
private static boolean isJPEG(final byte[] b) {
return b.length >= 2
&& (b[0] == (byte) 0xFF) && (b[1] == (byte) 0xD8);
}
private static boolean isGIF(final byte[] b) {
return b.length >= 6
&& b[0] == 'G' && b[1] == 'I'
&& b[2] == 'F' && b[3] == '8'
&& (b[4] == '7' || b[4] == '9') && b[5] == 'a';
}
private static boolean isPNG(final byte[] b) {
return b.length >= 8
&& (b[0] == (byte) 137 && b[1] == (byte) 80
&& b[2] == (byte) 78 && b[3] == (byte) 71
&& b[4] == (byte) 13 && b[5] == (byte) 10
&& b[6] == (byte) 26 && b[7] == (byte) 10);
}
private static boolean isBMP(final byte[] b) {
return b.length >= 2
&& (b[0] == 0x42) && (b[1] == 0x4d);
}
private static boolean isEmptyBitmap(final Bitmap src) {
return src == null || src.getWidth() == 0 || src.getHeight() == 0;
}
///////////////////////////////////////////////////////////////////////////
// about compress
///////////////////////////////////////////////////////////////////////////
/**
* Return the compressed bitmap using scale.
*
* @param src The source of bitmap.
* @param newWidth The new width.
* @param newHeight The new height.
* @return the compressed bitmap
*/
public static Bitmap compressByScale(final Bitmap src,
final int newWidth,
final int newHeight) {
return scale(src, newWidth, newHeight, false);
}
/**
* Return the compressed bitmap using scale.
*
* @param src The source of bitmap.
* @param newWidth The new width.
* @param newHeight The new height.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the compressed bitmap
*/
public static Bitmap compressByScale(final Bitmap src,
final int newWidth,
final int newHeight,
final boolean recycle) {
return scale(src, newWidth, newHeight, recycle);
}
/**
* Return the compressed bitmap using scale.
*
* @param src The source of bitmap.
* @param scaleWidth The scale of width.
* @param scaleHeight The scale of height.
* @return the compressed bitmap
*/
public static Bitmap compressByScale(final Bitmap src,
final float scaleWidth,
final float scaleHeight) {
return scale(src, scaleWidth, scaleHeight, false);
}
/**
* Return the compressed bitmap using scale.
*
* @param src The source of bitmap.
* @param scaleWidth The scale of width.
* @param scaleHeight The scale of height.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return he compressed bitmap
*/
public static Bitmap compressByScale(final Bitmap src,
final float scaleWidth,
final float scaleHeight,
final boolean recycle) {
return scale(src, scaleWidth, scaleHeight, recycle);
}
/**
* Return the compressed bitmap using quality.
*
* @param src The source of bitmap.
* @param quality The quality.
* @return the compressed bitmap
*/
public static Bitmap compressByQuality(final Bitmap src,
@IntRange(from = 0, to = 100) final int quality) {
return compressByQuality(src, quality, false);
}
/**
* Return the compressed bitmap using quality.
*
* @param src The source of bitmap.
* @param quality The quality.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the compressed bitmap
*/
public static Bitmap compressByQuality(final Bitmap src,
@IntRange(from = 0, to = 100) final int quality,
final boolean recycle) {
if (isEmptyBitmap(src)) return null;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
src.compress(Bitmap.CompressFormat.JPEG, quality, baos);
byte[] bytes = baos.toByteArray();
if (recycle && !src.isRecycled()) src.recycle();
return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
}
/**
* Return the compressed bitmap using quality.
*
* @param src The source of bitmap.
* @param maxByteSize The maximum size of byte.
* @return the compressed bitmap
*/
public static Bitmap compressByQuality(final Bitmap src, final long maxByteSize) {
return compressByQuality(src, maxByteSize, false);
}
/**
* Return the compressed bitmap using quality.
*
* @param src The source of bitmap.
* @param maxByteSize The maximum size of byte.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the compressed bitmap
*/
public static Bitmap compressByQuality(final Bitmap src,
final long maxByteSize,
final boolean recycle) {
if (isEmptyBitmap(src) || maxByteSize <= 0) return null;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
src.compress(CompressFormat.JPEG, 100, baos);
byte[] bytes;
if (baos.size() <= maxByteSize) {
bytes = baos.toByteArray();
} else {
baos.reset();
src.compress(CompressFormat.JPEG, 0, baos);
if (baos.size() >= maxByteSize) {
bytes = baos.toByteArray();
} else {
// find the best quality using binary search
int st = 0;
int end = 100;
int mid = 0;
while (st < end) {
mid = (st + end) / 2;
baos.reset();
src.compress(CompressFormat.JPEG, mid, baos);
int len = baos.size();
if (len == maxByteSize) {
break;
} else if (len > maxByteSize) {
end = mid - 1;
} else {
st = mid + 1;
}
}
if (end == mid - 1) {
baos.reset();
src.compress(CompressFormat.JPEG, st, baos);
}
bytes = baos.toByteArray();
}
}
if (recycle && !src.isRecycled()) src.recycle();
return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
}
/**
* Return the compressed bitmap using sample size.
*
* @param src The source of bitmap.
* @param sampleSize The sample size.
* @return the compressed bitmap
*/
public static Bitmap compressBySampleSize(final Bitmap src, final int sampleSize) {
return compressBySampleSize(src, sampleSize, false);
}
/**
* Return the compressed bitmap using sample size.
*
* @param src The source of bitmap.
* @param sampleSize The sample size.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the compressed bitmap
*/
public static Bitmap compressBySampleSize(final Bitmap src,
final int sampleSize,
final boolean recycle) {
if (isEmptyBitmap(src)) return null;
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = sampleSize;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
src.compress(Bitmap.CompressFormat.JPEG, 100, baos);
byte[] bytes = baos.toByteArray();
if (recycle && !src.isRecycled()) src.recycle();
return BitmapFactory.decodeByteArray(bytes, 0, bytes.length, options);
}
/**
* Return the compressed bitmap using sample size.
*
* @param src The source of bitmap.
* @param maxWidth The maximum width.
* @param maxHeight The maximum height.
* @return the compressed bitmap
*/
public static Bitmap compressBySampleSize(final Bitmap src,
final int maxWidth,
final int maxHeight) {
return compressBySampleSize(src, maxWidth, maxHeight, false);
}
/**
* Return the compressed bitmap using sample size.
*
* @param src The source of bitmap.
* @param maxWidth The maximum width.
* @param maxHeight The maximum height.
* @param recycle True to recycle the source of bitmap, false otherwise.
* @return the compressed bitmap
*/
public static Bitmap compressBySampleSize(final Bitmap src,
final int maxWidth,
final int maxHeight,
final boolean recycle) {
if (isEmptyBitmap(src)) return null;
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
src.compress(Bitmap.CompressFormat.JPEG, 100, baos);
byte[] bytes = baos.toByteArray();
BitmapFactory.decodeByteArray(bytes, 0, bytes.length, options);
options.inSampleSize = calculateInSampleSize(options, maxWidth, maxHeight);
options.inJustDecodeBounds = false;
if (recycle && !src.isRecycled()) src.recycle();
return BitmapFactory.decodeByteArray(bytes, 0, bytes.length, options);
}
/**
* Return the size of bitmap.
*
* @param filePath The path of file.
* @return the size of bitmap
*/
public static int[] getSize(String filePath) {
return getSize(getFileByPath(filePath));
}
/**
* Return the size of bitmap.
*
* @param file The file.
* @return the size of bitmap
*/
public static int[] getSize(File file) {
if (file == null) return new int[]{0, 0};
BitmapFactory.Options opts = new BitmapFactory.Options();
opts.inJustDecodeBounds = true;
BitmapFactory.decodeFile(file.getAbsolutePath(), opts);
return new int[]{opts.outWidth, opts.outHeight};
}
/**
* Return the sample size.
*
* @param options The options.
* @param maxWidth The maximum width.
* @param maxHeight The maximum height.
* @return the sample size
*/
private static int calculateInSampleSize(final BitmapFactory.Options options,
final int maxWidth,
final int maxHeight) {
int height = options.outHeight;
int width = options.outWidth;
int inSampleSize = 1;
while ((width >>= 1) >= maxWidth && (height >>= 1) >= maxHeight) {
inSampleSize <<= 1;
}
return inSampleSize;
}
///////////////////////////////////////////////////////////////////////////
// other utils methods
///////////////////////////////////////////////////////////////////////////
private static File getFileByPath(final String filePath) {
return isSpace(filePath) ? null : new File(filePath);
}
private static boolean createFileByDeleteOldFile(final File file) {
if (file == null) return false;
if (file.exists() && !file.delete()) return false;
if (!createOrExistsDir(file.getParentFile())) return false;
try {
return file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
return false;
}
}
private static boolean createOrExistsDir(final File file) {
return file != null && (file.exists() ? file.isDirectory() : file.mkdirs());
}
private static boolean isSpace(final String s) {
if (s == null) return true;
for (int i = 0, len = s.length(); i < len; ++i) {
if (!Character.isWhitespace(s.charAt(i))) {
return false;
}
}
return true;
}
private static byte[] input2Byte(final InputStream is) {
if (is == null) return null;
try {
ByteArrayOutputStream os = new ByteArrayOutputStream();
byte[] b = new byte[1024];
int len;
while ((len = is.read(b, 0, 1024)) != -1) {
os.write(b, 0, len);
}
return os.toByteArray();
} catch (IOException e) {
e.printStackTrace();
return null;
} finally {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static Bitmap url2Bitmap(final String url) {
URL imageurl = null;
Bitmap bitmap = null;
try {
imageurl = new URL(url);
} catch (MalformedURLException e) {
e.printStackTrace();
return null;
}
try {
HttpURLConnection conn = (HttpURLConnection) imageurl.openConnection();
conn.setDoInput(true);
conn.connect();
InputStream is = conn.getInputStream();
bitmap = BitmapFactory.decodeStream(is);
is.close();
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
}
网友评论