Android开发工具系列：Utils工具
Androi开发工具系列：SharedPreference管理工具
Android开发工具系列：弱引用工具
Android开发工具系列：Utils工具
文章目录
- 1 TimeUtils
- 2 NTPTimeUtils
- 3 DrawableUtils
- 4 DensityUtils
- 5 SDcardUtils
- 6 JSONUtils
- 7 KeyboardUtils
- 8 ScreenUtils
1 TimeUtils
public class TimeUtils {
public static final int YEAR = 0;
public static final int MONTH = 1;
public static final int DAY = 2;
public static final int HOUR = 3;
public static final int MINUTE = 4;
private static final DecimalFormat sDecimalFormat = new DecimalFormat("00");
@SuppressLint("SimpleDateFormat")
private static final SimpleDateFormat sDate24HourFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
@SuppressLint("SimpleDateFormat")
private static final SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
private TimeUtils() {
/* cannot be instantiated */
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 获取当前年份
*/
public static int getYear() {
return getYear("");
}
public static int getYear(String year) {
if (TextUtils.isEmpty(year)) {
return new Date().getYear() + 1900;
}
return Integer.valueOf(year);
}
/**
* 获取当前月份
*/
public static int getMonth() {
return getMonth("");
}
public static int getMonth(String month) {
if (TextUtils.isEmpty(month)) {
return new Date().getMonth() + 1;
}
return Integer.valueOf(month);
}
/**
* 获取当前日期
*/
public static int getDay() {
return getDay("");
}
public static int getDay(String day) {
if (TextUtils.isEmpty(day)) {
return new Date().getDate();
}
return Integer.valueOf(day);
}
/**
* 获取当前小时
*/
public static int getHour() {
return getHour("");
}
public static int getHour(String hour) {
if (TextUtils.isEmpty(hour)) {
return new Date().getHours();
}
return Integer.valueOf(hour);
}
/**
* 获取当前分钟
*/
public static int getMinute() {
return getMinute("");
}
public static int getMinute(String minute) {
if (TextUtils.isEmpty(minute)) {
return new Date().getMinutes();
}
return Integer.valueOf(minute);
}
/**
* 根据年月日获取星期几
*/
public static int getDayOfWeek(int year, int month, int day) {
Calendar instance = Calendar.getInstance();
instance.set(Calendar.YEAR, year);
instance.set(Calendar.MONTH, month - 1);
instance.set(Calendar.DAY_OF_MONTH, day);
return instance.get(Calendar.DAY_OF_WEEK);
}
/**
* 传递星期几获取当月相同星期的具体日期
*
* @param targetDayOfWeek 星期，targetDayOfWeek=Calendar.SUNDAY~SATURDAY
* @return [15, 20]
*/
public static List<Integer> getDayOfMonthsByDayOfWeek(int year, int month, int targetDayOfWeek) {
int maxDayOfMonth = getDayOfMonthByYearAndMonth(year, month);
List<Integer> dayOfWeeks = new ArrayList<>();
for (int i = 1; i <= maxDayOfMonth; i++) {
int dayOfWeek = getDayOfWeek(year, month, i);
if (dayOfWeek == targetDayOfWeek) {
dayOfWeeks.add(i);
}
}
return dayOfWeeks;
}
public static int getWeekByStr(Context context, String week) {
if (TextUtils.equals(week, context.getString(R.string.sunday))) {
return Calendar.SUNDAY;
} else if (TextUtils.equals(week, context.getString(R.string.monday))) {
return Calendar.MONDAY;
} else if (TextUtils.equals(week, context.getString(R.string.tuesday))) {
return Calendar.TUESDAY;
} else if (TextUtils.equals(week, context.getString(R.string.wednesday))) {
return Calendar.WEDNESDAY;
} else if (TextUtils.equals(week, context.getString(R.string.thursday))) {
return Calendar.THURSDAY;
} else if (TextUtils.equals(week, context.getString(R.string.friday))) {
return Calendar.FRIDAY;
} else if (TextUtils.equals(week, context.getString(R.string.saturday))) {
return Calendar.SATURDAY;
} else {
return -1;
}
}
/**
* 获取某年某月的最大天数
*/
public static int getDayOfMonthByYearAndMonth(int year, int month) {
Calendar instance = Calendar.getInstance();
instance.set(Calendar.YEAR, year);
instance.set(Calendar.MONTH, month - 1);
return instance.getActualMaximum(Calendar.DAY_OF_MONTH);
}
/**
* 计算两个日期之间的总秒数
*/
public static int getTotalSeconds(LocalTime startTime, LocalTime endTime) {
if (endTime.hour < startTime.hour) endTime.day += 1; // 计算时间不需要理会超过当前月份天数问题，超过一天直接+1计算
DateModel dateModel = new DateModel(startTime, endTime);
return dateModel.getBetweenSeconds();
}
/**
* 根据提供的开始年月日时分和秒数，计算经过seconds秒后的具体日期
*
* @return [year, month, day, hour] 通过TimeUtils上的常量索引YEAR、MONTH、DAY、HOUR、MINUTE获取
*/
public static int[] getEndDate(int year, int month, int day, int hour, int minute, int seconds) {
long startTime = new Date(year, month, day, hour, minute).getTime();
long endTime = startTime + seconds * 1000;
int[] endDateArr = new int[5];
Date endDate = new Date(endTime);
endDateArr[YEAR] = endDate.getYear();
endDateArr[MONTH] = endDate.getMonth();
endDateArr[DAY] = endDate.getDate();
endDateArr[HOUR] = endDate.getHours();
endDateArr[MINUTE] = endDate.getMinutes();
int dayOfMonth = getDayOfMonthByYearAndMonth(endDateArr[YEAR], endDateArr[MONTH]);
// 计算的天数超过了当月的总天数，月份+1
if (endDateArr[DAY] > dayOfMonth) {
endDateArr[MONTH]++;
endDateArr[DAY] = 1;
// 计算的月份超过了总月份，年份+1
if (endDateArr[MONTH] > 12) {
endDateArr[YEAR]++;
endDateArr[MONTH] = 1;
}
}
return endDateArr;
}
public static boolean isMonthValid(int month) {
return month >= 0 && month <= 12;
}
public static boolean isHourValid(int hour) {
return hour >= 0 && hour <= 23;
}
public static boolean isMinuteValid(int minute) {
return minute >= 0 && minute <= 59;
}
/**
* 根据秒数获取格式化时分秒
*
* @return 00:00:00
*/
public static String getDecimalFormatTime(int seconds) {
String hour = sDecimalFormat.format(seconds / 3600);
String minute = sDecimalFormat.format(seconds % 3600 / 60);
String second = sDecimalFormat.format(seconds % 60);
return hour + ":" + minute + ":" + second;
}
/**
* 根据年月日时分秒获取当前时区的时间（已处理夏令时）
*
* @return 00:00:00
*/
public String formatZoneTime(Context context, int year, int month, int day, int hour, int minute, int second) {
String zone = TimeZone.getDefault().getID();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
return formatZoneTimeAndroidO(context, createLocalDateTime(year, month, day, hour, minute, second), ZoneId.of(zone));
} else {
TimeZone timeZone = TimeZone.getTimeZone(zone);
Calendar.getInstance().setTimeZone(timeZone);
SimpleDateFormat format = NtpTimeUtils.is24HourFormat(context) ? sDate24HourFormat : sDateFormat;
format.setTimeZone(timeZone);
return timeFormat(format, getDateTime(year, month - 1, day, hour, minute, second));
}
}
public String timeFormat(SimpleDateFormat format, long time) {
return timeFormat(format, new Date(time));
}
public String timeFormat(SimpleDateFormat format, Date date) {
return format.format(date);
}
/**
* 传递年月日时分秒获取日期Date
*/
public Date getDateTime(int year, int month, int day, int hour, int minute, int second) {
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.YEAR, year);
calendar.set(Calendar.MONTH, month); // 需要注意Calendar的月份计算时要-1，获取时要+1
calendar.set(Calendar.DAY_OF_MONTH, day);
calendar.set(Calendar.HOUR_OF_DAY, hour);
calendar.set(Calendar.MINUTE, minute);
calendar.set(Calendar.SECOND, second);
return calendar.getTime(); // Date.getTime()获取时间戳
}
@RequiresApi(Build.VERSION_CODES.O)
private LocalDateTime createLocalDateTime(int year, int month, int day, int hour, int minute, int second) {
return LocalDateTime.of(year, month, day, hour, minute, second);
}
@RequiresApi(Build.VERSION_CODES.O)
private String formatZoneTimeAndroidO(Context context, LocalDateTime time, ZoneId zoneId) {
ZonedDateTime zonedDateTime = time.atZone(ZoneId.systemDefault());
ZonedDateTime zoneSameInstant = zonedDateTime.withZoneSameInstant(zoneId);
long hours = Duration.between(zoneSameInstant.withEarlierOffsetAtOverlap(),
zoneSameInstant.withLaterOffsetAtOverlap()).toHours();
zoneSameInstant = zoneSameInstant.plusHours(hours);
String format = NtpTimeUtils.is24HourFormat(context) ? "yyyy-MM-dd HH:mm:ss" : "yyyy-MM-dd hh:mm:ss";
return zoneSameInstant.format(DateTimeFormatter.ofPattern(format));
}
/**
* 0时区的Mjd转换为当前时区日期
*
* @param zeroMjd 0时区Mjd
* @return 当前时区日期
*/
public LocalTime mjdToLocal(MjdTime zeroMjd) {
LocalTime zeroTime = mjdToDate(zeroMjd.mjdDate);
if (zeroTime != null) {
zeroTime.hour = zeroMjd.mjdTime / 3600;
zeroTime.minute = (zeroMjd.mjdTime % 3600) / 60;
zeroTime.second = ((zeroMjd.mjdTime % 3600) % 60);
return adjustZoneTime(zeroTime);
}
return null;
}
/**
* Mjd转为0时区日期
*/
public LocalTime mjdToDate(int mjd) {
if (mjd != 0) {
int year = (int) ((((float) mjd) - 15078.2) / 365.25);
int month = (int) ((((float) mjd) - 14956.1 - (int) (((float) year) * 365.25)) / 30.6001);
int day = (int) (mjd - 14956 - ((int) (((float) month) * 365.25)) - ((int) (((float) month) * 30.6001)));
int k = ((month == 14 || month == 15) ? 1 : 0);
year = (int) (year + k + 1900);
month = month - 1 - k * 12;
// int weekday = ((mjd + 2) % 7) + 1;
LocalTime zeroTime = new LocalTime();
zeroTime.year = year;
zeroTime.month = month;
zeroTime.day = day;
}
return null;
}
/**
* 日期转为Mjd
*/
public int dateToMjd(int year, int month, int day) {
if (year < 1900) return -1;
int il = (1 == month) || (2 == month) ? 1 : 0;
year = year - 1900;
return 14956 + day + (int) (((float) (year - il)) * 365.25) + (int) (((float) (month + 1 + il * 12)) * 30.6001);
}
/**
* 0时区Mjd转换为当前时区Mjd
*
* @param zeroMjd 0时区Mjd
* @return 当前时区的Mjd
*/
public MjdTime zeroMjdToLocalMjd(MjdTime zeroMjd) {
LocalTime localTime = mjdToLocal(zeroMjd);
int localMjdDate = dateToMjd(localTime.year, localTime.month, localTime.day);
int localMjdTime = getCurrTimeZoneMjdTotalSeconds();
MjdTime localMjd = new MjdTime();
localMjd.mjdDate = localMjdDate;
localMjd.mjdTime = localMjdTime;
return localMjd;
}
/**
* 获取当前时区从00:00:00到现在的总秒数（已处理夏令时）
*/
private int getCurrTimeZoneMjdTotalSeconds() {
Calendar calendar = Calendar.getInstance();
calendar.setTimeZone(TimeZone.getDefault());
int hour = calendar.get(Calendar.HOUR_OF_DAY);
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
return second + minute * 60 + hour * 3600;
}
/**
* 0时区日期转换为当前时区日期
*
* @param zeroTime 0时区日期
* @return 当前时区日期
*/
public LocalTime adjustZoneTime(LocalTime zeroTime) {
return adjustZoneTime(zeroTime, TimeZone.getTimeZone("GMT"), TimeZone.getDefault());
}
/**
* 旧时区日期转换为新时区日期
*
* @param oldTime 旧时区日期
* @param oldTimeZone 旧时区，默认为底层的0时区
* @param newTimeZone 新时区，默认为当前时区
* @return 新时区日期
*/
public LocalTime adjustZoneTime(LocalTime oldTime, TimeZone oldTimeZone, TimeZone newTimeZone) {
return adjustZoneTime(oldTime.year, oldTime.month, oldTime.day, oldTime.hour, oldTime.minute, oldTime.second, oldTimeZone, newTimeZone);
}
public LocalTime adjustZoneTime(int year, int month, int day, int hour, int minute, int second, TimeZone oldTimeZone, TimeZone newTimeZone) {
Date oldDate = getDateTime(year, month - 1, day, hour, minute, second);
int timeOffset = oldTimeZone.getOffset(oldDate.getTime()) - newTimeZone.getOffset(oldDate.getTime()); // 时区之间的时间差
Date newDate = new Date(oldDate.getTime() - timeOffset);
Calendar calendar = Calendar.getInstance();
calendar.setTime(newDate);
LocalTime localTime = new LocalTime();
localTime.year = calendar.get(Calendar.YEAR);
localTime.month = calendar.get(Calendar.MONTH) + 1;
localTime.day = calendar.get(Calendar.DAY_OF_MONTH);
localTime.hour = calendar.get(Calendar.HOUR_OF_DAY);
localTime.minute = calendar.get(Calendar.MINUTE);
localTime.second = calendar.get(Calendar.SECOND);
return localTime;
}
}
public class LocalTime {
public int year;
public int month;
public int day;
public int hour;
public int minute;
public int second;
}
// TimeUtils中的儒略历时间MjdTime默认都是0时区，所以也处理了时区日期转换操作，根据需要取舍是否转换时区
public class MjdTime {
public int mjdDate;
public int mjdTime;
}
public class DateModel {
private final LocalTime start;
private final LocalTime end;
public DateModel(LocalTime start, LocalTime end) {
this.start = start;
this.end = end;
}
public int getBetweenSeconds() {
long seconds = getDate(end).getTime() - getDate(start).getTime();
if (seconds < 0) {
return 0;
}
return (int) (seconds / 1000);
}
private Date getDate(LocalTime localTime) {
return new Date(localTime.year, localTime.month, localTime.day, localTime.hour, localTime.minute);
}
public LocalTime getStart() {
return start;
}
public LocalTime getEnd() {
return end;
}
}
2 NTPTimeUtils
参考：通过NTP获取网络时间
参考：设置系统日期和时间
public class NtpTimeUtils {
// NTP服务器地址，同步获取网络时间（网络获取的时间已处理夏令时）
private static String[] ntpServerHost = new String[]{
"cn.pool.ntp.org",
"ntp1.aliyun.com",
"ntp2.aliyun.com",
"ntp3.aliyun.com"
};
// AndroidManifest.xml需要添加权限
private static String[] networkPermissions = new String[]{
Manifest.permission.INTERNET,
Manifest.permission.ACCESS_NETWORK_STATE
};
// 运行在子线程
@WorkerThread
private static long getTimeFromNtpServer(String ntpHost) {
SntpClient client = new SntpClient();
boolean isSuccessful = client.requestTime(ntpHost, 3000);
if (isSuccessful) {
return client.getNtpTime();
}
return -1;
}
// 运行在子线程
@WorkerThread
public static long getTime() {
for (String host : ntpServerHost) {
// 获取到当前时区时间的时间戳
// int diff = time - System.currentTimeMillis(); 缓存时间差
// long currTime = System.currentTimeMillis() + diff; 获取当前时间
long time = getTimeFromNtpServer(host);
if (time != -1) {
return time;
}
}
return -1;
}
/**
* 系统Setting是否打开网络获取时间开关
*/
public static boolean isAutoTime(Context context) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
try {
return Settings.Global.getInt(context.getContentResolver(), Settings.Global.AUTO_TIME) > 0;
} catch (Settings.SettingNotFoundException e) {
e.printStackTrace();
return false;
}
}
return false;
}
/**
* 是否连接网络
*/
public static boolean isNetworkActive(Context context) {
for (String permission : networkPermissions) {
if (ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_DENIED) {
return false;
}
}
ConnectivityManager cmm = (ConnectivityManager) context.getSystemService(CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = cmm.getActiveNetworkInfo();
return networkInfo != null && networkInfo.isConnected();
}
/**
* 系统Setting是否打开时间显示为24小时开关
*/
public static boolean is24HourFormat(Context context) {
return DateFormat.is24HourFormat(context);
}
}
public class SntpClient {
private static final String TAG = "SntpClient";
private static final int REFERENCE_TIME_OFFSET = 16;
private static final int ORIGINATE_TIME_OFFSET = 24;
private static final int RECEIVE_TIME_OFFSET = 32;
private static final int TRANSMIT_TIME_OFFSET = 40;
private static final int NTP_PACKET_SIZE = 48;
private static final int NTP_PORT = 123;
private static final int NTP_MODE_CLIENT = 3;
private static final int NTP_VERSION = 3;
// Number of seconds between Jan 1, 1900 and Jan 1, 1970
// 70 years plus 17 leap days
private static final long OFFSET_1900_TO_1970 = ((365L * 70L) + 17L) * 24L * 60L * 60L;
// system time computed from NTP server response
private long mNtpTime;
// value of SystemClock.elapsedRealtime() corresponding to mNtpTime
private long mNtpTimeReference;
// round trip time in milliseconds
private long mRoundTripTime;
/**
* Sends an SNTP request to the given host and processes the response.
*
* @param host host name of the server.
* @param timeout network timeout in milliseconds.
* @return true if the transaction was successful.
*/
public boolean requestTime(String host, int timeout) {
DatagramSocket socket = null;
try {
socket = new DatagramSocket();
socket.setSoTimeout(timeout);
InetAddress address = InetAddress.getByName(host);
byte[] buffer = new byte[NTP_PACKET_SIZE];
DatagramPacket request = new DatagramPacket(buffer, buffer.length, address, NTP_PORT);
// set mode = 3 (client) and version = 3
// mode is in low 3 bits of first byte
// version is in bits 3-5 of first byte
buffer[0] = NTP_MODE_CLIENT | (NTP_VERSION << 3);
// get current time and write it to the request packet
long requestTime = System.currentTimeMillis();
long requestTicks = SystemClock.elapsedRealtime();
writeTimeStamp(buffer, TRANSMIT_TIME_OFFSET, requestTime);
socket.send(request);
// read the response
DatagramPacket response = new DatagramPacket(buffer, buffer.length);
socket.receive(response);
long responseTicks = SystemClock.elapsedRealtime();
long responseTime = requestTime + (responseTicks - requestTicks);
// extract the results
long originateTime = readTimeStamp(buffer, ORIGINATE_TIME_OFFSET);
long receiveTime = readTimeStamp(buffer, RECEIVE_TIME_OFFSET);
long transmitTime = readTimeStamp(buffer, TRANSMIT_TIME_OFFSET);
long roundTripTime = responseTicks - requestTicks - (transmitTime - receiveTime);
long clockOffset = ((receiveTime - originateTime) + (transmitTime - responseTime))/2;
// save our results - use the times on this side of the network latency
// (response rather than request time)
mNtpTime = responseTime + clockOffset;
mNtpTimeReference = responseTicks;
mRoundTripTime = roundTripTime;
} catch (Exception e) {
Log.d(TAG, "request time failed: " + e);
return false;
} finally {
if (socket != null) {
socket.close();
}
}
return true;
}
/**
* Returns the time computed from the NTP transaction.
*
* @return time value computed from NTP server response.
*/
public long getNtpTime() {
return mNtpTime;
}
/**
* Returns the reference clock value (value of SystemClock.elapsedRealtime())
* corresponding to the NTP time.
*
* @return reference clock corresponding to the NTP time.
*/
public long getNtpTimeReference() {
return mNtpTimeReference;
}
/**
* Returns the round trip time of the NTP transaction
*
* @return round trip time in milliseconds.
*/
public long getRoundTripTime() {
return mRoundTripTime;
}
/**
* Reads an unsigned 32 bit big endian number from the given offset in the buffer.
*/
private long read32(byte[] buffer, int offset) {
byte b0 = buffer[offset];
byte b1 = buffer[offset+1];
byte b2 = buffer[offset+2];
byte b3 = buffer[offset+3];
// convert signed bytes to unsigned values
int i0 = ((b0 & 0x80) == 0x80 ? (b0 & 0x7F) + 0x80 : b0);
int i1 = ((b1 & 0x80) == 0x80 ? (b1 & 0x7F) + 0x80 : b1);
int i2 = ((b2 & 0x80) == 0x80 ? (b2 & 0x7F) + 0x80 : b2);
int i3 = ((b3 & 0x80) == 0x80 ? (b3 & 0x7F) + 0x80 : b3);
return ((long)i0 << 24) + ((long)i1 << 16) + ((long)i2 << 8) + (long)i3;
}
/**
* Reads the NTP time stamp at the given offset in the buffer and returns
* it as a system time (milliseconds since January 1, 1970).
*/
private long readTimeStamp(byte[] buffer, int offset) {
long seconds = read32(buffer, offset);
long fraction = read32(buffer, offset + 4);
return ((seconds - OFFSET_1900_TO_1970) * 1000) + ((fraction * 1000L) / 0x100000000L);
}
/**
* Writes system time (milliseconds since January 1, 1970) as an NTP time stamp
* at the given offset in the buffer.
*/
private void writeTimeStamp(byte[] buffer, int offset, long time) {
long seconds = time / 1000L;
long milliseconds = time - seconds * 1000L;
seconds += OFFSET_1900_TO_1970;
// write seconds in big endian format
buffer[offset++] = (byte)(seconds >> 24);
buffer[offset++] = (byte)(seconds >> 16);
buffer[offset++] = (byte)(seconds >> 8);
buffer[offset++] = (byte)(seconds >> 0);
long fraction = milliseconds * 0x100000000L / 1000L;
// write fraction in big endian format
buffer[offset++] = (byte)(fraction >> 24);
buffer[offset++] = (byte)(fraction >> 16);
buffer[offset++] = (byte)(fraction >> 8);
// low order bits should be random data
buffer[offset++] = (byte)(Math.random() * 255.0);
}
}
3 DrawableUtils
public class DrawableUtils {
private DrawableUtils() {
/* cannot be instantiated */
throw new UnsupportedOperationException("cannot be instantiated");
}
public static void updateLeftDrawable(Context context,
@NonNull TextView textView,
@DrawableRes int drawableLeftRes) {
updateDrawable(context, textView, drawableLeftRes, 0, 0, 0);
}
public static void updateLeftDrawable(@NonNull TextView textView, @NonNull Drawable leftDrawable) {
textView.setCompoundDrawables(leftDrawable, null, null, null);
}
public static void updateTopDrawable(Context context,
@NonNull TextView textView,
@DrawableRes int drawableTopRes) {
updateDrawable(context, textView, 0, drawableTopRes, 0, 0);
}
public static void updateTopDrawable(@NonNull TextView textView, @NonNull Drawable topDrawable) {
textView.setCompoundDrawables(null, topDrawable, null, null);
}
public static void updateRightDrawable(Context context,
@NonNull TextView textView,
@DrawableRes int drawableRightRes) {
updateDrawable(context, textView, 0, 0, drawableRightRes, 0);
}
public static void updateRightDrawable(@NonNull TextView textView, @NonNull Drawable rightDrawable) {
textView.setCompoundDrawables(null, null, rightDrawable, null);
}
public static void updateBottomDrawable(Context context,
@NonNull TextView textView,
@DrawableRes int drawableBottomRes) {
updateDrawable(context, textView, 0, 0, 0, drawableBottomRes);
}
public static void updateBottomDrawable(@NonNull TextView textView, @NonNull Drawable bottomDrawable) {
textView.setCompoundDrawables(null, null, null, bottomDrawable);
}
public static void updateNonDrawable(Context context, @NonNull TextView textView) {
updateDrawable(context, textView, 0, 0, 0, 0);
}
public static void updateDrawable(Context context,
TextView textView,
int drawableLeftRes,
int drawableTopRes,
int drawableRightRes,
int drawableBottomRes) {
Drawable drawableLeft = null;
Drawable drawableRight = null;
Drawable drawableBottom = null;
Drawable drawableTop = null;
if (drawableLeftRes != 0) {
drawableLeft = ContextCompat.getDrawable(context, drawableLeftRes);
drawableLeft.setBounds(0, 0, drawableLeft.getMinimumWidth(), drawableLeft.getMinimumHeight());
}
if (drawableTopRes != 0) {
drawableTop = ContextCompat.getDrawable(context, drawableTopRes);
drawableTop.setBounds(0, 0, drawableTop.getMinimumWidth(), drawableTop.getMinimumHeight());
}
if (drawableRightRes != 0) {
drawableRight = ContextCompat.getDrawable(context, drawableRightRes);
drawableRight.setBounds(0, 0, drawableRight.getMinimumWidth(), drawableRight.getMinimumHeight());
}
if (drawableBottomRes != 0) {
drawableBottom = ContextCompat.getDrawable(context, drawableBottomRes);
drawableBottom.setBounds(0, 0, drawableBottom.getMinimumWidth(), drawableBottom.getMinimumHeight());
}
textView.setCompoundDrawables(drawableLeft, drawableTop, drawableRight, drawableBottom);
}
}
4 DensityUtils
public class DensityUtils {
private DensityUtils() {
/* cannot be instantiated */
throw new UnsupportedOperationException("cannot be instantiated");
}
public static int dp2px(Context context, float dpVal) {
return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
dpVal, context.getResources().getDisplayMetrics());
}
public static int sp2px(Context context, float spVal) {
return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP,
spVal, context.getResources().getDisplayMetrics());
}
public static float px2dp(Context context, float pxVal) {
final float scale = context.getResources().getDisplayMetrics().density;
return (pxVal / scale);
}
public static float px2sp(Context context, float pxVal) {
return (pxVal / context.getResources().getDisplayMetrics().scaledDensity);
}
}
5 SDcardUtils
public class SDCardUtils {
private static final String EXTERNAL_STORAGE_PERMISSION = "android.permission.WRITE_EXTERNAL_STORAGE";
private SDCardUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 判断SDCard是否可用
*
* @return
*/
public static boolean isSDCardEnable() {
return Environment.getExternalStorageState().equals(
Environment.MEDIA_MOUNTED);
}
/**
* 获取SD卡路径
*
* @return
*/
public static String getSDCardPath() {
return Environment.getExternalStorageDirectory().getAbsolutePath()
+ File.separator;
}
/**
* 获取系统存储路径
*
* @return
*/
public static String getRootDirectoryPath() {
return Environment.getRootDirectory().getAbsolutePath();
}
/**
* 获取SD卡的剩余容量 单位byte
*
* @return
*/
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
*/
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;
}
/**
* 获取缓存目录
*
* @param context
* @param dirName
* @return
*/
public static File getCacheDir(Context context, String dirName) {
return getCacheDir(context, true, dirName);
}
private static File getCacheDir(Context context, boolean preferExternal, String dir) {
File appCacheDir = null;
if (preferExternal
&& MEDIA_MOUNTED.equals(Environment.getExternalStorageState())
&& hasExternalStoragePermission(context)) {
appCacheDir = getExternalCacheDir(context, dir);
}
if (appCacheDir == null) {
appCacheDir = context.getCacheDir();
}
if (appCacheDir == null) {
String cacheDirPath = "/data/data/" + context.getPackageName()
+ "/" + dir + "/";
appCacheDir = new File(cacheDirPath);
}
return appCacheDir;
}
private static File getExternalCacheDir(Context context, String dir) {
File dataDir = new File(new File(
Environment.getExternalStorageDirectory(), "Android"), "data");
File appCacheDir = new File(
new File(dataDir, context.getPackageName()), dir);
if (!appCacheDir.exists()) {
if (!appCacheDir.mkdirs()) {
return null;
}
try {
new File(appCacheDir, ".nomedia").createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
return appCacheDir;
}
private static boolean hasExternalStoragePermission(Context context) {
int perm = context
.checkCallingOrSelfPermission(EXTERNAL_STORAGE_PERMISSION);
return perm == PackageManager.PERMISSION_GRANTED;
}
}
6 JSONUtils
public class JSONUtils {
public static String getString(JSONObject response, String key) {
String value = response.optString(key, "");
return value.equals("null") ? "" : value;
}
public static boolean isEmptyArray(JSONArray jsonArray) {
return (jsonArray == null || jsonArray.length() == 0) ? true : false;
}
public static String[] decoding(JSONArray jsonArray) {
if (isEmptyArray(jsonArray)) {
return null;
}
int length = jsonArray.length();
String[] values = new String[length];
for (int i = 0; i < length; i++) {
values[i] = jsonArray.optString(i);
}
return values;
}
public static JSONArray encoding(String[] values) {
if (values == null) {
return null;
}
int length = values.length;
JSONArray jsonArray = new JSONArray();
for (int i = 0; i < length; i++) {
try {
jsonArray.put(i, values[i]);
} catch (JSONException e) {
e.printStackTrace();
}
}
return jsonArray;
}
public static ArrayList<String> decodingList(JSONArray jsonArray) {
if (isEmptyArray(jsonArray)) {
return null;
}
ArrayList<String> list = new ArrayList<String>();
int length = jsonArray.length();
for (int i = 0; i < length; i++) {
String tag = jsonArray.optString(i);
if (!TextUtils.isEmpty(tag)) {
list.add(tag);
}
}
return list;
}
public static JSONArray encodingList(List<String> values) {
if (values == null) {
return null;
}
int size = values.size();
JSONArray jsonArray = new JSONArray();
for (int i = 0; i < size; i++) {
try {
jsonArray.put(i, values.get(i));
} catch (JSONException e) {
e.printStackTrace();
}
}
return jsonArray;
}
public static JSONArray encoding(List<Long> values) {
if (values == null) {
return null;
}
int size = values.size();
JSONArray jsonArray = new JSONArray();
for (int i = 0; i < size; i++) {
try {
jsonArray.put(i, values.get(i));
} catch (JSONException e) {
e.printStackTrace();
}
}
return jsonArray;
}
public static JSONObject getJSONObject(Context context, String assetsFile)
throws JSONException {
String text = readAssetRes(context, assetsFile);
return new JSONObject(text);
}
public static String readAssetRes(Context context, String filepath) {
InputStream is = null;
try {
is = context.getAssets().open(filepath);
int size = is.available();
byte[] buffer = new byte[size];
is.read(buffer);
is.close();
String text = new String(buffer, "UTF-8");
return text;
} catch (IOException e) {
e.printStackTrace();
return "";
} finally {
closeSilently(is);
}
}
private static void closeSilently(Closeable c) {
if (c == null) {
return;
}
try {
c.close();
} catch (Throwable t) {
}
}
}
7 KeyboardUtils
/**
* 软键盘相关辅助类
*/
public class KeyBoardUtils {
private KeyBoardUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 隐藏输入盘
*
* @param activity
*/
public static void collapseSoftInput(Activity activity) {
InputMethodManager inputMethodManager = (InputMethodManager) activity
.getSystemService(Context.INPUT_METHOD_SERVICE);
if (inputMethodManager.isActive()) {
if (activity.getCurrentFocus() != null) {
inputMethodManager.hideSoftInputFromWindow(activity
.getCurrentFocus().getWindowToken(),
InputMethodManager.HIDE_NOT_ALWAYS);
}
}
}
/**
* 显示输入盘
*
* @param context
* @param inputText
*/
public static void showSoftInput(Context context, EditText inputText) {
if (inputText == null) {
return;
}
InputMethodManager imm = (InputMethodManager) context
.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(inputText, InputMethodManager.RESULT_SHOWN);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,
InputMethodManager.HIDE_IMPLICIT_ONLY);
}
/**
* 隐藏输入盘
*
* @param context
* @param inputText
*/
public static void hideSoftInput(Context context, EditText inputText) {
if (inputText == null) {
return;
}
InputMethodManager imm = (InputMethodManager) context
.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(inputText.getWindowToken(), 0);
}
/**
* 设置EditText的光标
*
* @param editText
*/
public static void setFocus(EditText editText) {
editText.requestFocus();
CharSequence text = editText.getText();
if (text instanceof Spannable) {
Selection.setSelection((Spannable) text, text.length());
}
}
/**
* 设置EditText的光标并选择文字
*
* @param editText
*/
public static void setFocusAndSelection(EditText editText) {
editText.requestFocus();
CharSequence text = editText.getText();
if (text instanceof Spannable) {
Selection.selectAll((Spannable) text);
}
}
}
8 ScreenUtils
/**
* 获得屏幕相关的辅助类
*/
public class ScreenUtils {
private ScreenUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
public static int getDrawerWidth(Resources res) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
if (res.getConfiguration().smallestScreenWidthDp >= 600 || res.getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
// device is a tablet
return (int) (320 * res.getDisplayMetrics().density);
} else {
return (int) (res.getDisplayMetrics().widthPixels - (70 * res.getDisplayMetrics().density));
}
} else {
// for devices without smallestScreenWidthDp reference calculate if device screen is over 600 dp
if ((res.getDisplayMetrics().widthPixels / res.getDisplayMetrics().density) >= 600 || res.getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE)
return (int) (320 * res.getDisplayMetrics().density);
else
return (int) (res.getDisplayMetrics().widthPixels - (70 * res.getDisplayMetrics().density));
}
}
/**
* 获取屏幕宽度
*
* @param context
* @return
*/
public static int getScreenWidth(Context context) {
WindowManager wm = (WindowManager) context
.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics outMetrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(outMetrics);
return outMetrics.widthPixels;
}
/**
* 获取屏幕高度
*
* @param context
* @return
*/
public static int getScreenHeight(Context context) {
WindowManager wm = (WindowManager) context
.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics outMetrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(outMetrics);
return outMetrics.heightPixels;
}
/**
* 设置Activity状态栏颜色
*
* @param activity
* @param colorId
*/
public static void setStatusBarColor(Activity activity, int colorId) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
Window window = activity.getWindow();
window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
| View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
window.setStatusBarColor(ContextCompat.getColor(activity, colorId));
}
}
/**
* 获取ActionBar高度
*
* @param context
* @return
*/
@TargetApi(14)
public static int getActionBarHeight(Context context) {
int result = 0;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
TypedValue tv = new TypedValue();
context.getTheme().resolveAttribute(android.R.attr.actionBarSize, tv, true);
result = TypedValue.complexToDimensionPixelSize(tv.data, context.getResources().getDisplayMetrics());
}
return result;
}
/**
* 获取状态栏高度
*
* @param context
* @return
*/
public static int getStatusBarHeight(Context context) {
return getInternalDimensionSize(context.getResources(), "status_bar_height");
}
private static int getInternalDimensionSize(Resources res, String key) {
int result = 0;
int resourceId = res.getIdentifier(key, "dimen", "android");
if (resourceId > 0) {
result = res.getDimensionPixelSize(resourceId);
}
return result;
}
/**
* 获取当前屏幕截图，包含状态栏
*
* @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 bitmap = Bitmap.createBitmap(bmp, 0, 0, width, height);
view.destroyDrawingCache();
return bitmap;
}
/**
* 获取当前屏幕截图，不包含状态栏
*
* @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 bitmap = Bitmap.createBitmap(bmp, 0, statusBarHeight, width, height - statusBarHeight);
view.destroyDrawingCache();
return bitmap;
}
}