Android开发辅助工具类，用于快速开发，以便减少做重复的工作，提高开发效率，encrypt主要是包括加密工具。
- AESUtils：AES对称加密
public class AESUtils {
private AESUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 生成密钥
*
* @return
*/
public static byte[] initKey256() {
KeyGenerator keyGen = null;
try {
keyGen = KeyGenerator.getInstance("AES");
keyGen.init(256); //192 256
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
SecretKey secretKey = keyGen.generateKey();
return secretKey.getEncoded();
}
/**
* 生成密钥
*
* @param keysize
* @return
*/
public static byte[] initKey(int keysize) {
KeyGenerator keyGen = null;
try {
keyGen = KeyGenerator.getInstance("AES");
keyGen.init(keysize); //192 256
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
SecretKey secretKey = keyGen.generateKey();
return secretKey.getEncoded();
}
/**
* AES 加密
*
* @param data
* @param key
* @return
*/
public static byte[] encrypt(byte[] data, byte[] key) {
SecretKey secretKey = new SecretKeySpec(key, "AES");
try {
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] cipherBytes = cipher.doFinal(data);
return cipherBytes;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
return null;
}
/**
* AES 解密
*
* @param data
* @param key
* @return
*/
public static byte[] decrypt(byte[] data, byte[] key) {
SecretKey secretKey = new SecretKeySpec(key, "AES");
try {
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, secretKey);
byte[] plainBytes = cipher.doFinal(data);
return plainBytes;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
return null;
}
}
- DESUtils：DES对称加密
public class DESUtils {
private DESUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 生成密钥
*
* @return
*/
public static byte[] initKey56() {
KeyGenerator keyGen = null;
try {
keyGen = KeyGenerator.getInstance("DES");
keyGen.init(56);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
SecretKey secretKey = keyGen.generateKey();
return secretKey.getEncoded();
}
/**
* 生成密钥
*
* @param keysize
* @return
*/
public static byte[] initKey(int keysize) {
KeyGenerator keyGen = null;
try {
keyGen = KeyGenerator.getInstance("DES");
keyGen.init(keysize);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
SecretKey secretKey = keyGen.generateKey();
return secretKey.getEncoded();
}
/**
* DES 加密
*
* @param data
* @param key
* @return
*/
public static byte[] encrypt(byte[] data, byte[] key) {
SecretKey secretKey = new SecretKeySpec(key, "DES");
try {
Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] cipherBytes = cipher.doFinal(data);
return cipherBytes;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
return null;
}
/**
* DES 解密
*
* @param data
* @param key
* @return
*/
public static byte[] decrypt(byte[] data, byte[] key) {
SecretKey secretKey = new SecretKeySpec(key, "DES");
try {
Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
cipher.init(Cipher.DECRYPT_MODE, secretKey);
byte[] plainBytes = cipher.doFinal(data);
return plainBytes;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
return null;
}
}
- MD5Utils：MD5加密 （不可逆）
public class MD5Utils {
private MD5Utils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* MD5加密
* StringBuilder不支持并发操作，线性不安全的，不适合多线程中使用。但其在单线程中的性能比StringBuffer高。
*
* @param str
* @return
*/
public static String encryptMD5ForBuilder(String str) {
if (str == null || str.length() == 0) {
return null;
}
StringBuilder builder = new StringBuilder();
try {
MessageDigest digest = MessageDigest.getInstance("MD5");
digest.update(str.getBytes());
byte[] cipher = digest.digest();
for (byte b : cipher) {
String hexStr = Integer.toHexString(b & 0xff);
builder.append(hexStr.length() == 1 ? "0" + hexStr : hexStr);
}
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return builder.toString();
}
/**
* MD5加密
* StringBuffer支持并发操作，线性安全的，适合多线程中使用。
*
* @param str
* @return
*/
public static String encryptMD5ForBuffer(String str) {
if (str == null || str.length() == 0) {
return null;
}
StringBuffer buffer = new StringBuffer();
try {
MessageDigest digest = MessageDigest.getInstance("MD5");
digest.update(str.getBytes());
byte[] cipher = digest.digest();
for (byte b : cipher) {
String hexStr = Integer.toHexString(b & 0xff);
buffer.append(hexStr.length() == 1 ? "0" + hexStr : hexStr);
}
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return buffer.toString();
}
}
- SHA512Utils：SHA加密 （不可逆）
public class SHA512Utils {
private SHA512Utils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* SHA-512 加密
* StringBuilder不支持并发操作，线性不安全的，不适合多线程中使用。但其在单线程中的性能比StringBuffer高。
*
* @param str
* @return
*/
public static String encryptSHAForBuilder(String str) {
if (str == null || str.length() == 0) {
return null;
}
StringBuilder builder = new StringBuilder();
try {
MessageDigest digest = MessageDigest.getInstance("SHA-512");
digest.update(str.getBytes());
byte[] cipher = digest.digest();
for (byte b : cipher) {
String hexStr = Integer.toHexString(b & 0xff);
builder.append(hexStr.length() == 1 ? "0" + hexStr : hexStr);
}
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return builder.toString();
}
/**
* SHA-512 加密
* StringBuffer支持并发操作，线性安全的，适合多线程中使用。
*
* @param str
* @return
*/
public static String encryptSHAForBuffer(String str) {
if (str == null || str.length() == 0) {
return null;
}
StringBuffer buffer = new StringBuffer();
try {
MessageDigest digest = MessageDigest.getInstance("SHA-512");
digest.update(str.getBytes());
byte[] cipher = digest.digest();
for (byte b : cipher) {
String hexStr = Integer.toHexString(b & 0xff);
buffer.append(hexStr.length() == 1 ? "0" + hexStr : hexStr);
}
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return buffer.toString();
}
}
- TripleDESUtils：3DES对称加密
public class TripleDESUtils {
private TripleDESUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 生成密钥
*
* @return
*/
public static byte[] initKey168() {
KeyGenerator keyGen = null;
try {
keyGen = KeyGenerator.getInstance("DESede");
keyGen.init(168);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
SecretKey secretKey = keyGen.generateKey();
return secretKey.getEncoded();
}
/**
* 生成密钥
*
* @return
*/
public static byte[] initKey(int keysize) {
KeyGenerator keyGen = null;
try {
keyGen = KeyGenerator.getInstance("DESede");
keyGen.init(keysize); //112 168
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
SecretKey secretKey = keyGen.generateKey();
return secretKey.getEncoded();
}
/**
* 3DES 加密
*
* @param data
* @param key
* @return
*/
public static byte[] encrypt(byte[] data, byte[] key) {
SecretKey secretKey = new SecretKeySpec(key, "DESede");
try {
Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] cipherBytes = cipher.doFinal(data);
return cipherBytes;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
return null;
}
/**
* 3DES 解密
*
* @param data
* @param key
* @return
*/
public static byte[] decrypt(byte[] data, byte[] key) {
SecretKey secretKey = new SecretKeySpec(key, "DESede");
try {
Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
cipher.init(Cipher.DECRYPT_MODE, secretKey);
byte[] plainBytes = cipher.doFinal(data);
return plainBytes;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
return null;
}
}
- AppUtils：App相关辅助类
public class AppUtils {
private AppUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 获取app名称
*
* @param context
* @return
*/
public static String getAppName(Context context) {
PackageInfo info = getPackageInfo(context);
int labelRes = info.applicationInfo.labelRes;
return context.getResources().getString(labelRes);
}
/**
* 获取包名
*
* @param context
* @return
*/
public static String getPackageName(Context context) {
PackageInfo info = getPackageInfo(context);
return info.packageName;
}
/**
* 获取app版本名称
*
* @param context
* @return
*/
public static String getVersionName(Context context) {
PackageInfo info = getPackageInfo(context);
return info.versionName;
}
/**
* 获取版本号
*
* @param context
* @return
*/
public static int getVersionCode(Context context) {
PackageInfo packageInfo = getPackageInfo(context);
return packageInfo.versionCode;
}
private static PackageInfo getPackageInfo(Context context) {
try {
PackageManager pm = context.getPackageManager();
PackageInfo pi = pm.getPackageInfo(context.getPackageName(), PackageManager.GET_CONFIGURATIONS);
return pi;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
- BitmapUtils：Bitmap相关辅助类
public class BitmapUtils {
private BitmapUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* bitmap to byte[]
*
* @param b
* @param quality
* @return
*/
public static byte[] bitmapToByte(Bitmap b, int quality) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
b.compress(Bitmap.CompressFormat.PNG, quality, baos);
return baos.toByteArray();
}
/**
* byte[] to bitmap
*
* @param b
* @return
*/
public static Bitmap byteToBitmap(byte[] b) {
return (b == null || b.length == 0) ? null : BitmapFactory.decodeByteArray(b, 0, b.length);
}
/**
* bitmap to base64
*
* @param bitmap
* @return
*/
public static String bitmapToBase64(Bitmap bitmap) {
return Base64.encodeToString(bitmapToByte(bitmap, 100), Base64.DEFAULT);
}
/**
* base64 to bitmap
*
* @param base64Str
* @return
*/
public static Bitmap base64ToBitmap(String base64Str) {
byte[] bytes = Base64.decode(base64Str, Base64.DEFAULT);
return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
}
/**
* drawable to bitmap
*
* @param drawable
* @return
*/
public static Bitmap drawableToBitmap(Drawable drawable) {
BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
return bitmapDrawable.getBitmap();
}
/**
* bitmap to drawable
*
* @param context
* @param bitmap
* @return
*/
public static Drawable bitmapToDrawable(Context context, Bitmap bitmap) {
return bitmap == null ? null : new BitmapDrawable(context.getResources(), bitmap);
}
/**
* bitmap to uri
*
* @param context
* @param bitmap
* @return
*/
public static Uri bitmapToUri(Context context, Bitmap bitmap) {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
String path = MediaStore.Images.Media.insertImage(context.getContentResolver(), bitmap, "Title", null);
return Uri.parse(path);
}
/**
* 设置 inJustDecodeBounds 属性为true可以在解码的时候避免内存的分配，
* 它会返回一个null的Bitmap，但是可以获取到 outWidth, outHeight 与 outMimeType
*
* @param showWidth
* @param showHeight
* @return
*/
public static Bitmap getScaleBitmap(Resources res, int resId, int showWidth, int showHeight) {
BitmapFactory.Options options = getOptions();
options.inJustDecodeBounds = true;
BitmapFactory.decodeResource(res, resId, options);
options.inSampleSize = calculateInSampleSize(options, showWidth, showHeight);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeResource(res, resId, options);
}
public static Bitmap getScaleBitmap(String path, int showWidth, int showHeight) {
BitmapFactory.Options options = getOptions();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(path, options);
options.inSampleSize = calculateInSampleSize(options, showWidth, showHeight);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeFile(path, options);
}
/**
* 对bitmap 进行缩放
*
* @param bm
* @param showWidth
* @param showHeight
* @return
*/
private static Bitmap getScaleBitmap(Bitmap bm, float showWidth, float showHeight) {
if (bm == null) {
return null;
}
if (showWidth <= 0 || showHeight <= 0) {
return bm;
}
int width = bm.getWidth();
int height = bm.getHeight();
float scaleWidth = showWidth / width;
float scaleHeight = showHeight / height;
float scale = scaleWidth >= scaleHeight ? scaleWidth : scaleHeight;
Matrix matrix = new Matrix();
matrix.reset();
matrix.postScale(scale, scale);
bm = Bitmap.createBitmap(bm, 0, 0, width, height, matrix, true);
return bm;
}
/**
* 计算采样率
*
* @param options
* @param reqWidth
* @param reqHeight
* @return
*/
public 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) {
final int halfHeight = height / 2;
final int halfWidth = width / 2;
// Calculate the largest inSampleSize value that is a power of 2 and keeps both
// height and width larger than the requested height and width.
while ((halfHeight / inSampleSize) > reqHeight
&& (halfWidth / inSampleSize) > reqWidth) {
inSampleSize *= 2;
}
}
return inSampleSize;
}
private static BitmapFactory.Options getOptions() {
return new BitmapFactory.Options();
}
/**
* 翻转
* (-1,1) 左右
* (1,-1) 上下
*
* @param bmp
* @param sx
* @param sy
* @return
*/
public static Bitmap flipBitmap(Bitmap bmp, int sx, int sy) {
int w = bmp.getWidth();
int h = bmp.getHeight();
Matrix matrix = new Matrix();
matrix.postScale(sx, sy);
bmp = Bitmap.createBitmap(bmp, 0, 0, w, h, matrix, true);
return bmp;
}
/**
* 旋转
*
* @param bitmap
* @param degree
* @return
*/
public static Bitmap bitmapRotate(Bitmap bitmap, int degree) {
Matrix matrix = new Matrix();
matrix.postRotate(degree);
int width = bitmap.getWidth();
int height = bitmap.getHeight();
bitmap = Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, true);
return bitmap;
}
/**
* 创建圆形图片
*
* @param source
* @param size
* @return
*/
public static Bitmap createCircleImage(Bitmap source, int size) {
source = getScaleBitmap(source, size, size);
BitmapShader mBitmapShader = new BitmapShader(source, Shader.TileMode.REPEAT,
Shader.TileMode.REPEAT);
Bitmap dest = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888);
if (dest == null) {
return null;
}
Canvas canvas = new Canvas(dest);
Paint paint = new Paint();
paint.setAntiAlias(true);
paint.setShader(mBitmapShader);
canvas.drawCircle(size / 2, size / 2, size / 2, paint);
return dest;
}
public static Bitmap getBitmapWith(InputStream inputStream, Rect rect) {
try {
BitmapRegionDecoder bitmapRegionDecoder = BitmapRegionDecoder.newInstance(inputStream, false);
BitmapFactory.Options options = new BitmapFactory.Options();
options.inPreferredConfig = Bitmap.Config.RGB_565;
Bitmap bitmap = bitmapRegionDecoder.decodeRegion(rect, options);
return bitmap;
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}
- DateUtils：日期相关辅助类
public class DateUtils {
private DateUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 获取日期
*
* @param offset 表示偏移天数
* @return
*/
public String getNowDayOffset(int offset) {
Calendar m_Calendar = Calendar.getInstance();
long time = (long) m_Calendar.getTimeInMillis();
time = time + offset * 24 * 3600 * 1000;
Date myDate = new Date(time);
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
return df.format(myDate);
}
/**
* 获取日期
* @param time
* @return
*/
public String getTime(long time) {
Date myDate = new Date(time);
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
return df.format(myDate);
}
/**
* 使指定日期向前走一天，变成“明天”的日期
*
* @param cal 处理日期
*/
public void forward(Calendar cal) {
int year = cal.get(Calendar.YEAR);
int month = cal.get(Calendar.MONTH);//0到11
int day = cal.get(Calendar.DAY_OF_MONTH);
int days = getDaysOfMonth(year, month + 1);
if (day == days) {//如果是本月最后一天，还要判断年份是不是要向前滚
if (month == 11) {//如果是12月份，年份要向前滚
cal.roll(Calendar.YEAR, true);
cal.set(Calendar.MONTH, 0);//月份，第一月是0
cal.set(Calendar.DAY_OF_MONTH, 1);
} else {//如果不是12月份
cal.roll(Calendar.MONTH, true);
cal.set(Calendar.DAY_OF_MONTH, 1);
}
} else {
cal.roll(Calendar.DAY_OF_MONTH, 1);//如果是月内，直接天数加1
}
}
/**
* 使日期倒一天
*
* @param cal
*/
public void backward(Calendar cal) {
//计算上一月有多少天
int month = cal.get(Calendar.MONTH);//0到11
int year = cal.get(Calendar.YEAR);
int days = getDaysOfMonth(year, month);//上个月的天数
int day = cal.get(Calendar.DAY_OF_MONTH);
if (day == 1) {//如果是本月第一天，倒回上一月
if (month == 0) {//如果是本年第一个月，年份倒一天
cal.roll(Calendar.YEAR, false);
cal.set(Calendar.MONTH, 11);//去年最后一个月是12月
cal.set(Calendar.DAY_OF_MONTH, 31);//12月最后一天总是31号
} else {//月份向前
cal.roll(Calendar.MONTH, false);
cal.set(Calendar.DAY_OF_MONTH, days);//上个月最后一天
}
} else {
cal.roll(Calendar.DAY_OF_MONTH, false);//如果是月内，日期倒一天
}
}
/**
* 判断平年闰年
*
* @param year
* @return true表示闰年，false表示平年
*/
public boolean isLeapYear(int year) {
if (year % 400 == 0) {
return true;
} else if (year % 100 != 0 && year % 4 == 0) {
return true;
}
return false;
}
/**
* 计算某月的天数
*
* @param year
* @param month 现实生活中的月份，不是系统存储的月份，从1到12
* @return
*/
public int getDaysOfMonth(int year, int month) {
if (month < 1 || month > 12) {
return 0;
}
boolean isLeapYear = isLeapYear(year);
int daysOfMonth = 0;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
daysOfMonth = 31;
break;
case 4:
case 6:
case 9:
case 11:
daysOfMonth = 30;
break;
case 2:
if (isLeapYear) {
daysOfMonth = 29;
} else {
daysOfMonth = 28;
}
}
return daysOfMonth;
}
/**
* 获取当天凌晨的秒数
*
* @return
*/
public long secondsMorning(Calendar c) {
Calendar tempCalendar = Calendar.getInstance();
tempCalendar.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), c.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
return tempCalendar.getTimeInMillis();
}
/**
* 获取第二天凌晨的秒数
*
* @return
*/
public long secondsNight(Calendar c) {
Calendar tempCalendar = Calendar.getInstance();
tempCalendar.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), c.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
forward(tempCalendar);
return tempCalendar.getTimeInMillis();
}
/**
* 判断某两天是不是同一天
*
* @param c1
* @param c2
* @return
*/
public boolean isSameDay(Calendar c1, Calendar c2) {
if (c1.get(Calendar.YEAR) != c2.get(Calendar.YEAR))
return false;
if (c1.get(Calendar.MONTH) != c2.get(Calendar.MONTH))
return false;
if (c1.get(Calendar.DAY_OF_MONTH) != c2.get(Calendar.DAY_OF_MONTH))
return false;
return true;
}
}
- DevicesUtils：设备相关辅助类
public class DevicesUtils {
private DevicesUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 获取系统版本
*
* @return
*/
public static String getSystemVersion() {
return Build.VERSION.RELEASE;
}
/**
* 获取设备型号
*
* @return
*/
public static String getDevicesModel() {
return android.os.Build.MODEL;
}
/**
* 获取设备ID
*
* @return
*/
public static String getDevicesId(Context context) {
TelephonyManager telephonyManager = (TelephonyManager) context
.getSystemService(context.TELEPHONY_SERVICE);
return telephonyManager.getDeviceId();
}
/**
* 获取当前时间
*
* @return
*/
public static long getCurrentTime() {
return System.currentTimeMillis();
}
/**
* 获取日期
*
* @return
*/
public static String getDate() {
SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmss");
Date curDate = new Date(System.currentTimeMillis());
return formatter.format(curDate);
}
/**
* 获取 SD 卡路径
*
* @param context
* @param paramString
* @return
*/
public static String getSDCacheDir(Context context, String paramString) {
String absoultePath = "";
if ("mounted".equals(Environment.getExternalStorageState()))
absoultePath = Environment.getExternalStorageDirectory().getAbsolutePath();
if (absoultePath == null) {
File cacheDir = context.getCacheDir();
if (cacheDir != null) {
if (cacheDir.exists())
absoultePath = cacheDir.getPath();
}
}
return absoultePath + File.separator + paramString;
}
/**
* 获取mac地址
*
* @param context
* @return
*/
public static String getMacAddress(Context context) {
WifiManager wifi = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
WifiInfo info = wifi.getConnectionInfo();
String mac = info.getMacAddress();
return mac;
}
/**
* 获取设备IP
*
* @return
*/
public static String getDevicesIp() {
try {
for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en
.hasMoreElements(); ) {
NetworkInterface intf = en.nextElement();
for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr
.hasMoreElements(); ) {
InetAddress inetAddress = enumIpAddr.nextElement();
if (!inetAddress.isLoopbackAddress()) {
return inetAddress.getHostAddress().toString();
}
}
}
} catch (SocketException ex) {
ex.printStackTrace();
}
return null;
}
}
- FileUtils：文件相关辅助类
public class FileUtils {
private FileUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 检查是否存在SD卡
*/
public static boolean hasSdcard() {
String state = Environment.getExternalStorageState();
if (state.equals(Environment.MEDIA_MOUNTED)) {
return true;
} else {
return false;
}
}
/**
* 创建目录
*
* @param context
* @param dirName 文件夹名称
* @return
*/
public static File createFileDir(Context context, String dirName) {
String filePath;
// 如SD卡已存在，则存储；反之存在data目录下
if (hasSdcard()) {
// SD卡路径
filePath = Environment.getExternalStorageDirectory() + File.separator + dirName;
} else {
filePath = context.getCacheDir().getPath() + File.separator + dirName;
}
File destDir = new File(filePath);
if (!destDir.exists()) {
boolean isCreate = destDir.mkdirs();
Log.i("FileUtils", filePath + " has created. " + isCreate);
}
return destDir;
}
/**
* 删除文件（若为目录，则递归删除子目录和文件）
*
* @param file
* @param delThisPath true代表删除参数指定file，false代表保留参数指定file
*/
public static void delFile(File file, boolean delThisPath) {
if (!file.exists()) {
return;
}
if (file.isDirectory()) {
File[] subFiles = file.listFiles();
if (subFiles != null) {
int num = subFiles.length;
// 删除子目录和文件
for (int i = 0; i < num; i++) {
delFile(subFiles[i], true);
}
}
}
if (delThisPath) {
file.delete();
}
}
/**
* 获取文件大小，单位为byte（若为目录，则包括所有子目录和文件）
*
* @param file
* @return
*/
public static long getFileSize(File file) {
long size = 0;
if (file.exists()) {
if (file.isDirectory()) {
File[] subFiles = file.listFiles();
if (subFiles != null) {
int num = subFiles.length;
for (int i = 0; i < num; i++) {
size += getFileSize(subFiles[i]);
}
}
} else {
size += file.length();
}
}
return size;
}
/**
* 保存Bitmap到指定目录
*
* @param dir 目录
* @param fileName 文件名
* @param bitmap
*/
public static void saveBitmap(File dir, String fileName, Bitmap bitmap) {
if (bitmap == null) {
return;
}
File file = new File(dir, fileName);
try {
file.createNewFile();
FileOutputStream fos = new FileOutputStream(file);
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);
fos.flush();
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 判断某目录下文件是否存在
*
* @param dir 目录
* @param fileName 文件名
* @return
*/
public static boolean isFileExists(File dir, String fileName) {
return new File(dir, fileName).exists();
}
}
- KeyBoardUtils：软键盘相关辅助类
public class KeyBoardUtils {
private KeyBoardUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 切换软键盘的状态,如当前为收起变为弹出,若当前为弹出变为收起
*
* @param edittext
*/
public static void toggleKeybord(EditText edittext) {
InputMethodManager inputMethodManager = (InputMethodManager)
edittext.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
inputMethodManager.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS);
}
/**
* 强制隐藏输入法键盘
*
* @param edittext
*/
public static void hideKeybord(EditText edittext) {
InputMethodManager inputMethodManager = (InputMethodManager)
edittext.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
if (inputMethodManager.isActive()) {
inputMethodManager.hideSoftInputFromWindow(edittext.getWindowToken(), 0);
}
}
/**
* 强制显示输入法键盘
*
* @param edittext
*/
public static void showKeybord(EditText edittext) {
InputMethodManager inputMethodManager = (InputMethodManager)
edittext.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
inputMethodManager.showSoftInput(edittext, InputMethodManager.SHOW_FORCED);
}
/**
* 输入法是否显示
*
* @param edittext
* @return
*/
public static boolean isKeybord(EditText edittext) {
boolean bool = false;
InputMethodManager inputMethodManager = (InputMethodManager)
edittext.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
if (inputMethodManager.isActive()) {
bool = true;
}
return bool;
}
}
- LogUtils：打印相关辅助类
public class LogUtils {
private LogUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
private static boolean isDebug = false;
public static void setDebug(boolean debug) {
isDebug = debug;
}
public static void d(String tag, String msg) {
if (isDebug) {
Log.d(tag, msg);
}
}
public static void d(Object object, String msg) {
if (isDebug) {
Log.d(object.getClass().getSimpleName(), msg);
}
}
public static void i(String tag, String msg) {
if (isDebug) {
Log.i(tag, msg);
}
}
public static void i(Object object, String msg) {
if (isDebug) {
Log.i(object.getClass().getSimpleName(), msg);
}
}
public static void w(String tag, String msg) {
if (isDebug) {
Log.w(tag, msg);
}
}
public static void w(Object object, String msg) {
if (isDebug) {
Log.w(object.getClass().getSimpleName(), msg);
}
}
public static void e(String tag, String msg) {
if (isDebug) {
Log.e(tag, msg);
}
}
public static void e(Object object, String msg) {
if (isDebug) {
Log.e(object.getClass().getSimpleName(), msg);
}
}
}
- NetworkUtils：网络相关辅助类
public class NetworkUtils {
private NetworkUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
public static final int ACTION_WIFI_SETTINGS = 0;
public static final int ACTION_DATA_ROAMING_SETTINGS = 1;
/**
* 判断网络是否可用，需要加上访问网络状态的权限
*
* @param context
* @return
*/
public static boolean isNetworkAvaiable(Context context) {
ConnectivityManager connectivity = getConnectivityManager(context);
if (connectivity == null) {
return false;
}
NetworkInfo info = connectivity.getActiveNetworkInfo();
if (info == null || !info.isAvailable()) {
return false;
}
return true;
}
/**
* 判断网络是否连接
*
* @param context
* @return
*/
public static boolean isConnected(Context context) {
ConnectivityManager connectivity = getConnectivityManager(context);
if (null != connectivity) {
NetworkInfo info = connectivity.getActiveNetworkInfo();
if (null != info && info.isConnected()) {
if (info.getState() == NetworkInfo.State.CONNECTED) {
return true;
}
}
}
return false;
}
/**
* 判断是否是WiFi网络
*
* @param context
* @return
*/
public static boolean isWifiConn(Context context) {
boolean isCommected = isConnected(context);
if (isCommected) {
ConnectivityManager connectivity = getConnectivityManager(context);
if (connectivity == null)
return false;
return connectivity.getActiveNetworkInfo().getType() == ConnectivityManager.TYPE_WIFI;
}
return false;
}
/**
* 获取网络连接管理
*
* @param context
* @return
*/
private static ConnectivityManager getConnectivityManager(Context context) {
return (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
}
/**
* 打开网络设置界面 整体
*
* @param activity
*/
public static void openSetting(Activity activity) {
//整体
activity.startActivity(new Intent(Settings.ACTION_WIRELESS_SETTINGS));
}
/**
* 打开网络设置界面 WIFI/流量
*
* @param activity
* @param i 0:WIFI/1:流量
*/
public static void openSetting(Activity activity, int i) {
if (i == ACTION_WIFI_SETTINGS) {
//WIFI
activity.startActivity(new Intent(Settings.ACTION_WIFI_SETTINGS));
} else if (i == ACTION_DATA_ROAMING_SETTINGS) {
//流量
activity.startActivity(new Intent(
android.provider.Settings.ACTION_DATA_ROAMING_SETTINGS));
}
}
}
- SDCardUtils：SD卡相关辅助类
public class SDCardUtils {
private SDCardUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 判断SDCard是否可用
*/
public static boolean isSDCardEnable() {
return Environment.getExternalStorageState().equals(
Environment.MEDIA_MOUNTED);
}
/**
* 获取SD卡路径
*/
public static String getSDCardPath() {
return Environment.getExternalStorageDirectory().getAbsolutePath()
+ File.separator;
}
/**
* 获取SD卡的剩余容量(byte)
*/
public static long getSDCardAllSize() {
if (isSDCardEnable()) {
StatFs stat = new StatFs(getSDCardPath());
// 获取空闲的数据块的数量
long availableBlocks = (long) stat.getAvailableBlocks() - 4;
// 获取单个数据块的大小（byte）
long freeBlocks = stat.getAvailableBlocks();
return freeBlocks * availableBlocks;
}
return 0;
}
/**
* 获取指定路径所在空间的剩余可用容量字节数(byte)
* @param filePath
* @return 容量字节 SDCard可用空间，内部存储可用空间
*/
public static long getFreeBytes(String filePath) {
// 如果是sd卡的下的路径，则获取sd卡可用容量
if (filePath.startsWith(getSDCardPath())) {
filePath = getSDCardPath();
} else {// 如果是内部存储的路径，则获取内存存储的可用容量
filePath = Environment.getDataDirectory().getAbsolutePath();
}
StatFs stat = new StatFs(filePath);
long availableBlocks = (long) stat.getAvailableBlocks() - 4;
return stat.getBlockSize() * availableBlocks;
}
/**
* 获取系统存储路径
*/
public static String getRootDirectoryPath() {
return Environment.getRootDirectory().getAbsolutePath();
}
}
- SPUtils：SharedPreferences相关辅助类
public class SPUtils {
private SPUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 保存文件名
*/
public static final String FILE_NAME = "config";
/**
* 保存数据的方法，根据类型调用不同的保存方法
*
* @param context
* @param key
* @param value
*/
public static void putString(Context context, String key, String value) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
sp.edit().putString(key, value).apply(); //commit同步的，apply异步的
}
public static void putInt(Context context, String key, int value) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
sp.edit().putInt(key, value).apply();
}
public static void putBoolean(Context context, String key, boolean value) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
sp.edit().putBoolean(key, value).apply();
}
public static void putFloat(Context context, String key, float value) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
sp.edit().putFloat(key, value).apply();
}
public static void putLong(Context context, String key, long value) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
sp.edit().putLong(key, value).apply();
}
/**
* 保存图片到SharedPreferences
*
* @param mContext
* @param key
* @param imageView
*/
public static void putImage(Context mContext, String key, ImageView imageView) {
BitmapDrawable drawable = (BitmapDrawable) imageView.getDrawable();
Bitmap bitmap = drawable.getBitmap();
// 将Bitmap压缩成字节数组输出流
ByteArrayOutputStream byStream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.PNG, 80, byStream);
// 利用Base64将我们的字节数组输出流转换成String
byte[] byteArray = byStream.toByteArray();
String imgString = new String(Base64.encodeToString(byteArray, Base64.DEFAULT));
// 将String保存shareUtils
SPUtils.putString(mContext, key, imgString);
}
/**
* 获取数据的方法，根据默认值得到数据的类型，然后调用对应方法获取值
*
* @param context
* @param key
* @param defValue
* @return
*/
public static String getString(Context context, String key, String defValue) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
return sp.getString(key, defValue);
}
public static int getInt(Context context, String key, int defValue) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
return sp.getInt(key, defValue);
}
public static boolean getBoolean(Context context, String key, boolean defValue) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
return sp.getBoolean(key, defValue);
}
public static float getFloat(Context context, String key, float defValue) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
return sp.getFloat(key, defValue);
}
public static long getLong(Context context, String key, long defValue) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
return sp.getLong(key, defValue);
}
/**
* 从SharedPreferences读取图片
*
* @param mContext
* @param key
* @param imageView
* @return
*/
public static Bitmap getImage(Context mContext, String key, ImageView imageView) {
String imgString = SPUtils.getString(mContext, key, "");
if (!imgString.equals("")) {
// 利用Base64将我们string转换
byte[] byteArray = Base64.decode(imgString, Base64.DEFAULT);
ByteArrayInputStream byStream = new ByteArrayInputStream(byteArray);
// 生成bitmap
return BitmapFactory.decodeStream(byStream);
}
return null;
}
/**
* 移除某个key对应的值
*
* @param context
* @param key
*/
public static void remove(Context context, String key) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
sp.edit().remove(key).apply();
}
/**
* 清除所有数据
*
* @param context
*/
public static void clear(Context context) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
sp.edit().clear().apply();
}
/**
* 查询某个key是否已经存在
*
* @param context
* @param key
* @return
*/
public static boolean contains(Context context, String key) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
return sp.contains(key);
}
/**
* 返回所有的键值对
*
* @param context
* @return
*/
public static Map<String, ?> getAll(Context context) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
return sp.getAll();
}
}
- ScreenUtils：屏幕相关辅助类
public class ScreenUtils {
private ScreenUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 获得屏幕宽度
*
* @param context
* @return
*/
public static int getScreenWidth(Context context) {
DisplayMetrics dm = getDisplayMetrics(context);
return dm.widthPixels;
}
/**
* 获得屏幕高度
*
* @param context
* @return
*/
public static int getScreenHeight(Context context) {
DisplayMetrics dm = getDisplayMetrics(context);
return dm.heightPixels;
}
/**
* 获取屏幕密度
*
* @param context
* @return
*/
public static float getScreenDensity(Context context) {
DisplayMetrics dm = getDisplayMetrics(context);
return dm.density;
}
/**
* 获取屏幕密度 dpi
*
* @param context
* @return
*/
public static float getScreenDensityDpi(Context context) {
DisplayMetrics dm = getDisplayMetrics(context);
return dm.densityDpi;
}
/**
* 获得状态栏的高度
*
* @param context
* @return
*/
public static int getStatusBarHeight(Context context) {
int statusBarHeight = 0;
int resourceId = context.getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resourceId > 0) {
statusBarHeight = context.getResources().getDimensionPixelSize(resourceId);
}
return statusBarHeight;
}
/**
* dip转px
*
* @param context
* @param dpVal
* @return
*/
public static int dip2px(Context context, float dpVal) {
return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
dpVal, context.getResources().getDisplayMetrics());
}
/**
* sp转px
*
* @param context
* @param spVal
* @return
*/
public static int sp2px(Context context, float spVal) {
return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP,
spVal, context.getResources().getDisplayMetrics());
}
/**
* px转dip
*
* @param context
* @param pxVal
* @return
*/
public static float px2dip(Context context, float pxVal) {
final float scale = context.getResources().getDisplayMetrics().density;
return (pxVal / scale);
}
/**
* px转sp
*
* @param context
* @param pxVal
* @return
*/
public static float px2sp(Context context, float pxVal) {
return (pxVal / context.getResources().getDisplayMetrics().scaledDensity);
}
/**
* 获取当前屏幕截图，包含状态栏
*
* @param activity
* @return
*/
public static Bitmap snapShotWithStatusBar(Activity activity) {
View view = activity.getWindow().getDecorView();
view.setDrawingCacheEnabled(true);
view.buildDrawingCache();
Bitmap bmp = view.getDrawingCache();
int width = getScreenWidth(activity);
int height = getScreenHeight(activity);
Bitmap bp = null;
bp = Bitmap.createBitmap(bmp, 0, 0, width, height);
view.destroyDrawingCache();
return bp;
}
/**
* 获取当前屏幕截图，不包含状态栏
*
* @param activity
* @return
*/
public static Bitmap snapShotWithoutStatusBar(Activity activity) {
View view = activity.getWindow().getDecorView();
view.setDrawingCacheEnabled(true);
view.buildDrawingCache();
Bitmap bmp = view.getDrawingCache();
Rect frame = new Rect();
activity.getWindow().getDecorView().getWindowVisibleDisplayFrame(frame);
int statusBarHeight = frame.top;
int width = getScreenWidth(activity);
int height = getScreenHeight(activity);
Bitmap bp = null;
bp = Bitmap.createBitmap(bmp, 0, statusBarHeight, width, height
- statusBarHeight);
view.destroyDrawingCache();
return bp;
}
private static DisplayMetrics getDisplayMetrics(Context context) {
WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics outMetrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(outMetrics);
return outMetrics;
}
}
- StringUtils：字符相关辅助类
public class StringUtils {
private static final String TELREGEX = "^(13[0-9]|14[0-9]|15[0-9]|17[0-9]|18[0-9])\\d{8}$";
private static final String EMAILREGEX = "\\w+([-.]\\w+)*@\\w+([-]\\w+)*\\.(\\w+([-]\\w+)*\\.)*[a-z]{2,3}$";
private static final String URLREGEX = "^(http://|https://)?((?:[A-Za-z0-9]+-[A-Za-z0-9]+|[A-Za-z0-9]+)\\.)+([A-Za-z]+)[/\\?\\:]?.*$";
private static final String IPREGEX = "((?:(?:25[0-5]|2[0-4]\\\\d|[01]?\\\\d?\\\\d)\\\\.){3}(?:25[0-5]|2[0-4]\\\\d|[01]?\\\\d?\\\\d))";
private static final String CHINESEREGEX = "[\\u4E00-\\u9FA5\\uF900-\\uFA2D]";
private static final String IDNUMREGEX = "^\\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$";
private StringUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* Unicode转中文
*
* @param utfString
* @return
*/
public String convertUnicodeToChina(String utfString) {
StringBuilder sb = new StringBuilder();
int i = -1;
int pos = 0;
while ((i = utfString.indexOf("\\u", pos)) != -1) {
sb.append(utfString.substring(pos, i));
if (i + 5 < utfString.length()) {
pos = i + 6;
sb.append((char) Integer.parseInt(utfString.substring(i + 2, i + 6), 16));
}
}
return sb.toString();
}
/**
* 手机号码验证
*
* @param mobiles
* @return
*/
public static boolean isMobile(String mobiles) {
return check(mobiles, TELREGEX);
}
/**
* 邮箱验证
*
* @param email
* @return
*/
public static boolean isEmail(String email) {
return check(email, EMAILREGEX);
}
/**
* http、https Url验证
*
* @param url
* @return
*/
public static boolean isHttpUrl(String url) {
return check(url, URLREGEX);
}
/**
* ip 验证
*
* @param ip
* @return
*/
public static boolean isIp(String ip) {
return check(ip, IPREGEX);
}
/**
* 中文验证
*
* @param sequence
* @return
*/
public static boolean isContainChinese(String sequence) {
return check(sequence, CHINESEREGEX);
}
/**
* 身份证号验证
*
* @param id
* @return
*/
public static boolean isIDNumber(String id) {
return check(id, IDNUMREGEX);
}
private static boolean check(String content, String rule) {
Pattern p = Pattern.compile(rule);
Matcher m = p.matcher(content);
return m.matches();
}
/**
* 十六进制字符串转换为byte数组
*
* @param hexString
* @return
*/
public static byte[] hexString2Bytes(String hexString) {
if (hexString == null || hexString.equals("")) {
return null;
}
hexString = hexString.toUpperCase();
int length = hexString.length() / 2;
char[] hexChars = hexString.toCharArray();
byte[] d = new byte[length];
for (int i = 0; i < length; i++) {
int pos = i * 2;
d[i] = (byte) (char2Byte(hexChars[pos]) << 4 | char2Byte(hexChars[pos + 1]));
}
return d;
}
public static byte char2Byte(char c) {
return (byte) "0123456789ABCDEF".indexOf(c);
}
/**
* byte数组转换为十六进制字符串
*
* @param b
* @return
*/
public static String bytes2HexString(byte[] b) {
if (b.length == 0) {
return null;
}
StringBuilder sb = new StringBuilder("");
for (int i = 0; i < b.length; i++) {
int value = b[i] & 0xFF;
String hv = Integer.toHexString(value);
if (hv.length() < 2) {
sb.append(0);
}
sb.append(hv);
}
return sb.toString();
}
/**
* int转换为byte数组
*
* @param res
* @return
*/
public static byte[] int2Byte(int res) {
byte[] targets = new byte[4];
targets[0] = (byte) (res & 0xff);// 最低位
targets[1] = (byte) ((res >> 8) & 0xff);// 次低位
targets[2] = (byte) ((res >> 16) & 0xff);// 次高位
targets[3] = (byte) (res >>> 24);// 最高位,无符号右移。
return targets;
}
/**
* byte数组转换为int
*
* @param res
* @return
*/
public static int byte2Int(byte[] res) {
// 一个byte数据左移24位变成0x??000000，再右移8位变成0x00??0000
int targets = (res[3] & 0xff) | ((res[2] << 8) & 0xff00) | ((res[1] << 16) & 0xff0000) | ((res[0] << 24) & 0xff000000);
return targets;
}
/**
* 保留几位小数
*/
public static String saveDecimals(int cnt, double value) {
if (cnt == 2)
return String.format("%.02f", value);
else if (cnt == 1)
return String.format("%.01f", value);
else
return String.format("%.0f", value);
}
}
- ToastUtils：吐司相关辅助类
public class ToastUtils {
private ToastUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 短时间显示Toast
*/
public static void showShort(Context context, CharSequence message) {
Toast.makeText(context, message, Toast.LENGTH_SHORT).show();
}
/**
* 长时间显示Toast
*/
public static void showLong(Context context, CharSequence message) {
Toast.makeText(context, message, Toast.LENGTH_LONG).show();
}
}
- ViewUtils：View相关辅助类
public class ViewUtils {
private ViewUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 把自身从父View中移除
*
* @param view
*/
public static void removeSelfFromParent(View view) {
if (view != null) {
ViewParent parent = view.getParent();
if (parent != null && parent instanceof ViewGroup) {
ViewGroup group = (ViewGroup) parent;
group.removeView(view);
}
}
}
/**
* 判断触点是否落在该View上
*
* @param ev
* @param v
* @return
*/
public static boolean isTouchInView(MotionEvent ev, View v) {
int[] vLoc = new int[2];
v.getLocationOnScreen(vLoc);
float motionX = ev.getRawX();
float motionY = ev.getRawY();
return motionX >= vLoc[0] && motionX <= (vLoc[0] + v.getWidth())
&& motionY >= vLoc[1] && motionY <= (vLoc[1] + v.getHeight());
}
}