Skip to content

A
AndroidUtilCode

xiaoxuan_i809 / AndroidUtilCode
与 Fork 源项目一致

从无法访问的项目Fork

通知 1
Star 0
Fork 0
A
AndroidUtilCode

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 8aae7626 编写于 作者: B blankj
浏览文件
操作

modify md

上级 504be3d3
展开全部 隐藏空白更改
内联 并排
Showing with 2481 addition and 1645 deletion
md/about_app.md
浏览文件 @ 8aae7626
# App相关
### 安装指定路径下的Apk
``` java
import android.app.ActivityManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
/**
* 安装指定路径下的Apk
* <p>根据路径名是否符合和文件是否存在判断是否安装成功
* <p>更好的做法应该是startActivityForResult回调判断是否安装成功比较妥当
* <p>这里做不了回调，后续自己做处理
* <pre>
* author: Blankj
* blog : http://blankj.com
* time : 2016/8/2
* desc : App相关的工具类
* </pre>
*/
public static boolean installApp(Context context, String filePath) {
if (filePath != null && filePath.length() > 4
&& filePath.toLowerCase().substring(filePath.length() - 4).equals(".apk")) {
public class AppUtils {
private AppUtils() {
throw new UnsupportedOperationException("u can't fuck me...");
}
/**
* 安装App
* <p>根据路径安装App</p>
*
* @param context 上下文
* @param filePath 文件路径
*/
public static void installApp(Context context, String filePath) {
installApp(context, new File(filePath));
}
/**
* 安装App
* <p>根据文件安装App</p>
*
* @param context 上下文
* @param file 文件
*/
public static void installApp(Context context, File file) {
Intent intent = new Intent(Intent.ACTION_VIEW);
File file = new File(filePath);
if (file.exists() && file.isFile() && file.length() > 0) {
intent.setDataAndType(Uri.fromFile(file), "application/vnd.android.package-archive");
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(intent);
return true;
}
intent.setDataAndType(Uri.fromFile(file), "application/vnd.android.package-archive");
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(intent);
}
return false;
}
```
### 卸载指定包名的App
``` java
/**
* 卸载指定包名的App
* <p>这里卸载成不成功只判断了packageName是否为空
* <p>如果要根据是否卸载成功应该用startActivityForResult回调判断是否还存在比较妥当
* <p>这里做不了回调，后续自己做处理
*/
public boolean uninstallApp(Context context, String packageName) {
if (!TextUtils.isEmpty(packageName)) {
/**
* 卸载指定包名的App
*
* @param context 上下文
* @param packageName 包名
*/
public void uninstallApp(Context context, String packageName) {
Intent intent = new Intent(Intent.ACTION_DELETE);
intent.setData(Uri.parse("package:" + packageName));
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(intent);
return true;
}
return false;
}
```
### 获取当前App信息
``` java
/**
* 封装App信息的Bean类
*/
public static class AppInfo {
private String name;
private Drawable icon;
private String packagName;
private String versionName;
private int versionCode;
private boolean isSD;
private boolean isUser;
public Drawable getIcon() {
return icon;
}
/**
* 封装App信息的Bean类
*/
public static class AppInfo {
public void setIcon(Drawable icon) {
this.icon = icon;
}
private String name;
private Drawable icon;
private String packageName;
private String versionName;
private int versionCode;
private boolean isSD;
private boolean isUser;
public boolean isSD() {
return isSD;
}
public Drawable getIcon() {
return icon;
}
public void setSD(boolean SD) {
isSD = SD;
}
public void setIcon(Drawable icon) {
this.icon = icon;
}
public boolean isUser() {
return isUser;
}
public boolean isSD() {
return isSD;
}
public void setUser(boolean user) {
isUser = user;
}
public void setSD(boolean SD) {
isSD = SD;
}
public String getName() {
return name;
}
public boolean isUser() {
return isUser;
}
public void setName(String name) {
this.name = name;
}
public void setUser(boolean user) {
isUser = user;
}
public String getPackagName() {
return packagName;
}
public String getName() {
return name;
}
public void setPackagName(String packagName) {
this.packagName = packagName;
}
public void setName(String name) {
this.name = name;
}
public int getVersionCode() {
return versionCode;
}
public String getPackageName() {
return packageName;
}
public void setVersionCode(int versionCode) {
this.versionCode = versionCode;
}
public void setPackageName(String packagName) {
this.packageName = packagName;
}
public String getVersionName() {
return versionName;
}
public int getVersionCode() {
return versionCode;
}
public void setVersionName(String versionName) {
this.versionName = versionName;
}
public void setVersionCode(int versionCode) {
this.versionCode = versionCode;
}
/**
* @param name 名称
* @param icon 图标
* @param packagName 包名
* @param versionName 版本号
* @param versionCode 版本Code
* @param isSD 是否安装在SD卡
* @param isUser 是否是用户程序
*/
public AppInfo(String name, Drawable icon, String packagName,
String versionName, int versionCode, boolean isSD, boolean isUser) {
this.setName(name);
this.setIcon(icon);
this.setPackagName(packagName);
this.setVersionName(versionName);
this.setVersionCode(versionCode);
this.setSD(isSD);
this.setUser(isUser);
}
public String getVersionName() {
return versionName;
}
public void setVersionName(String versionName) {
this.versionName = versionName;
}
/**
* @param name 名称
* @param icon 图标
* @param packageName 包名
* @param versionName 版本号
* @param versionCode 版本Code
* @param isSD 是否安装在SD卡
* @param isUser 是否是用户程序
*/
public AppInfo(String name, Drawable icon, String packageName,
String versionName, int versionCode, boolean isSD, boolean isUser) {
this.setName(name);
this.setIcon(icon);
this.setPackageName(packageName);
this.setVersionName(versionName);
this.setVersionCode(versionCode);
this.setSD(isSD);
this.setUser(isUser);
}
/*@Override
public String toString() {
......@@ -144,127 +165,149 @@ public static class AppInfo {
+ isSD() + "\n"
+ isUser() + "\n";
}*/
}
}
/**
* 获取当前App信息
* <p>AppInfo（名称，图标，包名，版本号，版本Code，是否安装在SD卡，是否是用户程序）
*/
public static AppInfo getAppInfo(Context context) {
PackageManager pm = context.getPackageManager();
PackageInfo pi = null;
try {
pi = pm.getPackageInfo(context.getApplicationContext().getPackageName(), 0);
} catch (PackageManager.NameNotFoundException e) {
e.printStackTrace();
/**
* 获取当前App信息
* <p>AppInfo（名称，图标，包名，版本号，版本Code，是否安装在SD卡，是否是用户程序）</p>
*
* @param context 上下文
* @return 当前应用的AppInfo
*/
public static AppInfo getAppInfo(Context context) {
PackageManager pm = context.getPackageManager();
PackageInfo pi = null;
try {
pi = pm.getPackageInfo(context.getApplicationContext().getPackageName(), 0);
} catch (PackageManager.NameNotFoundException e) {
e.printStackTrace();
}
return pi != null ? getBean(pm, pi) : null;
}
return pi != null ? getBean(pm, pi) : null;
}
/**
* 得到AppInfo的Bean
*/
private static AppInfo getBean(PackageManager pm, PackageInfo pi) {
ApplicationInfo ai = pi.applicationInfo;
String name = ai.loadLabel(pm).toString();
Drawable icon = ai.loadIcon(pm);
String packageName = pi.packageName;
String versionName = pi.versionName;
int versionCode = pi.versionCode;
boolean isSD = (ApplicationInfo.FLAG_SYSTEM & ai.flags) != ApplicationInfo.FLAG_SYSTEM;
boolean isUser = (ApplicationInfo.FLAG_SYSTEM & ai.flags) != ApplicationInfo.FLAG_SYSTEM;
return new AppInfo(name, icon, packageName, versionName, versionCode, isSD, isUser);
}
```
/**
* 得到AppInfo的Bean
*
* @param pm 包的管理
* @param pi 包的信息
* @return AppInfo类
*/
private static AppInfo getBean(PackageManager pm, PackageInfo pi) {
ApplicationInfo ai = pi.applicationInfo;
String name = ai.loadLabel(pm).toString();
Drawable icon = ai.loadIcon(pm);
String packageName = pi.packageName;
String versionName = pi.versionName;
int versionCode = pi.versionCode;
boolean isSD = (ApplicationInfo.FLAG_SYSTEM & ai.flags) != ApplicationInfo.FLAG_SYSTEM;
boolean isUser = (ApplicationInfo.FLAG_SYSTEM & ai.flags) != ApplicationInfo.FLAG_SYSTEM;
return new AppInfo(name, icon, packageName, versionName, versionCode, isSD, isUser);
}
### 获取所有已安装App信息
```
/**
* 获取所有已安装App信息
* <p>AppInfo（名称，图标，包名，版本号，版本Code，是否安装在SD卡，是否是用户程序）
* <p>依赖上面的getBean方法
*/
public static List<AppInfo> getAllAppsInfo(Context context) {
List<AppInfo> list = new ArrayList<>();
PackageManager pm = context.getPackageManager();
// 获取系统中安装的所有软件信息
List<PackageInfo> installedPackages = pm.getInstalledPackages(0);
for (PackageInfo pi : installedPackages) {
if (pi != null) {
list.add(getBean(pm, pi));
/**
* 获取所有已安装App信息
* <p>AppInfo（名称，图标，包名，版本号，版本Code，是否安装在SD卡，是否是用户程序）</p>
* <p>依赖上面的getBean方法</p>
*
* @param context 上下文
* @return 所有已安装的AppInfo列表
*/
public static List<AppInfo> getAllAppsInfo(Context context) {
List<AppInfo> list = new ArrayList<>();
PackageManager pm = context.getPackageManager();
// 获取系统中安装的所有软件信息
List<PackageInfo> installedPackages = pm.getInstalledPackages(0);
for (PackageInfo pi : installedPackages) {
if (pi != null) {
list.add(getBean(pm, pi));
}
}
return list;
}
return list;
}
```
### 打开指定包名的App
```
/**
* 打开指定包名的App
*/
public static boolean openAppByPackageName(Context context, String packageName) {
if (!TextUtils.isEmpty(packageName)) {
PackageManager pm = context.getPackageManager();
Intent launchIntentForPackage = pm.getLaunchIntentForPackage(packageName);
if (launchIntentForPackage != null) {
context.startActivity(launchIntentForPackage);
/**
* 根据包名获取意图
*
* @param context 上下文
* @param packageName 包名
* @return 意图
*/
private static Intent getIntentByPackageName(Context context, String packageName) {
return context.getPackageManager().getLaunchIntentForPackage(packageName);
}
/**
* 根据包名判断App是否安装
*
* @param context 上下文
* @param packageName 包名
* @return true: 已安装<br>false: 未安装
*/
public static boolean isInstallApp(Context context, String packageName) {
return getIntentByPackageName(context, packageName) != null;
}
/**
* 打开指定包名的App
*
* @param context 上下文
* @param packageName 包名
* @return true: 打开成功<br>false: 打开失败
*/
public static boolean openAppByPackageName(Context context, String packageName) {
Intent intent = getIntentByPackageName(context, packageName);
if (intent != null) {
context.startActivity(intent);
return true;
}
return false;
}
return false;
}
```
### 打开指定包名的App应用信息界面
``` java
/**
* 打开指定包名的App应用信息界面
*/
public static boolean openAppInfo(Context context, String packageName) {
if (!TextUtils.isEmpty(packageName)) {
/**
* 打开指定包名的App应用信息界面
*
* @param context 上下文
* @param packageName 包名
*/
public static void openAppInfo(Context context, String packageName) {
Intent intent = new Intent();
intent.setAction("android.settings.APPLICATION_DETAILS_SETTINGS");
intent.setData(Uri.parse("package:" + packageName));
context.startActivity(intent);
return true;
}
return false;
}
```
### 可用来做App信息分享
``` java
/**
* 可用来做App信息分享
*/
public static void shareAppInfo(Context context, String info) {
if (!TextUtils.isEmpty(info)) {
/**
* 可用来做App信息分享
*
* @param context 上下文
* @param info 分享信息
*/
public static void shareAppInfo(Context context, String info) {
Intent intent = new Intent(Intent.ACTION_SEND);
intent.setType("text/plain");
intent.putExtra(Intent.EXTRA_TEXT, info);
context.startActivity(intent);
}
}
```
### 判断当前App处于前台还是后台
``` java
/**
* 判断当前App处于前台还是后台
* <p>需添加权限 android.permission.GET_TASKS
* <p>并且必须是系统应用该方法才有效
*/
public static boolean isAppBackground(Context context) {
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
@SuppressWarnings("deprecation")
List<ActivityManager.RunningTaskInfo> tasks = am.getRunningTasks(1);
if (!tasks.isEmpty()) {
ComponentName topActivity = tasks.get(0).topActivity;
if (!topActivity.getPackageName().equals(context.getPackageName())) {
return true;
/**
* 判断当前App处于前台还是后台
* <p>需添加权限 android.permission.GET_TASKS</p>
* <p>并且必须是系统应用该方法才有效</p>
*
* @param context 上下文
* @return true: 后台<br>false: 前台
*/
public static boolean isAppBackground(Context context) {
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
@SuppressWarnings("deprecation")
List<ActivityManager.RunningTaskInfo> tasks = am.getRunningTasks(1);
if (!tasks.isEmpty()) {
ComponentName topActivity = tasks.get(0).topActivity;
if (!topActivity.getPackageName().equals(context.getPackageName())) {
return true;
}
}
return false;
}
return false;
}
```
```
\ No newline at end of file
md/about_device.md
浏览文件 @ 8aae7626
# 设备相关
### 获取设备MAC地址
``` java
import android.content.Context;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.os.Environment;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
/**
* 获取设备MAC地址
* <p>需添加权限 android.permission.ACCESS_WIFI_STATE
* <pre>
* author: Blankj
* blog : http://blankj.com
* time : 2016/8/1
* desc : 设备相关的工具类
* </pre>
*/
public static String getMacAddress(Context context) {
String macAddress;
WifiManager wifi = (WifiManager) context
.getSystemService(Context.WIFI_SERVICE);
WifiInfo info = wifi.getConnectionInfo();
macAddress = info.getMacAddress();
if (null == macAddress) {
return "";
public class DeviceUtils {
private DeviceUtils() {
throw new UnsupportedOperationException("u can't fuck me...");
}
macAddress = macAddress.replace(":", "");
return macAddress;
}
```
### 获取设备厂商，如Xiaomi
``` java
/**
* 获取设备厂商，如Xiaomi
*/
public static String getManufacturer() {
String MANUFACTURER = Build.MANUFACTURER;
return MANUFACTURER;
}
```
/**
* 获取设备MAC地址
* <p>需添加权限 android.permission.ACCESS_WIFI_STATE</p>
*
* @param context 上下文
* @return MAC地址
*/
public static String getMacAddress(Context context) {
WifiManager wifi = (WifiManager) context
.getSystemService(Context.WIFI_SERVICE);
WifiInfo info = wifi.getConnectionInfo();
String macAddress = info.getMacAddress().replace(":", "");
return macAddress == null ? "" : macAddress;
}
### 获取设备型号，如MI2SC
``` java
/**
* 获取设备型号，如MI2SC
*/
public static String getModel() {
String model = Build.MODEL;
if (model != null) {
model = model.trim().replaceAll("\\s*", "");
} else {
model = "";
/**
* 获取设备MAC地址
* <p>需添加权限 android.permission.ACCESS_WIFI_STATE</p>
*
* @return MAC地址
*/
public static String getMacAddress() {
String macAddress = null;
try {
Process pp = Runtime.getRuntime().exec("cat /sys/class/net/wlan0/address");
InputStreamReader ir = new InputStreamReader(pp.getInputStream());
LineNumberReader reader = new LineNumberReader(ir);
macAddress = reader.readLine().replace(":", "");
} catch (IOException ex) {
ex.printStackTrace();
}
return macAddress == null ? "" : macAddress;
}
return model;
}
```
### 获取设备SD卡是否可用
``` java
/**
* 获取设备SD卡是否可用
*/
public static boolean isSDCardEnable() {
return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
}
```
/**
* 获取设备厂商，如Xiaomi
*
* @return 设备厂商
*/
public static String getManufacturer() {
String MANUFACTURER = Build.MANUFACTURER;
return MANUFACTURER;
}
### 获取设备SD卡路径
```
/**
* 获取设备SD卡路径
* <p>一般是/storage/emulated/0/
*/
public static String getSDCardPath() {
return Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator;
/**
* 获取设备型号，如MI2SC
*
* @return 设备型号
*/
public static String getModel() {
String model = Build.MODEL;
if (model != null) {
model = model.trim().replaceAll("\\s*", "");
} else {
model = "";
}
return model;
}
/**
* 获取设备SD卡是否可用
*
* @return true : 可用<br>false : 不可用
*/
public static boolean isSDCardEnable() {
return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
}
/**
* 获取设备SD卡路径
* <p>一般是/storage/emulated/0/</p>
*
* @return SD卡路径
*/
public static String getSDCardPath() {
return Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator;
}
}
```
md/about_encode.md
浏览文件 @ 8aae7626
# 加解密相关
### MD5加密
# 编码解码相关
``` java
/**
* MD5加密
*
* @param data 明文字符串
* @return 密文
*/
public static String getMD5(String data) {
return getMD5(data.getBytes());
}
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
/**
* MD5加密
*
* @param data 明文字符串
* @param salt 盐
* @return 密文
* <pre>
* author: Blankj
* blog : http://blankj.com
* time : 2016/8/7
* desc : 编码解码相关工具类
* </pre>
*/
public static String getMD5(String data, String salt) {
return bytes2Hex(encryptMD5((data + salt).getBytes()));
}
public class EncodeUtils {
/**
* MD5加密
*
* @param data 明文字节数组
* @return 密文
*/
public static String getMD5(byte[] data) {
return bytes2Hex(encryptMD5(data));
}
/**
* MD5加密
*
* @param data 明文字节数组
* @param salt 盐字节数组
* @return 密文
*/
public static String getMD5(byte[] data, byte[] salt) {
byte[] dataSalt = new byte[data.length + salt.length];
System.arraycopy(data, 0, dataSalt, 0, data.length);
System.arraycopy(salt, 0, dataSalt, data.length, salt.length);
return bytes2Hex(encryptMD5(dataSalt));
}
private EncodeUtils() {
throw new UnsupportedOperationException("u can't fuck me...");
}
/**
* MD5加密
*
* @param data 明文字节数组
* @return 密文字节数组
*/
public static byte[] encryptMD5(byte[] data) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(data);
return md.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
/**
* 以UTF-8编码字符串
* <p>若想自己指定字符集,可以使用encode(String string, String charset)方法</p>
*
* @param string 要编码的字符
* @return 编码为UTF-8的字符串
*/
public static String encodeUTF8(String string) {
return encode(string, "UTF-8");
}
return new byte[0];
}
/**
* 获取文件的MD5校验码
*
* @param filePath 文件路径
* @return 文件的MD5校验码
*/
public static String getMD5File(String filePath) {
FileInputStream in = null;
try {
MessageDigest md = MessageDigest.getInstance("MD5");
in = new FileInputStream(filePath);
int len;
byte[] buffer = new byte[1024];
while ((len = in.read(buffer)) != -1) {
md.update(buffer, 0, len);
}
return bytes2Hex(md.digest());
} catch (NoSuchAlgorithmException | IOException e) {
e.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException ignored) {
}
/**
* 字符编码
* <p>若系统不支持指定的编码字符集,则直接将string原样返回</p>
*
* @param string 要编码的字符
* @param charset 字符集
* @return 编码为字符集的字符串
*/
public static String encode(String string, String charset) {
try {
return URLEncoder.encode(string, charset);
} catch (UnsupportedEncodingException e) {
return string;
}
}
return "";
}
```
### SHA加密
```
/**
* SHA加密
*
* @param data 明文字符串
* @return 密文
*/
public static String getSHA(String data) {
return getSHA(data.getBytes());
}
/**
* SHA加密
*
* @param data 明文字节数组
* @return 密文
*/
public static String getSHA(byte[] data) {
return bytes2Hex(encryptSHA(data));
}
/**
* SHA加密
*
* @param data 明文字节数组
* @return 密文字节数组
*/
public static byte[] encryptSHA(byte[] data) {
try {
MessageDigest md = MessageDigest.getInstance("SHA");
md.update(data);
return md.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
/**
* 以UTF-8解码字符串
* <p>若想自己指定字符集,可以使用# {decode(String string, String charset)}方法</p>
*
* @param string 要解码的字符
* @return 解码为UTF-8的字符串
*/
public static String decodeUTF8(String string) {
return decode(string, "UTF-8");
}
return new byte[0];
}
/**
* 一个byte转为2个hex字符
*/
public static String bytes2Hex(byte[] src) {
char[] res = new char[src.length * 2];
final char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
for (int i = 0, j = 0; i < src.length; i++) {
res[j++] = hexDigits[src[i] >>> 4 & 0x0f];
res[j++] = hexDigits[src[i] & 0x0f];
/**
* 字符解码
* <p>若系统不支持指定的解码字符集,则直接将string原样返回</p>
*
* @param string 要解码的字符
* @param charset 字符集
* @return 解码为字符集的字符串
*/
public static String decode(String string, String charset) {
try {
return URLDecoder.decode(string, charset);
} catch (UnsupportedEncodingException e) {
return string;
}
}
return new String(res);
}
```
md/about_encrypt.md
浏览文件 @ 8aae7626
# 加解密相关
### MD5加密
``` java
/**
* MD5加密
*
* @param data 明文字符串
* @return 密文
*/
public static String getMD5(String data) {
return getMD5(data.getBytes());
}
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
/**
* MD5加密
*
* @param data 明文字符串
* @param salt 盐
* @return 密文
* <pre>
* author: Blankj
* blog : http://blankj.com
* time : 2016/8/2
* desc : 加密相关的工具类
* </pre>
*/
public static String getMD5(String data, String salt) {
return bytes2Hex(encryptMD5((data + salt).getBytes()));
}
public class EncryptUtils {
/**
* MD5加密
*
* @param data 明文字节数组
* @return 密文
*/
public static String getMD5(byte[] data) {
return bytes2Hex(encryptMD5(data));
}
private EncryptUtils() {
throw new UnsupportedOperationException("u can't fuck me...");
}
/**
* MD5加密
*
* @param data 明文字节数组
* @param salt 盐字节数组
* @return 密文
*/
public static String getMD5(byte[] data, byte[] salt) {
byte[] dataSalt = new byte[data.length + salt.length];
System.arraycopy(data, 0, dataSalt, 0, data.length);
System.arraycopy(salt, 0, dataSalt, data.length, salt.length);
return bytes2Hex(encryptMD5(dataSalt));
}
/**
* MD5加密
*
* @param data 明文字符串
* @return 密文
*/
public static String getMD5(String data) {
return getMD5(data.getBytes());
}
/**
* MD5加密
*
* @param data 明文字节数组
* @return 密文字节数组
*/
public static byte[] encryptMD5(byte[] data) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(data);
return md.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
/**
* MD5加密
*
* @param data 明文字符串
* @param salt 盐
* @return 密文
*/
public static String getMD5(String data, String salt) {
return bytes2Hex(encryptMD5((data + salt).getBytes()));
}
return new byte[0];
}
/**
* 获取文件的MD5校验码
*
* @param filePath 文件路径
* @return 文件的MD5校验码
*/
public static String getMD5File(String filePath) {
FileInputStream in = null;
try {
MessageDigest md = MessageDigest.getInstance("MD5");
in = new FileInputStream(filePath);
int len;
byte[] buffer = new byte[1024];
while ((len = in.read(buffer)) != -1) {
md.update(buffer, 0, len);
/**
* MD5加密
*
* @param data 明文字节数组
* @return 密文
*/
public static String getMD5(byte[] data) {
return bytes2Hex(encryptMD5(data));
}
/**
* MD5加密
*
* @param data 明文字节数组
* @param salt 盐字节数组
* @return 密文
*/
public static String getMD5(byte[] data, byte[] salt) {
byte[] dataSalt = new byte[data.length + salt.length];
System.arraycopy(data, 0, dataSalt, 0, data.length);
System.arraycopy(salt, 0, dataSalt, data.length, salt.length);
return bytes2Hex(encryptMD5(dataSalt));
}
/**
* MD5加密
*
* @param data 明文字节数组
* @return 密文字节数组
*/
public static byte[] encryptMD5(byte[] data) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(data);
return md.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return bytes2Hex(md.digest());
} catch (NoSuchAlgorithmException | IOException e) {
e.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException ignored) {
return new byte[0];
}
/**
* 获取文件的MD5校验码
*
* @param filePath 文件路径
* @return 文件的MD5校验码
*/
public static String getMD5File(String filePath) {
return getMD5File(new File(filePath));
}
/**
* 获取文件的MD5校验码
*
* @param file 文件
* @return 文件的MD5校验码
*/
public static String getMD5File(File file) {
FileInputStream in = null;
try {
in = new FileInputStream(file);
FileChannel channel = in.getChannel();
MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, file.length());
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(buffer);
return bytes2Hex(md.digest());
} catch (NoSuchAlgorithmException | IOException e) {
e.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException ignored) {
}
}
}
return "";
}
return "";
}
```
### SHA加密
```
/**
* SHA加密
*
* @param data 明文字符串
* @return 密文
*/
public static String getSHA(String data) {
return getSHA(data.getBytes());
}
/**
* SHA加密
*
* @param data 明文字符串
* @return 密文
*/
public static String getSHA(String data) {
return getSHA(data.getBytes());
}
/**
* SHA加密
*
* @param data 明文字节数组
* @return 密文
*/
public static String getSHA(byte[] data) {
return bytes2Hex(encryptSHA(data));
}
/**
* SHA加密
*
* @param data 明文字节数组
* @return 密文
*/
public static String getSHA(byte[] data) {
return bytes2Hex(encryptSHA(data));
}
/**
* SHA加密
*
* @param data 明文字节数组
* @return 密文字节数组
*/
public static byte[] encryptSHA(byte[] data) {
try {
MessageDigest md = MessageDigest.getInstance("SHA");
md.update(data);
return md.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
/**
* SHA加密
*
* @param data 明文字节数组
* @return 密文字节数组
*/
public static byte[] encryptSHA(byte[] data) {
try {
MessageDigest md = MessageDigest.getInstance("SHA");
md.update(data);
return md.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return new byte[0];
}
return new byte[0];
}
/**
* 一个byte转为2个hex字符
*/
public static String bytes2Hex(byte[] src) {
char[] res = new char[src.length * 2];
final char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
for (int i = 0, j = 0; i < src.length; i++) {
res[j++] = hexDigits[src[i] >>> 4 & 0x0f];
res[j++] = hexDigits[src[i] & 0x0f];
/**
* 一个byte转为2个hex字符
*
* @param src byte数组
* @return 16进制大写字符串
*/
public static String bytes2Hex(byte[] src) {
char[] res = new char[src.length << 1];
final char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
for (int i = 0, j = 0; i < src.length; i++) {
res[j++] = hexDigits[src[i] >>> 4 & 0x0f];
res[j++] = hexDigits[src[i] & 0x0f];
}
return new String(res);
}
return new String(res);
}
```
md/about_keyboard.md
浏览文件 @ 8aae7626
# 键盘相关
### 避免输入法面板遮挡
``` java
// 在manifest.xml中activity中设置
android:windowSoftInputMode="stateVisible|adjustResize"
```
import android.app.Activity;
import android.content.Context;
import android.util.Log;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;
### 动态隐藏软键盘
``` java
/**
* 动态隐藏软键盘
*/
public static void hideSoftInput(Activity activity) {
View view = activity.getWindow().peekDecorView();
if (view != null) {
InputMethodManager inputmanger = (InputMethodManager) activity
.getSystemService(Context.INPUT_METHOD_SERVICE);
inputmanger.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
}
* <pre>
* author: Blankj
* blog : http://blankj.com
* time : 2016/8/2
* desc : 键盘相关的工具类
* </pre>
*/
public class KeyboardUtils {
/**
* 动态隐藏软键盘
*/
public static void hideSoftInput(Context context, EditText edit) {
edit.clearFocus();
InputMethodManager inputmanger = (InputMethodManager) context
.getSystemService(Context.INPUT_METHOD_SERVICE);
inputmanger.hideSoftInputFromWindow(edit.getWindowToken(), 0);
}
```
private KeyboardUtils() {
throw new UnsupportedOperationException("u can't fuck me...");
}
### 点击屏幕空白区域隐藏软键盘
``` java
/**
* 点击屏幕空白区域隐藏软键盘（方法0）
* <p>在onTouch中处理，未获焦点则隐藏
* <p>参照以下注释代码
*/
public static void clickBlankArea2HideSoftInput0() {
Log.i("tips", "U should copy the following code.");
/*
@Override
public boolean onTouchEvent (MotionEvent event){
if (null != this.getCurrentFocus()) {
InputMethodManager mInputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
return mInputMethodManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), 0);
/**
* 动态隐藏软键盘
*
* @param activity activity
*/
public static void hideSoftInput(Activity activity) {
View view = activity.getWindow().peekDecorView();
if (view != null) {
InputMethodManager inputmanger = (InputMethodManager) activity
.getSystemService(Context.INPUT_METHOD_SERVICE);
inputmanger.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
return super.onTouchEvent(event);
}
*/
}
/**
* 点击屏幕空白区域隐藏软键盘（方法1）
* <p>根据EditText所在坐标和用户点击的坐标相对比，来判断是否隐藏键盘
* <p>需重写dispatchTouchEvent
* <p>参照以下注释代码
*/
public static void clickBlankArea2HideSoftInput1() {
Log.i("tips", "U should copy the following code.");
/*
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
View v = getCurrentFocus();
if (isShouldHideKeyboard(v, ev)) {
hideKeyboard(v.getWindowToken());
/**
* 动态隐藏软键盘
*
* @param context 上下文
* @param edit 输入框
*/
public static void hideSoftInput(Context context, EditText edit) {
edit.clearFocus();
InputMethodManager inputmanger = (InputMethodManager) context
.getSystemService(Context.INPUT_METHOD_SERVICE);
inputmanger.hideSoftInputFromWindow(edit.getWindowToken(), 0);
}
/**
* 点击屏幕空白区域隐藏软键盘（方法1）
* <p>在onTouch中处理，未获焦点则隐藏</p>
* <p>参照以下注释代码</p>
*/
public static void clickBlankArea2HideSoftInput0() {
Log.i("tips", "U should copy the following code.");
/*
@Override
public boolean onTouchEvent (MotionEvent event){
if (null != this.getCurrentFocus()) {
InputMethodManager mInputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
return mInputMethodManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), 0);
}
return super.onTouchEvent(event);
}
return super.dispatchTouchEvent(ev);
*/
}
// 根据EditText所在坐标和用户点击的坐标相对比，来判断是否隐藏键盘
private boolean isShouldHideKeyboard(View v, MotionEvent event) {
if (v != null && (v instanceof EditText)) {
int[] l = {0, 0};
v.getLocationInWindow(l);
int left = l[0],
top = l[1],
bottom = top + v.getHeight(),
right = left + v.getWidth();
return !(event.getX() > left && event.getX() < right
&& event.getY() > top && event.getY() < bottom);
/**
* 点击屏幕空白区域隐藏软键盘（方法2）
* <p>根据EditText所在坐标和用户点击的坐标相对比，来判断是否隐藏键盘</p>
* <p>需重写dispatchTouchEvent</p>
* <p>参照以下注释代码</p>
*/
public static void clickBlankArea2HideSoftInput1() {
Log.i("tips", "U should copy the following code.");
/*
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
View v = getCurrentFocus();
if (isShouldHideKeyboard(v, ev)) {
hideKeyboard(v.getWindowToken());
}
}
return super.dispatchTouchEvent(ev);
}
return false;
}
// 获取InputMethodManager，隐藏软键盘
private void hideKeyboard(IBinder token) {
if (token != null) {
InputMethodManager im = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
im.hideSoftInputFromWindow(token, InputMethodManager.HIDE_NOT_ALWAYS);
// 根据EditText所在坐标和用户点击的坐标相对比，来判断是否隐藏键盘
private boolean isShouldHideKeyboard(View v, MotionEvent event) {
if (v != null && (v instanceof EditText)) {
int[] l = {0, 0};
v.getLocationInWindow(l);
int left = l[0],
top = l[1],
bottom = top + v.getHeight(),
right = left + v.getWidth();
return !(event.getX() > left && event.getX() < right
&& event.getY() > top && event.getY() < bottom);
}
return false;
}
// 获取InputMethodManager，隐藏软键盘
private void hideKeyboard(IBinder token) {
if (token != null) {
InputMethodManager im = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
im.hideSoftInputFromWindow(token, InputMethodManager.HIDE_NOT_ALWAYS);
}
}
*/
}
*/
}
```
### 动态显示软键盘
``` java
/**
* 动态显示软键盘
*/
public static void showSoftInput(Context context, EditText edit) {
edit.setFocusable(true);
edit.setFocusableInTouchMode(true);
edit.requestFocus();
InputMethodManager inputManager = (InputMethodManager) context
.getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.showSoftInput(edit, 0);
}
```
/**
* 动态显示软键盘
*
* @param context 上下文
* @param edit 输入框
*/
public static void showSoftInput(Context context, EditText edit) {
edit.setFocusable(true);
edit.setFocusableInTouchMode(true);
edit.requestFocus();
InputMethodManager inputManager = (InputMethodManager) context
.getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.showSoftInput(edit, 0);
}
### 切换键盘显示与否状态
``` java
/**
* 切换键盘显示与否状态
*/
public static void toggleSoftInput(Context context, EditText edit) {
edit.setFocusable(true);
edit.setFocusableInTouchMode(true);
edit.requestFocus();
InputMethodManager inputManager = (InputMethodManager) context
.getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
/**
* 切换键盘显示与否状态
*
* @param context 上下文
* @param edit 输入框
*/
public static void toggleSoftInput(Context context, EditText edit) {
edit.setFocusable(true);
edit.setFocusableInTouchMode(true);
edit.requestFocus();
InputMethodManager inputManager = (InputMethodManager) context
.getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
}
}
```
md/about_network.md
浏览文件 @ 8aae7626
# 网络相关
### 打开网络设置界面
``` java
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.telephony.TelephonyManager;
/**
* 打开网络设置界面
* <p>3.0以下打开设置界面
* <pre>
* author: Blankj
* blog : http://blankj.com
* time : 2016/8/2
* desc : 网络相关的工具类
* </pre>
*/
public static void openWirelessSettings(Context context) {
if (android.os.Build.VERSION.SDK_INT > 10) {
context.startActivity(new Intent(android.provider.Settings.ACTION_SETTINGS));
} else {
context.startActivity(new Intent(android.provider.Settings.ACTION_WIRELESS_SETTINGS));
public class NetworkUtils {
private NetworkUtils() {
throw new UnsupportedOperationException("u can't fuck me...");
}
}
```
### 判断网络是否可用
``` java
/**
* 获取活动网路信息
*/
private static NetworkInfo getActiveNetworkInfo(Context context) {
ConnectivityManager cm = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
return cm.getActiveNetworkInfo();
}
public static final int NETWORK_WIFI = 1; // wifi network
public static final int NETWORK_4G = 4; // "4G" networks
public static final int NETWORK_3G = 3; // "3G" networks
public static final int NETWORK_2G = 2; // "2G" networks
public static final int NETWORK_UNKNOWN = 5; // unknown network
public static final int NETWORK_NO = -1; // no network
/**
* 判断网络是否可用
* <p>需添加权限 android.permission.ACCESS_NETWORK_STATE
*/
public static boolean isAvailable(Context context) {
NetworkInfo info = getActiveNetworkInfo(context);
return info != null && info.isAvailable();
}
```
private static final int NETWORK_TYPE_GSM = 16;
private static final int NETWORK_TYPE_TD_SCDMA = 17;
private static final int NETWORK_TYPE_IWLAN = 18;
### 判断网络是否连接
``` java
/**
* 判断网络是否连接
* <p>需添加权限 android.permission.ACCESS_NETWORK_STATE
*/
public static boolean isConnected(Context context) {
NetworkInfo info = getActiveNetworkInfo(context);
return info != null && info.isConnected();
}
```
/**
* 打开网络设置界面
* <p>3.0以下打开设置界面</p>
*
* @param context 上下文
*/
public static void openWirelessSettings(Context context) {
if (android.os.Build.VERSION.SDK_INT > 10) {
context.startActivity(new Intent(android.provider.Settings.ACTION_SETTINGS));
} else {
context.startActivity(new Intent(android.provider.Settings.ACTION_WIRELESS_SETTINGS));
}
}
### 判断网络是否是4G
``` java
/**
* 判断网络是否是4G
* <p>需添加权限 android.permission.ACCESS_NETWORK_STATE
*/
public static boolean is4G(Context context) {
NetworkInfo info = getActiveNetworkInfo(context);
return info != null && info.isAvailable() && info.getSubtype() == TelephonyManager.NETWORK_TYPE_LTE;
}
```
/**
* 获取活动网路信息
*
* @param context 上下文
* @return NetworkInfo
*/
private static NetworkInfo getActiveNetworkInfo(Context context) {
ConnectivityManager cm = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
return cm.getActiveNetworkInfo();
}
### 判断wifi是否连接状态
``` java
/**
* 判断wifi是否连接状态
* <p>需添加权限 android.permission.ACCESS_NETWORK_STATE
*/
public static boolean isWifiConnected(Context context) {
ConnectivityManager cm = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
return cm != null && cm.getActiveNetworkInfo().getType() == ConnectivityManager.TYPE_WIFI;
}
```
/**
* 判断网络是否可用
* <p>需添加权限 android.permission.ACCESS_NETWORK_STATE</p>
*/
public static boolean isAvailable(Context context) {
NetworkInfo info = getActiveNetworkInfo(context);
return info != null && info.isAvailable();
}
### 获取移动网络运营商名称
``` java
/**
* 获取移动网络运营商名称
* <p>如中国联通、中国移动、中国电信
*/
public static String getNetworkOperatorName(Context context) {
TelephonyManager tm = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
return tm != null ? tm.getNetworkOperatorName() : null;
}
```
/**
* 判断网络是否连接
* <p>需添加权限 android.permission.ACCESS_NETWORK_STATE</p>
*
* @param context 上下文
* @return true: 是<br>false: 否
*/
public static boolean isConnected(Context context) {
NetworkInfo info = getActiveNetworkInfo(context);
return info != null && info.isConnected();
}
### 获取移动终端类型
``` java
/**
* 获取移动终端类型
*
* @return 手机制式
* <ul>
* <li>PHONE_TYPE_NONE : 0 手机制式未知</li>
* <li>PHONE_TYPE_GSM : 1 手机制式为GSM，移动和联通</li>
* <li>PHONE_TYPE_CDMA : 2 手机制式为CDMA，电信</li>
* <li>PHONE_TYPE_SIP : 3</li>
* </ul>
*/
public static int getPhoneType(Context context) {
TelephonyManager tm = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
return tm != null ? tm.getPhoneType() : -1;
}
```
/**
* 判断网络是否是4G
* <p>需添加权限 android.permission.ACCESS_NETWORK_STATE</p>
*
* @param context 上下文
* @return true: 是<br>false: 不是
*/
public static boolean is4G(Context context) {
NetworkInfo info = getActiveNetworkInfo(context);
return info != null && info.isAvailable() && info.getSubtype() == TelephonyManager.NETWORK_TYPE_LTE;
}
### 获取当前的网络类型(WIFI,2G,3G,4G)
``` java
/**
* 获取当前的网络类型(WIFI,2G,3G,4G)
* <p>需添加权限 android.permission.ACCESS_NETWORK_STATE
*
* @return 网络类型
* <ul>
* <li>NETWORK_WIFI = 1;</li>
* <li>NETWORK_4G = 4;</li>
* <li>NETWORK_3G = 3;</li>
* <li>NETWORK_2G = 2;</li>
* <li>NETWORK_UNKNOWN = 5;</li>
* <li>NETWORK_NO = -1;</li>
* </ul>
*/
public static int getNetWorkType(Context context) {
int netType = NETWORK_NO;
NetworkInfo info = getActiveNetworkInfo(context);
if (info != null && info.isAvailable()) {
if (info.getType() == ConnectivityManager.TYPE_WIFI) {
netType = NETWORK_WIFI;
} else if (info.getType() == ConnectivityManager.TYPE_MOBILE) {
switch (info.getSubtype()) {
case NETWORK_TYPE_GSM:
case TelephonyManager.NETWORK_TYPE_GPRS:
case TelephonyManager.NETWORK_TYPE_CDMA:
case TelephonyManager.NETWORK_TYPE_EDGE:
case TelephonyManager.NETWORK_TYPE_1xRTT:
case TelephonyManager.NETWORK_TYPE_IDEN:
netType = NETWORK_2G;
break;
case NETWORK_TYPE_TD_SCDMA:
case TelephonyManager.NETWORK_TYPE_EVDO_A:
case TelephonyManager.NETWORK_TYPE_UMTS:
case TelephonyManager.NETWORK_TYPE_EVDO_0:
case TelephonyManager.NETWORK_TYPE_HSDPA:
case TelephonyManager.NETWORK_TYPE_HSUPA:
case TelephonyManager.NETWORK_TYPE_HSPA:
case TelephonyManager.NETWORK_TYPE_EVDO_B:
case TelephonyManager.NETWORK_TYPE_EHRPD:
case TelephonyManager.NETWORK_TYPE_HSPAP:
netType = NETWORK_3G;
break;
case NETWORK_TYPE_IWLAN:
case TelephonyManager.NETWORK_TYPE_LTE:
netType = NETWORK_4G;
break;
default:
String subtypeName = info.getSubtypeName();
if (subtypeName.equalsIgnoreCase("TD-SCDMA")
|| subtypeName.equalsIgnoreCase("WCDMA")
|| subtypeName.equalsIgnoreCase("CDMA2000")) {
/**
* 判断wifi是否连接状态
* <p>需添加权限 android.permission.ACCESS_NETWORK_STATE</p>
*
* @param context 上下文
* @return true: 连接<br>false: 未连接
*/
public static boolean isWifiConnected(Context context) {
ConnectivityManager cm = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
return cm != null && cm.getActiveNetworkInfo().getType() == ConnectivityManager.TYPE_WIFI;
}
/**
* 获取移动网络运营商名称
* <p>如中国联通、中国移动、中国电信</p>
*
* @param context 上下文
* @return 移动网络运营商名称
*/
public static String getNetworkOperatorName(Context context) {
TelephonyManager tm = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
return tm != null ? tm.getNetworkOperatorName() : null;
}
/**
* 获取移动终端类型
*
* @param context 上下文
* @return 手机制式
* <ul>
* <li>PHONE_TYPE_NONE : 0 手机制式未知</li>
* <li>PHONE_TYPE_GSM : 1 手机制式为GSM，移动和联通</li>
* <li>PHONE_TYPE_CDMA : 2 手机制式为CDMA，电信</li>
* <li>PHONE_TYPE_SIP : 3</li>
* </ul>
*/
public static int getPhoneType(Context context) {
TelephonyManager tm = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
return tm != null ? tm.getPhoneType() : -1;
}
/**
* 获取当前的网络类型(WIFI,2G,3G,4G)
* <p>需添加权限 android.permission.ACCESS_NETWORK_STATE</p>
*
* @param context 上下文
* @return 网络类型
* <ul>
* <li>NETWORK_WIFI = 1;</li>
* <li>NETWORK_4G = 4;</li>
* <li>NETWORK_3G = 3;</li>
* <li>NETWORK_2G = 2;</li>
* <li>NETWORK_UNKNOWN = 5;</li>
* <li>NETWORK_NO = -1;</li>
* </ul>
*/
public static int getNetWorkType(Context context) {
int netType = NETWORK_NO;
NetworkInfo info = getActiveNetworkInfo(context);
if (info != null && info.isAvailable()) {
if (info.getType() == ConnectivityManager.TYPE_WIFI) {
netType = NETWORK_WIFI;
} else if (info.getType() == ConnectivityManager.TYPE_MOBILE) {
switch (info.getSubtype()) {
case NETWORK_TYPE_GSM:
case TelephonyManager.NETWORK_TYPE_GPRS:
case TelephonyManager.NETWORK_TYPE_CDMA:
case TelephonyManager.NETWORK_TYPE_EDGE:
case TelephonyManager.NETWORK_TYPE_1xRTT:
case TelephonyManager.NETWORK_TYPE_IDEN:
netType = NETWORK_2G;
break;
case NETWORK_TYPE_TD_SCDMA:
case TelephonyManager.NETWORK_TYPE_EVDO_A:
case TelephonyManager.NETWORK_TYPE_UMTS:
case TelephonyManager.NETWORK_TYPE_EVDO_0:
case TelephonyManager.NETWORK_TYPE_HSDPA:
case TelephonyManager.NETWORK_TYPE_HSUPA:
case TelephonyManager.NETWORK_TYPE_HSPA:
case TelephonyManager.NETWORK_TYPE_EVDO_B:
case TelephonyManager.NETWORK_TYPE_EHRPD:
case TelephonyManager.NETWORK_TYPE_HSPAP:
netType = NETWORK_3G;
} else {
netType = NETWORK_UNKNOWN;
}
break;
break;
case NETWORK_TYPE_IWLAN:
case TelephonyManager.NETWORK_TYPE_LTE:
netType = NETWORK_4G;
break;
default:
String subtypeName = info.getSubtypeName();
if (subtypeName.equalsIgnoreCase("TD-SCDMA")
|| subtypeName.equalsIgnoreCase("WCDMA")
|| subtypeName.equalsIgnoreCase("CDMA2000")) {
netType = NETWORK_3G;
} else {
netType = NETWORK_UNKNOWN;
}
break;
}
} else {
netType = NETWORK_UNKNOWN;
}
} else {
netType = NETWORK_UNKNOWN;
}
return netType;
}
return netType;
}
/**
* 获取当前的网络类型(WIFI,2G,3G,4G)
* 依赖上面的方法
*
* @param context
* @return 网络类型名称
* <ul>
* <li>NETWORK_WIFI </li>
* <li>NETWORK_4G </li>
* <li>NETWORK_3G </li>
* <li>NETWORK_2G </li>
* <li>NETWORK_UNKNOWN</li>
* <li>NETWORK_NO </li>
* </ul>
*/
public static String getNetWorkTypeName(Context context) {
switch (getNetWorkType(context)) {
case NETWORK_WIFI:
return "NETWORK_WIFI";
case NETWORK_4G:
return "NETWORK_4G";
case NETWORK_3G:
return "NETWORK_3G";
case NETWORK_2G:
return "NETWORK_2G";
case NETWORK_NO:
return "NETWORK_NO";
default:
return "NETWORK_UNKNOWN";
/**
* 获取当前的网络类型(WIFI,2G,3G,4G)
* <p>依赖上面的方法</p>
*
* @param context 上下文
* @return 网络类型名称
* <ul>
* <li>NETWORK_WIFI </li>
* <li>NETWORK_4G </li>
* <li>NETWORK_3G </li>
* <li>NETWORK_2G </li>
* <li>NETWORK_UNKNOWN</li>
* <li>NETWORK_NO </li>
* </ul>
*/
public static String getNetWorkTypeName(Context context) {
switch (getNetWorkType(context)) {
case NETWORK_WIFI:
return "NETWORK_WIFI";
case NETWORK_4G:
return "NETWORK_4G";
case NETWORK_3G:
return "NETWORK_3G";
case NETWORK_2G:
return "NETWORK_2G";
case NETWORK_NO:
return "NETWORK_NO";
default:
return "NETWORK_UNKNOWN";
}
}
}
```
md/about_phone.md
浏览文件 @ 8aae7626
此差异已折叠。
md/about_regular.md
浏览文件 @ 8aae7626
# 正则相关
### 正则工具类
``` java
import android.text.TextUtils;
import java.util.regex.Pattern;
/*********************************************
* author: Blankj on 2016/8/2 21:19
* blog: http://blankj.com
* e-mail: blankj@qq.com
*********************************************/
/**
* <pre>
* author: Blankj
* blog : http://blankj.com
* time : 2016/8/2
* desc : 正则相关的工具类
* </pre>
*/
public class RegularUtils {
private RegularUtils() {
......@@ -22,7 +24,7 @@ public class RegularUtils {
private static final String REGEX_MOBILE_SIMPLE = "^[1]\\d{10}$";
/**
* 验证手机号（精确）
* <p>
* <p/>
* <p>移动：134(0-8)、135、136、137、138、139、147、150、151、152、157、158、159、178、182、183、184、187、188
* <p>联通：130、131、132、145、155、156、175、176、185、186
* <p>电信：133、153、173、177、180、181、189
......
md/about_screen.md
浏览文件 @ 8aae7626
# 屏幕相关
### 获取手机分辨率
``` java
/**
* 获取屏幕的宽度px
*/
public static int getDeviceWidth(Context context) {
WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics outMetrics = new DisplayMetrics();// 创建了一张白纸
windowManager.getDefaultDisplay().getMetrics(outMetrics);// 给白纸设置宽高
return outMetrics.widthPixels;
}
import android.app.Activity;
import android.app.KeyguardManager;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.graphics.Bitmap;
import android.os.Build;
import android.util.DisplayMetrics;
import android.util.TypedValue;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.view.WindowManager.LayoutParams;
/**
* 获取屏幕的高度px
*/
public static int getDeviceHeight(Context context) {
WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics outMetrics = new DisplayMetrics();// 创建了一张白纸
windowManager.getDefaultDisplay().getMetrics(outMetrics);// 给白纸设置宽高
return outMetrics.heightPixels;
}
```
import java.lang.reflect.Method;
### 设置透明状态栏(api >= 19方可使用)
``` java
/**
* 设置透明状态栏(api >= 19方可使用)
* <p>可在Activity的onCreat()中调用
* <p>需在顶部控件布局中加入以下属性让内容出现在状态栏之下
* <p>android:clipToPadding="true"
* <p>android:fitsSystemWindows="true"
* <pre>
* author: Blankj
* blog : http://blankj.com
* time : 2016/8/2
* desc : 屏幕相关的工具类
* </pre>
*/
public static void setTransparentStatusBar(Activity activity) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
//透明状态栏
activity.getWindow().addFlags(LayoutParams.FLAG_TRANSLUCENT_STATUS);
//透明导航栏
activity.getWindow().addFlags(LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
public class ScreenUtils {
private ScreenUtils() {
throw new UnsupportedOperationException("u can't fuck me...");
}
}
```
### 隐藏状态栏
``` java
/**
* 隐藏状态栏
* <p>也就是设置全屏，一定要在setContentView之前调用，否则报错
* <p>此方法Activity可以继承AppCompatActivity
* <p>启动的时候状态栏会显示一下再隐藏，比如QQ的欢迎界面
* <p>在配置文件中Activity加属性android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
* <p>如加了以上配置Activity不能继承AppCompatActivity，会报错
*/
public static void hideStatusBar(Activity activity) {
activity.requestWindowFeature(Window.FEATURE_NO_TITLE);
activity.getWindow().setFlags(LayoutParams.FLAG_FULLSCREEN,
LayoutParams.FLAG_FULLSCREEN);
}
```
/**
* 获取屏幕的宽度px
*
* @param context 上下文
* @return 屏幕宽px
*/
public static int getScreenWidth(Context context) {
WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics outMetrics = new DisplayMetrics();// 创建了一张白纸
windowManager.getDefaultDisplay().getMetrics(outMetrics);// 给白纸设置宽高
return outMetrics.widthPixels;
}
### 获取状态栏高度
``` java
/**
* 获取状态栏高度
*/
public static int getStatusBarHeight(Context context) {
int result = 0;
int resourceId = context.getResources()
.getIdentifier("status_bar_height", "dimen", "android");
if (resourceId > 0) {
result = context.getResources().getDimensionPixelSize(resourceId);
/**
* 获取屏幕的高度px
*
* @param context 上下文
* @return 屏幕高px
*/
public static int getScreenHeight(Context context) {
WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics outMetrics = new DisplayMetrics();// 创建了一张白纸
windowManager.getDefaultDisplay().getMetrics(outMetrics);// 给白纸设置宽高
return outMetrics.heightPixels;
}
return result;
}
```
### 判断状态栏是否存在
``` java
/**
* 判断状态栏是否存在
*
* @param activity
* @return <ul>
* <li>true: 存在 </li>
* <li>false: 不存在</li>
* </ul>
*/
public static boolean isStatusBarExists(Activity activity) {
WindowManager.LayoutParams params = activity.getWindow().getAttributes();
return (params.flags & LayoutParams.FLAG_FULLSCREEN) != LayoutParams.FLAG_FULLSCREEN;
}
```
/**
* 设置透明状态栏(api大于19方可使用)
* <p>可在Activity的onCreat()中调用</p>
* <p>需在顶部控件布局中加入以下属性让内容出现在状态栏之下</p>
* <p>android:clipToPadding="true"</p>
* <p>android:fitsSystemWindows="true"</p>
*
* @param activity activity
*/
public static void setTransparentStatusBar(Activity activity) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
//透明状态栏
activity.getWindow().addFlags(LayoutParams.FLAG_TRANSLUCENT_STATUS);
//透明导航栏
activity.getWindow().addFlags(LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
}
}
### 获取ActionBar高度
``` java
/**
* 获取ActionBar高度
*/
public static int getActionBarHeight(Activity activity) {
TypedValue tv = new TypedValue();
if (activity.getTheme().resolveAttribute(android.R.attr.actionBarSize, tv, true)) {
return TypedValue.complexToDimensionPixelSize(tv.data, activity.getResources().getDisplayMetrics());
/**
* 隐藏状态栏
* <p>也就是设置全屏，一定要在setContentView之前调用，否则报错</p>
* <p>此方法Activity可以继承AppCompatActivity</p>
* <p>启动的时候状态栏会显示一下再隐藏，比如QQ的欢迎界面</p>
* <p>在配置文件中Activity加属性android:theme="@android:style/Theme.NoTitleBar.Fullscreen"</p>
* <p>如加了以上配置Activity不能继承AppCompatActivity，会报错</p>
*
* @param activity activity
*/
public static void hideStatusBar(Activity activity) {
activity.requestWindowFeature(Window.FEATURE_NO_TITLE);
activity.getWindow().setFlags(LayoutParams.FLAG_FULLSCREEN,
LayoutParams.FLAG_FULLSCREEN);
}
return 0;
}
```
### 显示通知栏
``` java
/**
* 显示通知栏
* 需添加权限 android.permission.EXPAND_STATUS_BAR
*
* @param isSettingPanel true,打开设置，false 打开通知
*/
public static void showNotificationBar(Context context, boolean isSettingPanel) {
String methodName = (Build.VERSION.SDK_INT <= 16) ? "expand"
: (isSettingPanel ? "expandSettingsPanel" : "expandNotificationsPanel");
invokePanels(context, methodName);
}
```
/**
* 获取状态栏高度
*
* @param context 上下文
* @return 状态栏高度
*/
public static int getStatusBarHeight(Context context) {
int result = 0;
int resourceId = context.getResources()
.getIdentifier("status_bar_height", "dimen", "android");
if (resourceId > 0) {
result = context.getResources().getDimensionPixelSize(resourceId);
}
return result;
}
### 隐藏通知栏
``` java
/**
* 隐藏通知栏
* 需添加权限 android.permission.EXPAND_STATUS_BAR
*/
public static void hideNotificationBar(Context context) {
String methodName = (Build.VERSION.SDK_INT <= 16) ? "collapse" : "collapsePanels";
invokePanels(context, methodName);
}
```
/**
* 判断状态栏是否存在
*
* @param activity activity
* @return true: 存在<br>false: 不存在
*/
public static boolean isStatusBarExists(Activity activity) {
LayoutParams params = activity.getWindow().getAttributes();
return (params.flags & LayoutParams.FLAG_FULLSCREEN) != LayoutParams.FLAG_FULLSCREEN;
}
### 设置屏幕为横屏
```
/**
* 设置屏幕为横屏
* <p>还有一种就是在Activity中加属性android:screenOrientation="landscape"
* <p>不设置Activity的android:configChanges时，切屏会重新调用各个生命周期，切横屏时会执行一次，切竖屏时会执行两次
* <p>设置Activity的android:configChanges="orientation"时，切屏还是会重新调用各个生命周期，切横、竖屏时只会执行一次
* <p>设置Activity的android:configChanges="orientation|keyboardHidden|screenSize"（4.0以上必须带最后一个参数）时
* 切屏不会重新调用各个生命周期，只会执行onConfigurationChanged方法
*/
public static void setLandscape(Activity activity) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
}
```
/**
* 获取ActionBar高度
*
* @param activity activity
* @return ActionBar高度
*/
public static int getActionBarHeight(Activity activity) {
TypedValue tv = new TypedValue();
if (activity.getTheme().resolveAttribute(android.R.attr.actionBarSize, tv, true)) {
return TypedValue.complexToDimensionPixelSize(tv.data, activity.getResources().getDisplayMetrics());
}
return 0;
}
### 获取当前屏幕截图
``` java
/**
* 获取当前屏幕截图，包含状态栏
*/
public static Bitmap captureWithStatusBar(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 = Bitmap.createBitmap(bmp, 0, 0, width, height);
view.destroyDrawingCache();
return bp;
}
/**
* 显示通知栏
* <p>需添加权限 android.permission.EXPAND_STATUS_BAR</p>
*
* @param context 上下文
* @param isSettingPanel true: 打开设置<br>false: 打开通知
*/
public static void showNotificationBar(Context context, boolean isSettingPanel) {
String methodName = (Build.VERSION.SDK_INT <= 16) ? "expand"
: (isSettingPanel ? "expandSettingsPanel" : "expandNotificationsPanel");
invokePanels(context, methodName);
}
/**
* 获取当前屏幕截图，不包含状态栏
* <p>需要用到上面获取状态栏高度的方法
*/
public static Bitmap captureWithoutStatusBar(Activity activity) {
View view = activity.getWindow().getDecorView();
view.setDrawingCacheEnabled(true);
view.buildDrawingCache();
Bitmap bmp = view.getDrawingCache();
int statusBarHeight = getStatusBarHeight(activity);
int width = getScreenWidth(activity);
int height = getScreenHeight(activity);
Bitmap bp = Bitmap.createBitmap(bmp, 0, statusBarHeight, width, height - statusBarHeight);
view.destroyDrawingCache();
return bp;
}
```
/**
* 隐藏通知栏
* <p>需添加权限 android.permission.EXPAND_STATUS_BAR</p>
*
* @param context 上下文
*/
public static void hideNotificationBar(Context context) {
String methodName = (Build.VERSION.SDK_INT <= 16) ? "collapse" : "collapsePanels";
invokePanels(context, methodName);
}
### 判断是否锁屏
``` java
/**
* 判断是否锁屏
*/
public static boolean isScreenLock(Context context) {
KeyguardManager km = (KeyguardManager) context
.getSystemService(Context.KEYGUARD_SERVICE);
return km.inKeyguardRestrictedInputMode();
}
```
/**
* 反射唤醒通知栏
*
* @param context 上下文
* @param methodName 方法名
*/
private static void invokePanels(Context context, String methodName) {
try {
Object service = context.getSystemService("statusbar");
Class<?> statusBarManager = Class.forName("android.app.StatusBarManager");
Method expand = statusBarManager.getMethod(methodName);
expand.invoke(service);
} catch (Exception e) {
e.printStackTrace();
}
}
***
# 尺寸相关
### dp与px转换
``` java
/**
* dp转px
*/
public static int dp2px(Context context, float dpValue) {
final float scale = context.getResources().getDisplayMetrics().density;
return (int) (dpValue * scale + 0.5f);
}
/**
* 设置屏幕为横屏
* <p>还有一种就是在Activity中加属性android:screenOrientation="landscape"</p>
* <p>不设置Activity的android:configChanges时，切屏会重新调用各个生命周期，切横屏时会执行一次，切竖屏时会执行两次</p>
* <p>设置Activity的android:configChanges="orientation"时，切屏还是会重新调用各个生命周期，切横、竖屏时只会执行一次</p>
* <p>设置Activity的android:configChanges="orientation|keyboardHidden|screenSize"（4.0以上必须带最后一个参数）时
* 切屏不会重新调用各个生命周期，只会执行onConfigurationChanged方法</p>
*
* @param activity activity
*/
public static void setLandscape(Activity activity) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
}
/**
* px转dp
*/
public static int px2dp(Context context, float pxValue) {
final float scale = context.getResources().getDisplayMetrics().density;
return (int) (pxValue / scale + 0.5f);
/**
* 获取当前屏幕截图，包含状态栏
*
* @param activity activity
* @return Bitmap
*/
public static Bitmap captureWithStatusBar(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 = Bitmap.createBitmap(bmp, 0, 0, width, height);
view.destroyDrawingCache();
return bp;
}
/**
* 获取当前屏幕截图，不包含状态栏
* <p>需要用到上面获取状态栏高度getStatusBarHeight的方法</p>
*
* @param activity activity
* @return Bitmap
*/
public static Bitmap captureWithoutStatusBar(Activity activity) {
View view = activity.getWindow().getDecorView();
view.setDrawingCacheEnabled(true);
view.buildDrawingCache();
Bitmap bmp = view.getDrawingCache();
int statusBarHeight = getStatusBarHeight(activity);
int width = getScreenWidth(activity);
int height = getScreenHeight(activity);
Bitmap bp = Bitmap.createBitmap(bmp, 0, statusBarHeight, width, height - statusBarHeight);
view.destroyDrawingCache();
return bp;
}
/**
* 判断是否锁屏
*
* @param context 上下文
* @return true: 是<br>false: 否
*/
public static boolean isScreenLock(Context context) {
KeyguardManager km = (KeyguardManager) context
.getSystemService(Context.KEYGUARD_SERVICE);
return km.inKeyguardRestrictedInputMode();
}
}
```
\ No newline at end of file
```
\ No newline at end of file
md/about_shell.md 0 → 100644
浏览文件 @ 8aae7626
# Shell相关
``` java
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.List;
/**
* <pre>
* author: Blankj
* blog : http://blankj.com
* time : 2016/8/7
* desc : Shell操作工具类
* </pre>
*/
public class ShellUtils {
private ShellUtils() {
throw new UnsupportedOperationException("u can't fuck me...");
}
public static final String COMMAND_SU = "su";
public static final String COMMAND_SH = "sh";
public static final String COMMAND_EXIT = "exit\n";
public static final String COMMAND_LINE_END = "\n";
/**
* 判断设备是否root
*/
public static boolean isRoot() {
return execCmd("echo root", true, false).result == 0;
}
/**
* 是否是在root下执行命令
*
* @param command 命令
* @param isRoot 是否root
* @return CommandResult
*/
public static CommandResult execCmd(String command, boolean isRoot) {
return execCmd(new String[]{command}, isRoot, true);
}
/**
* 是否是在root下执行命令
*
* @param commands 多条命令链表
* @param isRoot 是否root
* @return CommandResult
*/
public static CommandResult execCmd(List<String> commands, boolean isRoot) {
return execCmd(commands == null ? null : commands.toArray(new String[]{}), isRoot, true);
}
/**
* 是否是在root下执行命令
*
* @param commands 多条命令数组
* @param isRoot 是否root
* @return CommandResult
*/
public static CommandResult execCmd(String[] commands, boolean isRoot) {
return execCmd(commands, isRoot, true);
}
/**
* 是否是在root下执行命令
*
* @param command 命令
* @param isRoot 是否root
* @param isNeedResultMsg 是否需要结果消息
* @return CommandResult
*/
public static CommandResult execCmd(String command, boolean isRoot, boolean isNeedResultMsg) {
return execCmd(new String[]{command}, isRoot, isNeedResultMsg);
}
/**
* 是否是在root下执行命令
*
* @param commands 命令链表
* @param isRoot 是否root
* @param isNeedResultMsg 是否需要结果消息
* @return CommandResult
*/
public static CommandResult execCmd(List<String> commands, boolean isRoot, boolean isNeedResultMsg) {
return execCmd(commands == null ? null : commands.toArray(new String[]{}), isRoot, isNeedResultMsg);
}
/**
* 是否是在root下执行命令
*
* @param commands 命令数组
* @param isRoot 是否root
* @param isNeedResultMsg 是否需要结果消息
* @return CommandResult
*/
public static CommandResult execCmd(String[] commands, boolean isRoot, boolean isNeedResultMsg) {
int result = -1;
if (commands == null || commands.length == 0) {
return new CommandResult(result, null, null);
}
Process process = null;
BufferedReader successResult = null;
BufferedReader errorResult = null;
StringBuilder successMsg = null;
StringBuilder errorMsg = null;
DataOutputStream os = null;
try {
process = Runtime.getRuntime().exec(isRoot ? COMMAND_SU : COMMAND_SH);
os = new DataOutputStream(process.getOutputStream());
for (String command : commands) {
if (command == null) {
continue;
}
os.write(command.getBytes());
os.writeBytes(COMMAND_LINE_END);
os.flush();
}
os.writeBytes(COMMAND_EXIT);
os.flush();
result = process.waitFor();
if (isNeedResultMsg) {
successMsg = new StringBuilder();
errorMsg = new StringBuilder();
successResult = new BufferedReader(new InputStreamReader(process.getInputStream()));
errorResult = new BufferedReader(new InputStreamReader(process.getErrorStream()));
String s;
while ((s = successResult.readLine()) != null) {
successMsg.append(s);
}
while ((s = errorResult.readLine()) != null) {
errorMsg.append(s);
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (os != null) {
os.close();
}
if (successResult != null) {
successResult.close();
}
if (errorResult != null) {
errorResult.close();
}
} catch (IOException e) {
e.printStackTrace();
}
if (process != null) {
process.destroy();
}
}
return new CommandResult(result, successMsg == null ? null : successMsg.toString(), errorMsg == null ? null
: errorMsg.toString());
}
/**
* 返回的命令结果
*/
public static class CommandResult {
/**
* 结果码
**/
public int result;
/**
* 成功的信息
**/
public String successMsg;
/**
* 错误信息
**/
public String errorMsg;
public CommandResult(int result) {
this.result = result;
}
public CommandResult(int result, String successMsg, String errorMsg) {
this.result = result;
this.successMsg = successMsg;
this.errorMsg = errorMsg;
}
}
}
```
\ No newline at end of file
md/about_size.md
浏览文件 @ 8aae7626
# 尺寸相关
### dp与px转换
``` java
/**
* dp转px
*/
public static int dp2px(Context context, float dpValue) {
final float scale = context.getResources().getDisplayMetrics().density;
return (int) (dpValue * scale + 0.5f);
}
import android.content.Context;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.TypedValue;
import android.view.View;
/**
* px转dp
*/
public static int px2dp(Context context, float pxValue) {
final float scale = context.getResources().getDisplayMetrics().density;
return (int) (pxValue / scale + 0.5f);
}
```
### sp与px转换
``` java
/**
* sp转px
*/
public static int sp2px(Context context, float spValue) {
final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
return (int) (spValue * fontScale + 0.5f);
}
* <pre>
* author: Blankj
* blog : http://blankj.com
* time : 2016/8/2
* desc : 尺寸相关的工具类
* </pre>
*/
public class SizeUtils {
/**
* px转sp
*/
public static int px2sp(Context context, float pxValue) {
final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
return (int) (pxValue / fontScale + 0.5f);
}
```
private SizeUtils() {
throw new UnsupportedOperationException("u can't fuck me...");
}
### 各种单位转换
``` java
/**
* 各种单位转换
* <p>该方法存在于TypedValue
*/
public static float applyDimension(int unit, float value, DisplayMetrics metrics) {
switch (unit) {
case TypedValue.COMPLEX_UNIT_PX:
return value;
case TypedValue.COMPLEX_UNIT_DIP:
return value * metrics.density;
case TypedValue.COMPLEX_UNIT_SP:
return value * metrics.scaledDensity;
case TypedValue.COMPLEX_UNIT_PT:
return value * metrics.xdpi * (1.0f / 72);
case TypedValue.COMPLEX_UNIT_IN:
return value * metrics.xdpi;
case TypedValue.COMPLEX_UNIT_MM:
return value * metrics.xdpi * (1.0f / 25.4f);
/**
* dp转px
*
* @param context 上下文
* @param dpValue dp值
* @return px值
*/
public static int dp2px(Context context, float dpValue) {
final float scale = context.getResources().getDisplayMetrics().density;
return (int) (dpValue * scale + 0.5f);
}
return 0;
}
```
### 在onCreate()即可强行获取View的尺寸
``` java
/**
* 在onCreate()即可强行获取View的尺寸
* <p>需回调onGetSizeListener接口，在onGetSize中获取view宽高
* 用法示例如下所示
* SizeUtils.forceGetViewSize(view);
* SizeUtils.setListener(new SizeUtils.onGetSizeListener() {
* @Override
* public void onGetSize(View view) {
* Log.d("tag", view.getWidth() + " " + view.getHeight());
* }
* });
*/
public static void forceGetViewSize(final View view) {
view.post(new Runnable() {
@Override
public void run() {
if (mListener != null) {
mListener.onGetSize(view);
}
}
});
}
/**
* px转dp
*
* @param context 上下文
* @param pxValue px值
* @return dp值
*/
public static int px2dp(Context context, float pxValue) {
final float scale = context.getResources().getDisplayMetrics().density;
return (int) (pxValue / scale + 0.5f);
}
/**
* 获取到View尺寸的监听
*/
public interface onGetSizeListener {
void onGetSize(View view);
}
/**
* sp转px
*
* @param context 上下文
* @param spValue sp值
* @return px值
*/
public static int sp2px(Context context, float spValue) {
final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
return (int) (spValue * fontScale + 0.5f);
}
public static void setListener(onGetSizeListener listener) {
mListener = listener;
}
/**
* px转sp
*
* @param context 上下文
* @param pxValue px值
* @return sp值
*/
public static int px2sp(Context context, float pxValue) {
final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
return (int) (pxValue / fontScale + 0.5f);
}
private static onGetSizeListener mListener;
```
/**
* 各种单位转换
* <p>该方法存在于TypedValue</p>
*
* @param unit 单位
* @param value 值
* @param metrics DisplayMetrics
* @return 转换结果
*/
public static float applyDimension(int unit, float value, DisplayMetrics metrics) {
switch (unit) {
case TypedValue.COMPLEX_UNIT_PX:
return value;
case TypedValue.COMPLEX_UNIT_DIP:
return value * metrics.density;
case TypedValue.COMPLEX_UNIT_SP:
return value * metrics.scaledDensity;
case TypedValue.COMPLEX_UNIT_PT:
return value * metrics.xdpi * (1.0f / 72);
case TypedValue.COMPLEX_UNIT_IN:
return value * metrics.xdpi;
case TypedValue.COMPLEX_UNIT_MM:
return value * metrics.xdpi * (1.0f / 25.4f);
}
return 0;
}
### ListView中提前测量View尺寸
``` java
/**
* ListView中提前测量View尺寸，如headerView
* <p>用的时候去掉注释拷贝到ListView中即可
* <p>参照以下注释代码
*/
public static void measureViewInLV(View view) {
Log.i("tips", "U should copy the follow code.");
/*
ViewGroup.LayoutParams p = view.getLayoutParams();
if (p == null) {
p = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.WRAP_CONTENT);
/**
* 在onCreate()即可强行获取View的尺寸
* <p>需回调onGetSizeListener接口，在onGetSize中获取view宽高</p>
* <p>用法示例如下所示</p>
* <pre>
* SizeUtils.forceGetViewSize(view);
* SizeUtils.setListener(new SizeUtils.onGetSizeListener() {
* <br>@Override
* public void onGetSize(View view) {
* Log.d("tag", view.getWidth() + " " + view.getHeight());
* }
* });
* </pre>
*
* @param view 视图
*/
public static void forceGetViewSize(final View view) {
view.post(new Runnable() {
@Override
public void run() {
if (mListener != null) {
mListener.onGetSize(view);
}
}
});
}
/**
* 获取到View尺寸的监听
*/
public interface onGetSizeListener {
void onGetSize(View view);
}
public static void setListener(onGetSizeListener listener) {
mListener = listener;
}
int width = ViewGroup.getChildMeasureSpec(0, 0, p.width);
int height;
int tempHeight = p.height;
if (tempHeight > 0) {
height = MeasureSpec.makeMeasureSpec(tempHeight,
MeasureSpec.EXACTLY);
} else {
height = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
private static onGetSizeListener mListener;
/**
* ListView中提前测量View尺寸，如headerView
* <p>用的时候去掉注释拷贝到ListView中即可</p>
* <p>参照以下注释代码</p>
*
* @param view 视图
*/
public static void measureViewInLV(View view) {
Log.i("tips", "U should copy the following code.");
/*
ViewGroup.LayoutParams p = view.getLayoutParams();
if (p == null) {
p = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.WRAP_CONTENT);
}
int width = ViewGroup.getChildMeasureSpec(0, 0, p.width);
int height;
int tempHeight = p.height;
if (tempHeight > 0) {
height = MeasureSpec.makeMeasureSpec(tempHeight,
MeasureSpec.EXACTLY);
} else {
height = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
}
view.measure(width, height);
*/
}
view.measure(width, height);
*/
}
```
```
\ No newline at end of file
md/about_sp.md 0 → 100644
浏览文件 @ 8aae7626
# SP相关
``` java
import android.content.Context;
import android.content.SharedPreferences;
/**
* <pre>
* author: Blankj
* blog : http://blankj.com
* time : 2016/8/2
* desc : SP读写工具类
* </pre>
*/
public class SPUtils {
private SPUtils() {
throw new UnsupportedOperationException("u can't fuck me...");
}
/**
* SP的name值
* <p>可通过修改PREFERENCE_NAME变量修改SP的name值</p>
*/
public static String PREFERENCE_NAME = "ANCROID_UTIL_CODE";
/**
* SP中写入String类型value
*
* @param context 上下文
* @param key 键
* @param value 值
* @return true: 写入成功<br>false: 写入失败
*/
public static boolean putString(Context context, String key, String value) {
return getSP(context).edit().putString(key, value).commit();
}
/**
* SP中读取String
*
* @param context 上下文
* @param key 键
* @return 存在返回对应值，不存在返回默认值null
*/
public static String getString(Context context, String key) {
return getString(context, key, null);
}
/**
* SP中读取String
*
* @param context 上下文
* @param key 键
* @param defaultValue 默认值
* @return 存在返回对应值，不存在返回默认值defaultValue
*/
public static String getString(Context context, String key, String defaultValue) {
return getSP(context).getString(key, defaultValue);
}
/**
* SP中写入int类型value
*
* @param context 上下文
* @param key 键
* @param value 值
* @return true: 写入成功<br>false: 写入失败
*/
public static boolean putInt(Context context, String key, int value) {
return getSP(context).edit().putInt(key, value).commit();
}
/**
* SP中读取int
*
* @param context 上下文
* @param key 键
* @return 存在返回对应值，不存在返回默认值-1
*/
public static int getInt(Context context, String key) {
return getInt(context, key, -1);
}
/**
* SP中读取int
*
* @param context 上下文
* @param key 键
* @param defaultValue 默认值
* @return 存在返回对应值，不存在返回默认值defaultValue
*/
public static int getInt(Context context, String key, int defaultValue) {
return getSP(context).getInt(key, defaultValue);
}
/**
* SP中写入long类型value
*
* @param context 上下文
* @param key 键
* @param value 值
* @return true: 写入成功<br>false: 写入失败
*/
public static boolean putLong(Context context, String key, long value) {
return getSP(context).edit().putLong(key, value).commit();
}
/**
* SP中读取long
*
* @param context 上下文
* @param key 键
* @return 存在返回对应值，不存在返回默认值-1
*/
public static long getLong(Context context, String key) {
return getLong(context, key, -1);
}
/**
* SP中读取long
*
* @param context 上下文
* @param key 键
* @param defaultValue 默认值
* @return 存在返回对应值，不存在返回默认值defaultValue
*/
public static long getLong(Context context, String key, long defaultValue) {
return getSP(context).getLong(key, defaultValue);
}
/**
* SP中写入float类型value
*
* @param context 上下文
* @param key 键
* @param value 值
* @return true: 写入成功<br>false: 写入失败
*/
public static boolean putFloat(Context context, String key, float value) {
return getSP(context).edit().putFloat(key, value).commit();
}
/**
* SP中读取float
*
* @param context 上下文
* @param key 键
* @return 存在返回对应值，不存在返回默认值-1
*/
public static float getFloat(Context context, String key) {
return getFloat(context, key, -1);
}
/**
* SP中读取float
*
* @param context 上下文
* @param key 键
* @param defaultValue 默认值
* @return 存在返回对应值，不存在返回默认值defaultValue
*/
public static float getFloat(Context context, String key, float defaultValue) {
return getSP(context).getFloat(key, defaultValue);
}
/**
* SP中写入boolean类型value
*
* @param context 上下文
* @param key 键
* @param value 值
* @return true: 写入成功<br>false: 写入失败
*/
public static boolean putBoolean(Context context, String key, boolean value) {
return getSP(context).edit().putBoolean(key, value).commit();
}
/**
* SP中读取boolean
*
* @param context 上下文
* @param key 键
* @return 存在返回对应值，不存在返回默认值false
*/
public static boolean getBoolean(Context context, String key) {
return getBoolean(context, key, false);
}
/**
* SP中读取boolean
*
* @param context 上下文
* @param key 键
* @param defaultValue 默认值
* @return 存在返回对应值，不存在返回默认值defaultValue
*/
public static boolean getBoolean(Context context, String key, boolean defaultValue) {
return getSP(context).getBoolean(key, defaultValue);
}
/**
* 获取name为PREFERENCE_NAME的SP对象
*
* @param context 上下文
* @return SP
*/
private static SharedPreferences getSP(Context context) {
return context.getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
}
}
```
\ No newline at end of file
md/about_time.md
浏览文件 @ 8aae7626
此差异已折叠。
md/about_unclassified.md
浏览文件 @ 8aae7626
# 未归类
### 获取服务是否开启
```
``` java
import android.app.ActivityManager;
import android.app.ActivityManager.RunningServiceInfo;
import android.content.ComponentName;
import android.content.Context;
import java.util.List;
/**
* 获取服务是否开启
* @param className 完整包名的服务类名
* <pre>
* author: Blankj
* blog : http://blankj.com
* time : 2016/8/2
* desc : 未归类的工具类
* </pre>
*/
public static boolean isRunningService(String className, Context context) {
// 进程的管理者,活动的管理者
ActivityManager activityManager = (ActivityManager)
context.getSystemService(Context.ACTIVITY_SERVICE);
// 获取正在运行的服务，最多获取1000个
List<RunningServiceInfo> runningServices = activityManager.getRunningServices(1000);
// 遍历集合
for (RunningServiceInfo runningServiceInfo : runningServices) {
ComponentName service = runningServiceInfo.service;
if (className.equals(service.getClassName())) {
return true;
public class UnclassifiedUtils {
private UnclassifiedUtils() {
throw new UnsupportedOperationException("u can't fuck me...");
}
/**
* 获取服务是否开启
*
* @param context 上下文
* @param className 完整包名的服务类名
* @return true: 是<br>false: 否
*/
public static boolean isRunningService(Context context, String className) {
// 进程的管理者,活动的管理者
ActivityManager activityManager = (ActivityManager)
context.getSystemService(Context.ACTIVITY_SERVICE);
// 获取正在运行的服务，最多获取1000个
List<RunningServiceInfo> runningServices = activityManager.getRunningServices(1000);
// 遍历集合
for (RunningServiceInfo runningServiceInfo : runningServices) {
ComponentName service = runningServiceInfo.service;
if (className.equals(service.getClassName())) {
return true;
}
}
return false;
}
/**
* HTML字符转义
* <p>对输入参数中的敏感字符进行过滤替换,防止用户利用JavaScript等方式输入恶意代码</p>
*
* @param html html文本
* @return 过滤后的文本
*/
public static String htmlEscape(String html) {
return html.replaceAll("&", "&amp;")
.replaceAll("<", "&lt;")
.replaceAll(">", "&gt;")
.replaceAll(" ", "&nbsp;")
.replaceAll("'", "&#39;")
.replaceAll("\"", "&quot;")
.replaceAll("\n", "<br/>");
}
return false;
}
```
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或