前言
相信用过工具类的各位仁兄都觉得工具类好用，小弟不才，今天斗胆拿出自己感觉比较顺手的工具类。
1、Activity控制类
public class ActivityCollector{
//activity集合
public static List<Activity> mActList = new ArrayList<Activity>();
/**
* 添加Activity
*
* @param activity
*/
public static void addActivity(Activity activity){
mActList.add.add(activity);
}
}
/**
* 移除Activity
*/
public static void removeActivity(Activity activity) {
mActList.remove(activity);
}
/**
* 退出
*/
public static void finishAll() {
for (Activity activity : mActList) {
if (!activity.isFinishing()) {
activity.finish();
}
}
}
}
2、应用市场管理类
public class MarketUtils {
// 360手机助手
public static final String MARKET = "com.qihoo.appstore";
// 淘宝手机助手
public static final String MARKET_TAOBAO = "com.taobao.appcenter";
// 应用宝
public static final String MARKET_QQDOWNLOADER = "com.tencent.Android.qqdownloader";
// 安卓市场
public static final String MARKET_HIAPK = "com.hiapk.marketpho";
// 安智市场
public static final String MARKET_GOAPK = "cn.goapk.market";
// 包名
public static final String APP_PACKAGE_NAME = "com.*.*";
public MarketUtils() {
throw new AssertionError();
}
/**
* 跳转到应用市场
*
* @param appPkg
* ：上传到应用市场上app的包名,不是本项目的包名
* @param marketPkg
* ：应用市场的包名
*/
public static void goToMarket(Context context, String packageName) {
Uri uri = Uri.parse("market://details?id=" + packageName);
Intent goToMarket = new Intent(Intent.ACTION_VIEW, uri);
try {
context.startActivity(goToMarket);
} catch (ActivityNotFoundException e) {
}
}
/**
* 启动App
*
* @param context
*/
public static void launchapp(Context context) {
// 判断是否安装过App，否则去市场下载
if (isAppInstalled(context, APP_PACKAGE_NAME)) {
context.startActivity(context.getPackageManager()
.getLaunchIntentForPackage(APP_PACKAGE_NAME));
} else {
goToMarket(context, APP_PACKAGE_NAME);
}
}
/**
* 检测某个应用是否安装
*
* @param context
* @param packageName
* @return
*/
public static boolean isAppInstalled(Context context, String packageName) {
try {
context.getPackageManager().getPackageInfo(packageName, 0);
return true;
} catch (NameNotFoundException e) {
return false;
}
}
/**
* 判断市场是否存在的方法
*
* @param context
* @param packageName
* 应用市场包名
* @return true or false
*/
public static boolean isAvilible(Context context, String packageName) {
final PackageManager packageManager = context.getPackageManager();// 获取packagemanager
List<PackageInfo> packageInfo = packageManager.getInstalledPackages(0);// 获取所有已安装程序的包信息
List<String> NameList = new ArrayList<String>();// 用于存储所有已安装程序的包名
// 从packageInfo中取出包名，放入NameList中
if (packageInfo != null) {
for (int i = 0; i < packageInfo.size(); i++) {
String pn = packageInfo.get(i).packageName;
NameList.add(pn);
}
}
return NameList.contains(packageName);// 判断pName中是否有目标程序的包名，有TRUE，没有FALSE
}
}
3、Toast工具类（不建议使用，请看另外一篇Android 自定义Toast，并且勘误Android工具类里面的ToastUtils）
public class ToastUtils {~
public static Toast toast;
public static boolean isShow = true;
private ToastUtils() {
// 不能被实例化
throw new UnsupportedOperationException("cannot be instantiated");
}
public static void showToast(Context context, String message) {
if (toast == null) {
toast = Toast.makeText(context, message, Toast.LENGTH_SHORT);
} else {
toast.setText(message);
}
toast.show();
}
/**
* 屏幕中间位置显示短时间Toast
*
* @param context
* @param msg
*/
public static void ToastShortCenter(Context context, String msg) {
if (isShow) {
if (context != null) {
Toast toast = Toast.makeText(context, msg, Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
}
}
}
/**
* 屏幕中心位置长时间显示Toast
*
* @param context
* @param message
*/
public static void ToastLongCenter(Context context, String message) {
if (isShow) {
if (context != null) {
Toast toast = Toast.makeText(context, message,
Toast.LENGTH_LONG);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
}
}
}
/**
* 自定义显示Toast时间
*
* @param context
* @param message
* @param duration
*/
public static void ToastShow(Context context, String message, int duration) {
if (isShow)
Toast.makeText(context, message, duration).show();
}
}
4、KeyBoardUtils
public class KeyBoardUtils {
public KeyBoardUtils() {
throw new AssertionError();
}
/**
* 打卡软键盘
*
* @param mEditText
* 输入框
* @param mContext
* 上下文
*/
public static void openKeybord(EditText mEditText, Context mContext) {
InputMethodManager imm = (InputMethodManager) mContext
.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(mEditText, InputMethodManager.RESULT_SHOWN);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,
InputMethodManager.HIDE_IMPLICIT_ONLY);
}
/**
* 关闭软键盘
*
* @param mEditText
* 输入框
* @param mContext
* 上下文
*/
public static void closeKeybord(EditText mEditText, Context mContext) {
InputMethodManager imm = (InputMethodManager) mContext
.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(mEditText.getWindowToken(), 0);
}
}
5、AES工具类
public class AESUtils {
// 密钥算法
private static final String KEY_ALGORITHM = "AES";
// AES/CBC/PKCS7Padding 分别对应 加密||解密算法、工作模式、填充方式
private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS7Padding";
// 定义自己的秘钥
public final static String SECRETKEY = "A9e4/vnQTrKF6otAGbM6zGsulKEL7b3x";
// 位移量
public final static String DISPLACEMENT = "9mg+!7ed8b36*w`X";
/**
* 获取KEY
*
* @return
* @throws Exception
*/
private static byte[] getKey() throws Exception {
return SECRETKEY.getBytes(Charset.forName("UTF-8"));
}
/**
* 加密
*
* @param toEncrypt
* 文本
* @return
*
* 加密返回数组
* @throws Exception
*/
@SuppressLint("TrulyRandom")
public static byte[] Encrypt(String toEncrypt) throws Exception {
// 秘钥
Key secretKey = new SecretKeySpec(getKey(), KEY_ALGORITHM);
// libs中bcprov的支持,bouncycastle支持 64 位密钥
Security.addProvider(new BouncyCastleProvider());
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
// 获取位移，并初始化
final byte[] data = DISPLACEMENT.getBytes();
IvParameterSpec mIvParameterSpec = new IvParameterSpec(data);
// 用 iv 初始化
cipher.init(Cipher.ENCRYPT_MODE, secretKey, mIvParameterSpec);
final byte[] mEncrypted = cipher.doFinal(toEncrypt.getBytes(Charset
.forName("UTF-8")));
final byte[] mSpecEncrypted = new byte[data.length + mEncrypted.length];
System.arraycopy(data, 0, mSpecEncrypted, 0, data.length);
System.arraycopy(mEncrypted, 0, mSpecEncrypted, data.length,
mEncrypted.length);
return mSpecEncrypted;
}
/**
* 加密数据
*
* @param encryption
*
* 文本
* @return
*
* 返回字符串
* @throws Exception
*/
public static String Encryption(String encryption) throws Exception {
byte[] entroyResult = Encrypt(encryption);
String result = new String(Base64.encode(entroyResult, 0), "UTF-8");
return result;
}
/**
* 解密数据
*
* @param toDecrypt
* 文本
* @return <br>
* 返回字符串
* @throws Exception
*/
public static String Decrypt(String decrypt) throws Exception {
byte[] data = Base64.decode(decrypt, 0);
// 秘钥
Key secretKey = new SecretKeySpec(getKey(), KEY_ALGORITHM);
Security.addProvider(new BouncyCastleProvider());
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
final byte[] mData = DISPLACEMENT.getBytes();
IvParameterSpec mIvParameterSpec = new IvParameterSpec(mData);
cipher.init(Cipher.DECRYPT_MODE, secretKey, mIvParameterSpec);
final byte[] mEncrypted = cipher.doFinal(data);
// 结果
final byte[] result = new byte[mEncrypted.length - mData.length];
System.arraycopy(mEncrypted, mData.length, result, 0, result.length);
return new String(result);
}
}
6、APP版本工具类
public class VersionUtil {
/**
* 获取应用程序名称
*
* @param context
* @return
*/
public static String getAppName(Context context) {
try {
PackageManager packageManager = context.getPackageManager();
PackageInfo packageInfo = packageManager.getPackageInfo(
context.getPackageName(), 0);
int labelRes = packageInfo.applicationInfo.labelRes;
return context.getResources().getString(labelRes);
} catch (PackageManager.NameNotFoundException e) {
e.printStackTrace();
}
return null;
}
/**
* 获取版本号
*
* @param context
* @return 当前应用的版本号
*/
public static String getVersion(Context context) {
try {
PackageManager manager = context.getPackageManager();
PackageInfo info = manager.getPackageInfo(context.getPackageName(),
0);
String version = info.versionName;
return version;
} catch (PackageManager.NameNotFoundException e) {
e.printStackTrace();
return "";
}
}
/**
* 版本比较
*
* @param nowVersion
* app版本
* @param serverVersion
* 服务器版本
* @return
*/
public static boolean compareVersion(String nowVersion, String serverVersion) {
if (nowVersion != null && serverVersion != null) {
String[] nowVersions = nowVersion.split("\\.");
String[] serverVersions = serverVersion.split("\\.");
if (nowVersion != null && serverVersion != null
&& nowVersions.length > 1 && serverVersions.length > 1) {
int nowVersionFirst = Integer.parseInt(nowVersions[0]);
int serverVersionFirst = Integer.parseInt(serverVersions[0]);
int nowVersionSecond = Integer.parseInt(nowVersions[1]);
int serverVersionSecond = Integer.parseInt(serverVersions[1]);
if (nowVersionFirst < serverVersionFirst) {
return true;
} else if (nowVersionFirst == serverVersionFirst
&& nowVersionSecond < serverVersionSecond) {
return true;
}
}
}
return false;
}
}
7、GlideUtils
话说用开源库的时候应该自行封装一下，为了后面修改方便。
public class GlideUtils {
public GlideUtils(){
throw new AssertionError();
}
/**
* 显示照片
* @param context
* @param imageView
* @param url
*/
public static void displays(Context context, ImageView imageView, Object url) {
Glide.with(context).load(url).skipMemoryCache(true) //跳过内存缓存
.diskCacheStrategy(DiskCacheStrategy.ALL) //硬盘缓存全部
.into(imageView);
}
/**
* 显示图片
* @param context
* @param imageView
* @param url
* @param tag
*/
public static void display(Context context, ImageView imageView, String url, Object tag) {
Glide.with(context).load(url).
error(R.drawable.ic_error).placeholder(R.drawable.ic_progress).into(imageView);
}
public static void display(Context context, ImageView imageView, String url, int progressId) {
RequestManager manager = Glide.with(context);
DrawableTypeRequest<String> load = manager.load(url);
load.error(R.drawable.ic_error).placeholder(new ColorDrawable(Color.GRAY)).into
(imageView);
if (progressId != -1) {
load.placeholder(progressId);
}
}
public static void display(Context context, ImageView imageView, String url) {
display(context, imageView, url, -1);
}
public static void cancel(Context context) {
}
/**
* 设置磁盘缓存大小和位置,这里设置150M
*/
public static void setInnerCacheDir(Context context){
GlideBuilder builder = new GlideBuilder(context);
builder.setDiskCache(new InternalCacheDiskCacheFactory(context, "ImgCache", 150 * 1024 * 1024));
}
/**
* 可以用ExternalCacheDiskCacheFactory来把你的磁盘缓存放到sd卡的公共缓存目录上,这里默认设置150M
*/
public static void setDiskCacheDir(Context context){
GlideBuilder builder = new GlideBuilder(context);
builder.setDiskCache( new ExternalCacheDiskCacheFactory(context, "ImgCache", 150 * 1024 * 1024));
}
/**
* 清除缓存
*/
public static void clearCache(final Context context){
Glide.get(context).clearMemory(); //清理内存缓存
new Thread(new Runnable() {
@Override
public void run() {
Glide.get(context).clearDiskCache(); //清理磁盘缓存
}
}).start();
}
}
8、缓存工具类
public class CacheUtil {
public CacheUtil() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/**
* 得到缓存大小
*
* @param context 上下文
* @return
* @throws IOException
*/
public static String getTotalCacheSize(Context context) throws IOException {
//缓存大小
long cacheSize = getFolderSize(context.getCacheDir());
// 如果SD卡正常挂载才可以创建文件或者写入文件等
if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
cacheSize += getFolderSize(context.getCacheDir());
}
return getFormatSize(cacheSize);
}
/**
* 得到临时缓存数据
*
* @param file
* @return
* @throws IOException
*/
public static long getFolderSize(File file) throws IOException {
long size = 0;
//文件
File[] fileList = file.listFiles();
for (int i = 0; i < fileList.length; i++) {
if (fileList[i].isDirectory()) {
size = size + getFolderSize(fileList[i]);
} else {
size = size + fileList[i].length();
}
}
return size;
}
/**
* 清除所有缓存
*/
public static void clearAllCache(Context context) {
//删除缓存
deleteDir(context.getCacheDir());
//如果存在SD卡则删除本地缓存
if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
deleteDir(context.getExternalCacheDir());
}
}
/**
* 是否删除文件
*
* @return
*/
public static boolean deleteDir(File dir) {
// 文件不为空并且是一个文件夹时
if (dir != null && dir.isDirectory()) {
//得到文件集合
String[] child = dir.list();
for (int i = 0; i < child.length; i++) {
//是否删除成功
boolean isSuccess = deleteDir(new File(dir, child[i]));
if (!isSuccess) {
return false;
}
}
}
return dir.delete();
}
/**
* 格式化
*
* @return
*/
public static String getFormatSize(double size) {
//KB
double kiloByte = size / 1024;
if (kiloByte<1){
return size+"Byte";
}
//MB
double megaByte=kiloByte/1024;
if (megaByte<1){
//高精度计算结果
BigDecimal result1=new BigDecimal(Double.toString(kiloByte));
//四舍五入
return result1.setScale(2,BigDecimal.ROUND_HALF_UP).toPlainString()+"KB";
}
//GB
double gigaByte = megaByte/1024;
if (gigaByte<1){
BigDecimal result2= new BigDecimal(Double.toString(megaByte));
return result2.setScale(2,BigDecimal.ROUND_HALF_UP).toPlainString()+"MB";
}
//TB
double teraByte =gigaByte/1024;
if (teraByte<1){
BigDecimal result3= new BigDecimal(Double.toString(gigaByte));
return result3.setScale(2,BigDecimal.ROUND_HALF_UP).toPlainString()+"GB";
}
BigDecimal result4= new BigDecimal(teraByte);
return result4.setScale(2,BigDecimal.ROUND_HALF_UP).toPlainString()+"TB";
}
}
9、SharedPreferences封装类
public class SPUtils {
/**
* 保存在手机里面的文件名
*/
public static final String FILE_NAME = "share_data";
/**
* 保存数据的方法，我们需要拿到保存数据的具体类型，然后根据类型调用不同的保存方法
*
* @param context
* @param key
* @param object
*/
public static void put(Context context, String key, Object object) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
if (object instanceof String) {
editor.putString(key, (String) object);
} else if (object instanceof Integer) {
editor.putInt(key, (Integer) object);
} else if (object instanceof Boolean) {
editor.putBoolean(key, (Boolean) object);
} else if (object instanceof Float) {
editor.putFloat(key, (Float) object);
} else if (object instanceof Long) {
editor.putLong(key, (Long) object);
} else {
editor.putString(key, object.toString());
}
/**
* commit操作使用了SharedPreferencesCompat.apply进行了替代，目的是尽可能的使用apply代替commit
* 因为commit方法是同步的，并且我们很多时候的commit操作都是UI线程中，毕竟是IO操作，尽可能异步；
*/
SharedPreferencesCompat.apply(editor);
}
/**
* 得到保存数据的方法，我们根据默认值得到保存的数据的具体类型，然后调用相对于的方法获取值
*
* @param context
* @param key
* @param defaultObject
* @return
*/
public static Object get(Context context, String key, Object defaultObject) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
Context.MODE_PRIVATE);
if (defaultObject instanceof String) {
return sp.getString(key, (String) defaultObject);
} else if (defaultObject instanceof Integer) {
return sp.getInt(key, (Integer) defaultObject);
} else if (defaultObject instanceof Boolean) {
return sp.getBoolean(key, (Boolean) defaultObject);
} else if (defaultObject instanceof Float) {
return sp.getFloat(key, (Float) defaultObject);
} else if (defaultObject instanceof Long) {
return sp.getLong(key, (Long) defaultObject);
}
return null;
}
/**
* 移除某个key值已经对应的值
*
* @param context
* @param key
*/
public static void remove(Context context, String key) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
editor.remove(key);
SharedPreferencesCompat.apply(editor);
}
/**
* 清除所有数据
*
* @param context
*/
public static void clear(Context context) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
editor.clear();
SharedPreferencesCompat.apply(editor);
}
/**
* 查询某个key是否已经存在
*
* @param context
* @param key
* @return
*/
public static boolean contains(Context context, String key) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
Context.MODE_PRIVATE);
return sp.contains(key);
}
/**
* 返回所有的键值对
*
* @param context
* @return
*/
public static Map<String, ?> getAll(Context context) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
Context.MODE_PRIVATE);
return sp.getAll();
}
/**
* 创建一个解决SharedPreferencesCompat.apply方法的一个兼容类
*
* @author dj
*/
private static class SharedPreferencesCompat {
private static final Method sApplyMethod = findApplyMethod();
/**
* 反射查找apply的方法
*
* @return
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
private static Method findApplyMethod() {
try {
Class clz = SharedPreferences.Editor.class;
return clz.getMethod("apply");
} catch (NoSuchMethodException e) {
}
return null;
}
/**
* 如果找到则使用apply执行，否则使用commit
*
* @param editor
*/
public static void apply(SharedPreferences.Editor editor) {
try {
if (sApplyMethod != null) {
sApplyMethod.invoke(editor);
return;
}
} catch (IllegalArgumentException e) {
} catch (IllegalAccessException e) {
} catch (InvocationTargetException e) {
e.printStackTrace();
}
editor.commit();
}
}
}
10、手机信息采集工具类
public class MobileUtil {
/**
* Print telephone info.
*/
public static String printMobileInfo(Context context) {
Date date = new Date(System.currentTimeMillis());
SimpleDateFormat dateFormat = new SimpleDateFormat(
"yyyy-MM-dd HH:mm:ss");
String time = dateFormat.format(date);
StringBuilder sb = new StringBuilder();
sb.append("系统时间：").append(time).append("\n");
TelephonyManager tm = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
String IMSI = tm.getSubscriberId();
// IMSI前面三位460是国家号码，其次的两位是运营商代号，00、02是中国移动，01是联通，03是电信。
String providerName = null;
if (IMSI != null) {
if (IMSI.startsWith("46000") || IMSI.startsWith("46002")) {
providerName = "中国移动";
} else if (IMSI.startsWith("46001")) {
providerName = "中国联通";
} else if (IMSI.startsWith("46003")) {
providerName = "中国电信";
}
}
sb.append(providerName).append("\n")
.append(getNativePhoneNumber(context)).append("\n网络模式：")
.append(getNetType(context)).append("\nIMSI是：").append(IMSI);
sb.append("\nDeviceID(IMEI) :").append(tm.getDeviceId());
sb.append("\nDeviceSoftwareVersion:").append(
tm.getDeviceSoftwareVersion());
sb.append("\ngetLine1Number :").append(tm.getLine1Number());
sb.append("\nNetworkCountryIso :").append(tm.getNetworkCountryIso());
sb.append("\nNetworkOperator :").append(tm.getNetworkOperator());
sb.append("\nNetworkOperatorName :").append(
tm.getNetworkOperatorName());
sb.append("\nNetworkType :").append(tm.getNetworkType());
sb.append("\nPhoneType :").append(tm.getPhoneType());
sb.append("\nSimCountryIso :").append(tm.getSimCountryIso());
sb.append("\nSimOperator :").append(tm.getSimOperator());
sb.append("\nSimOperatorName :").append(tm.getSimOperatorName());
sb.append("\nSimSerialNumber :").append(tm.getSimSerialNumber());
sb.append("\ngetSimState :").append(tm.getSimState());
sb.append("\nSubscriberId :").append(tm.getSubscriberId());
sb.append("\nVoiceMailNumber :").append(tm.getVoiceMailNumber());
return sb.toString();
}
/**
* 打印系统信息
*
* @return
*/
public static String printSystemInfo() {
Date date = new Date(System.currentTimeMillis());
SimpleDateFormat dateFormat = new SimpleDateFormat(
"yyyy-MM-dd HH:mm:ss");
String time = dateFormat.format(date);
StringBuilder sb = new StringBuilder();
sb.append("_______ 系统信息 ").append(time).append(" ______________");
sb.append("\nID :").append(Build.ID);
sb.append("\nBRAND :").append(Build.BRAND);
sb.append("\nMODEL :").append(Build.MODEL);
sb.append("\nRELEASE :").append(Build.VERSION.RELEASE);
sb.append("\nSDK :").append(Build.VERSION.SDK);
sb.append("\n_______ OTHER _______");
sb.append("\nBOARD :").append(Build.BOARD);
sb.append("\nPRODUCT :").append(Build.PRODUCT);
sb.append("\nDEVICE :").append(Build.DEVICE);
sb.append("\nFINGERPRINT :").append(Build.FINGERPRINT);
sb.append("\nHOST :").append(Build.HOST);
sb.append("\nTAGS :").append(Build.TAGS);
sb.append("\nTYPE :").append(Build.TYPE);
sb.append("\nTIME :").append(Build.TIME);
sb.append("\nINCREMENTAL :").append(Build.VERSION.INCREMENTAL);
sb.append("\n_______ CUPCAKE-3 _______");
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.CUPCAKE) {
sb.append("\nDISPLAY :").append(Build.DISPLAY);
}
sb.append("\n_______ DONUT-4 _______");
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.DONUT) {
sb.append("\nSDK_INT :").append(Build.VERSION.SDK_INT);
sb.append("\nMANUFACTURER :").append(Build.MANUFACTURER);
sb.append("\nBOOTLOADER :").append(Build.BOOTLOADER);
sb.append("\nCPU_ABI :").append(Build.CPU_ABI);
sb.append("\nCPU_ABI2 :").append(Build.CPU_ABI2);
sb.append("\nHARDWARE :").append(Build.HARDWARE);
sb.append("\nUNKNOWN :").append(Build.UNKNOWN);
sb.append("\nCODENAME :").append(Build.VERSION.CODENAME);
}
sb.append("\n_______ GINGERBREAD-9 _______");
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
sb.append("\nSERIAL :").append(Build.SERIAL);
}
return sb.toString();
}
/****
* 获取网络类型
*
* @param context
* @return
*/
public static String getNetType(Context context) {
try {
ConnectivityManager connectMgr = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo info = connectMgr.getActiveNetworkInfo();
if (info == null) {
return "";
}
if (info.getType() == ConnectivityManager.TYPE_WIFI) {
return "WIFI";
} else if (info.getType() == ConnectivityManager.TYPE_MOBILE) {
if (info.getSubtype() == TelephonyManager.NETWORK_TYPE_CDMA) {
return "CDMA";
} else if (info.getSubtype() == TelephonyManager.NETWORK_TYPE_EDGE) {
return "EDGE";
} else if (info.getSubtype() == TelephonyManager.NETWORK_TYPE_EVDO_0) {
return "EVDO0";
} else if (info.getSubtype() == TelephonyManager.NETWORK_TYPE_EVDO_A) {
return "EVDOA";
} else if (info.getSubtype() == TelephonyManager.NETWORK_TYPE_GPRS) {
return "GPRS";
}
/*
* else if(info.getSubtype() ==
* TelephonyManager.NETWORK_TYPE_HSDPA){ return "HSDPA"; }else
* if(info.getSubtype() == TelephonyManager.NETWORK_TYPE_HSPA){
* return "HSPA"; }else if(info.getSubtype() ==
* TelephonyManager.NETWORK_TYPE_HSUPA){ return "HSUPA"; }
*/
else if (info.getSubtype() == TelephonyManager.NETWORK_TYPE_UMTS) {
return "UMTS";
} else {
return "3G";
}
} else {
return "";
}
} catch (Exception e) {
return "";
}
}
/**
* 获取当前设置的电话号码
*/
public static String getNativePhoneNumber(Context context) {
TelephonyManager telephonyManager = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
String NativePhoneNumber = null;
NativePhoneNumber = telephonyManager.getLine1Number();
return String.format("手机号: %s", NativePhoneNumber);
}
/**
* IMSI是国际移动用户识别码的简称(International Mobile Subscriber Identity)
* IMSI共有15位，其结构如下： <br>
* MCC+MNC+MIN <br>
* MCC：Mobile Country Code，移动国家码，共3位，中国为460;<br>
* MNC:Mobile NetworkCode，移动网络码，共2位 <br>
* 在中国，移动的代码为电00和02，联通的代码为01，电信的代码为03<br>
* 合起来就是（也是Android手机中APN配置文件中的代码）： <br>
* 中国移动：46000 46002 <br>
* 中国联通：46001 <br>
* 中国电信：46003 <br>
* 举例，一个典型的IMSI号码为460030912121001 <br>
*/
public static String getIMSI(Context context) {
TelephonyManager telephonyManager = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
String IMSI = telephonyManager.getSubscriberId();
return IMSI;
}
/**
* IMEI是International Mobile Equipment Identity （国际移动设备标识）的简称
* IMEI由15位数字组成的”电子串号”，它与每台手机一一对应，而且该码是全世界唯一的 其组成为：
* 1.前6位数(TAC)是”型号核准号码”，一般代表机型 <br>
* 2. 接着的2位数(FAC)是”最后装配号”，一般代表产地 <br>
* 3.之后的6位数(SNR)是”串号”，一般代表生产顺序号 <br>
* 4. 最后1位数(SP)通常是”0″，为检验码，目前暂备用<br>
*/
public static String getIMEI(Context context) {
TelephonyManager telephonyManager = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
String IMEI = telephonyManager.getDeviceId();
return IMEI;
}
// ///_________________ 双卡双待系统IMEI和IMSI方案（see more on
// http://benson37.iteye.com/blog/1923946）
/**
* 双卡双待神机IMSI、IMSI、PhoneType信息 <uses-permission
* android:name="android.permission.READ_PHONE_STATE"/>
*/
public static class TeleInfo {
public String imsi_1;
public String imsi_2;
public String imei_1;
public String imei_2;
public int phoneType_1;
public int phoneType_2;
@Override
public String toString() {
return "TeleInfo{" + "imsi_1='" + imsi_1 + '\'' + ", imsi_2='"
+ imsi_2 + '\'' + ", imei_1='" + imei_1 + '\''
+ ", imei_2='" + imei_2 + '\'' + ", phoneType_1="
+ phoneType_1 + ", phoneType_2=" + phoneType_2 + '}';
}
}
/**
* MTK Phone.
* <p>
* 获取 MTK 神机的双卡 IMSI、IMSI 信息
*/
public static TeleInfo getMtkTeleInfo(Context context) {
TeleInfo teleInfo = new TeleInfo();
try {
Class<?> phone = Class
.forName("com.android.internal.telephony.Phone");
Field fields1 = phone.getField("GEMINI_SIM_1");
fields1.setAccessible(true);
int simId_1 = (Integer) fields1.get(null);
Field fields2 = phone.getField("GEMINI_SIM_2");
fields2.setAccessible(true);
int simId_2 = (Integer) fields2.get(null);
TelephonyManager tm = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
Method getSubscriberIdGemini = TelephonyManager.class
.getDeclaredMethod("getSubscriberIdGemini", int.class);
String imsi_1 = (String) getSubscriberIdGemini.invoke(tm, simId_1);
String imsi_2 = (String) getSubscriberIdGemini.invoke(tm, simId_2);
teleInfo.imsi_1 = imsi_1;
teleInfo.imsi_2 = imsi_2;
Method getDeviceIdGemini = TelephonyManager.class
.getDeclaredMethod("getDeviceIdGemini", int.class);
String imei_1 = (String) getDeviceIdGemini.invoke(tm, simId_1);
String imei_2 = (String) getDeviceIdGemini.invoke(tm, simId_2);
teleInfo.imei_1 = imei_1;
teleInfo.imei_2 = imei_2;
Method getPhoneTypeGemini = TelephonyManager.class
.getDeclaredMethod("getPhoneTypeGemini", int.class);
int phoneType_1 = (Integer) getPhoneTypeGemini.invoke(tm, simId_1);
int phoneType_2 = (Integer) getPhoneTypeGemini.invoke(tm, simId_2);
teleInfo.phoneType_1 = phoneType_1;
teleInfo.phoneType_2 = phoneType_2;
} catch (Exception e) {
e.printStackTrace();
}
return teleInfo;
}
/**
* MTK Phone.
* <p>
* 获取 MTK 神机的双卡 IMSI、IMSI 信息
*/
public static TeleInfo getMtkTeleInfo2(Context context) {
TeleInfo teleInfo = new TeleInfo();
try {
TelephonyManager tm = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
Class<?> phone = Class
.forName("com.android.internal.telephony.Phone");
Field fields1 = phone.getField("GEMINI_SIM_1");
fields1.setAccessible(true);
int simId_1 = (Integer) fields1.get(null);
Field fields2 = phone.getField("GEMINI_SIM_2");
fields2.setAccessible(true);
int simId_2 = (Integer) fields2.get(null);
Method getDefault = TelephonyManager.class.getMethod("getDefault",
int.class);
TelephonyManager tm1 = (TelephonyManager) getDefault.invoke(tm,
simId_1);
TelephonyManager tm2 = (TelephonyManager) getDefault.invoke(tm,
simId_2);
String imsi_1 = tm1.getSubscriberId();
String imsi_2 = tm2.getSubscriberId();
teleInfo.imsi_1 = imsi_1;
teleInfo.imsi_2 = imsi_2;
String imei_1 = tm1.getDeviceId();
String imei_2 = tm2.getDeviceId();
teleInfo.imei_1 = imei_1;
teleInfo.imei_2 = imei_2;
int phoneType_1 = tm1.getPhoneType();
int phoneType_2 = tm2.getPhoneType();
teleInfo.phoneType_1 = phoneType_1;
teleInfo.phoneType_2 = phoneType_2;
} catch (Exception e) {
e.printStackTrace();
}
return teleInfo;
}
/**
* Qualcomm Phone. 获取 高通 神机的双卡 IMSI、IMSI 信息
*/
public static TeleInfo getQualcommTeleInfo(Context context) {
TeleInfo teleInfo = new TeleInfo();
try {
TelephonyManager tm = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
Class<?> simTMclass = Class
.forName("android.telephony.MSimTelephonyManager");
// Object sim = context.getSystemService("phone_msim");
Object sim = context.getSystemService(Context.TELEPHONY_SERVICE);
int simId_1 = 0;
int simId_2 = 1;
Method getSubscriberId = simTMclass.getMethod("getSubscriberId",
int.class);
String imsi_1 = (String) getSubscriberId.invoke(sim, simId_1);
String imsi_2 = (String) getSubscriberId.invoke(sim, simId_2);
teleInfo.imsi_1 = imsi_1;
teleInfo.imsi_2 = imsi_2;
Method getDeviceId = simTMclass.getMethod("getDeviceId", int.class);
String imei_1 = (String) getDeviceId.invoke(sim, simId_1);
String imei_2 = (String) getDeviceId.invoke(sim, simId_2);
teleInfo.imei_1 = imei_1;
teleInfo.imei_2 = imei_2;
Method getDataState = simTMclass.getMethod("getDataState");
int phoneType_1 = tm.getDataState();
int phoneType_2 = (Integer) getDataState.invoke(sim);
teleInfo.phoneType_1 = phoneType_1;
teleInfo.phoneType_2 = phoneType_2;
} catch (Exception e) {
e.printStackTrace();
}
return teleInfo;
}
/**
* Spreadtrum Phone.
* <p>
* 获取 展讯 神机的双卡 IMSI、IMSI 信息
*/
public static TeleInfo getSpreadtrumTeleInfo(Context context) {
TeleInfo teleInfo = new TeleInfo();
try {
TelephonyManager tm1 = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
String imsi_1 = tm1.getSubscriberId();
String imei_1 = tm1.getDeviceId();
int phoneType_1 = tm1.getPhoneType();
teleInfo.imsi_1 = imsi_1;
teleInfo.imei_1 = imei_1;
teleInfo.phoneType_1 = phoneType_1;
Class<?> phoneFactory = Class
.forName("com.android.internal.telephony.PhoneFactory");
Method getServiceName = phoneFactory.getMethod("getServiceName",
String.class, int.class);
getServiceName.setAccessible(true);
TelephonyManager tm2 = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
String imsi_2 = tm2.getSubscriberId();
String imei_2 = tm2.getDeviceId();
int phoneType_2 = tm2.getPhoneType();
teleInfo.imsi_2 = imsi_2;
teleInfo.imei_2 = imei_2;
teleInfo.phoneType_2 = phoneType_2;
} catch (Exception e) {
e.printStackTrace();
}
return teleInfo;
}
/**
* 获取 MAC 地址 <uses-permission
* android:name="android.permission.ACCESS_WIFI_STATE"/>
*/
public static String getMacAddress(Context context) {
// wifi mac地址
WifiManager wifi = (WifiManager) context
.getSystemService(Context.WIFI_SERVICE);
WifiInfo info = wifi.getConnectionInfo();
String mac = info.getMacAddress();
return mac;
}
/**
* 获取 开机时间
*/
public static String getBootTimeString() {
long ut = SystemClock.elapsedRealtime() / 1000;
int h = (int) ((ut / 3600));
int m = (int) ((ut / 60) % 60);
return h + ":" + m;
}
}
11、CommonUtils
public class CommonUtils {
static Context context;
// 手机网络类型
public static final int NETTYPE_WIFI = 0x01;
public static final int NETTYPE_CMWAP = 0x02;
public static final int NETTYPE_CMNET = 0x03;
public static boolean GTE_HC;
public static boolean GTE_ICS;
public static boolean PRE_HC;
private static Boolean _hasBigScreen = null;
private static Boolean _hasCamera = null;
private static Boolean _isTablet = null;
private static Integer _loadFactor = null;
private static int _pageSize = -1;
public static float displayDensity = 0.0F;
public static final String TAG = context.getClass().getSimpleName();
static {
GTE_ICS = Build.VERSION.SDK_INT >= 14;
GTE_HC = Build.VERSION.SDK_INT >= 11;
PRE_HC = Build.VERSION.SDK_INT >= 11 ? false : true;
}
public CommonUtils() {
throw new AssertionError();
}
/**
* 获取系统当前当前时间戳
*/
public static String getTimesTamp() {
long timestamp = System.currentTimeMillis() / 1000;
return String.valueOf(timestamp);
}
public static int[] getRealScreenSize(Activity activity) {
int[] size = new int[2];
int screenWidth = 0, screenHeight = 0;
WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
screenWidth = metrics.widthPixels;
screenHeight = metrics.heightPixels;
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 14 && Build.VERSION.SDK_INT < 17)
try {
screenWidth = (Integer) Display.class.getMethod("getRawWidth")
.invoke(d);
screenHeight = (Integer) Display.class
.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 17)
try {
Point realSize = new Point();
Display.class.getMethod("getRealSize", Point.class).invoke(d,
realSize);
screenWidth = realSize.x;
screenHeight = realSize.y;
} catch (Exception ignored) {
}
size[0] = screenWidth;
size[1] = screenHeight;
return size;
}
/**
* 是否存在相机
*
* @return
*/
public static final boolean hasCamera(Context context) {
if (_hasCamera == null) {
PackageManager pckMgr = context.getPackageManager();
boolean flag = pckMgr
.hasSystemFeature("android.hardware.camera.front");
boolean flag1 = pckMgr.hasSystemFeature("android.hardware.camera");
boolean flag2;
if (flag || flag1)
flag2 = true;
else
flag2 = false;
_hasCamera = Boolean.valueOf(flag2);
}
return _hasCamera.booleanValue();
}
/**
* 判断是否有物理的menu键
*
* @param context
* @return
*/
public static boolean hasHardwareMenuKey(Context context) {
boolean flag = false;
if (PRE_HC)
flag = true;
else if (GTE_ICS) {
flag = ViewConfiguration.get(context).hasPermanentMenuKey();
} else
flag = false;
return flag;
}
/**
* 是否有google商店
*
* @param activity
* @param pck
* @return
*/
public static boolean gotoGoogleMarket(Activity activity, String pck) {
try {
Intent intent = new Intent();
intent.setPackage("com.android.vending");
intent.setAction(Intent.ACTION_VIEW);
intent.setData(Uri.parse("market://details?id=" + pck));
activity.startActivity(intent);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 隐藏动画视图
*
* @param view
*/
public static void hideAnimatedView(View view) {
if (PRE_HC && view != null)
view.setPadding(view.getWidth(), 0, 0, 0);
}
/**
* 显示动画视图
*
* @param view
*/
public static void showAnimatedView(View view) {
if (PRE_HC && view != null)
view.setPadding(0, 0, 0, 0);
}
/**
* 显示键盘dialog
*
* @param dialog
*/
public static void showSoftKeyboard(Dialog dialog) {
dialog.getWindow().setSoftInputMode(4);
}
/**
* 切换键盘
*
* @param view
*/
public static void toogleSoftKeyboard(Context context, View view) {
((InputMethodManager) context
.getSystemService(Context.INPUT_METHOD_SERVICE))
.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS);
}
/**
* 判断是否横屏
*
* @return
*/
public static boolean isLandscape(Context context) {
boolean flag;
if (context.getResources().getConfiguration().orientation == 2)
flag = true;
else
flag = false;
return flag;
}
/**
* 判断是否竖屏
*
* @return
*/
public static boolean isPortrait(Context context) {
boolean flag = true;
if (context.getResources().getConfiguration().orientation != 1)
flag = false;
return flag;
}
/**
* 判断是否平板
*
* @return
*/
public static boolean isTablet(Context context) {
if (_isTablet == null) {
boolean flag;
if ((0xf & context.getResources().getConfiguration().screenLayout) >= 3)
flag = true;
else
flag = false;
_isTablet = Boolean.valueOf(flag);
}
return _isTablet.booleanValue();
}
/**
* 判断是否有sd卡
*
* @return
*/
public static boolean isSdcardReady() {
return Environment.MEDIA_MOUNTED.equals(Environment
.getExternalStorageState());
}
/**
* 判断系统语言国家
*
* @return
*/
public static String getCurCountryLan(Context context) {
return context.getResources().getConfiguration().locale.getLanguage()
+ "-"
+ context.getResources().getConfiguration().locale.getCountry();
}
/**
* 判断是否中文简体（CN）国家中国
*
* @return
*/
public static boolean isZhCN(Context context) {
String lang = context.getResources().getConfiguration().locale
.getCountry();
if (lang.equalsIgnoreCase("CN")) {
return true;
}
return false;
}
/**
* 获取两个数的百分比
*
* @param p1
* @param p2
* @return
*/
public static String percent(double p1, double p2) {
String str;
double p3 = p1 / p2;
NumberFormat nf = NumberFormat.getPercentInstance();
nf.setMinimumFractionDigits(5);// 保留的小数位数(精度)
str = nf.format(p3);
return str;
}
public static String percent2(double p1, double p2) {
String str;
double p3 = p1 / p2;
NumberFormat nf = NumberFormat.getPercentInstance();
nf.setMinimumFractionDigits(0);
str = nf.format(p3);
return str;
}
/**
* 打开本app在应用商店的页面
*
* @param context
*/
public static void openAppInMarket(Context context) {
if (context != null) {
String pckName = context.getPackageName();
try {
String str = "market://details?id=" + pckName;
Intent localIntent = new Intent("android.intent.action.VIEW");
localIntent.setData(Uri.parse(str));
context.startActivity(localIntent);
} catch (Exception ex) {
}
}
}
/**
* 全屏显示，去掉顶部状态栏
*
* @param activity
*/
public static void setFullScreen(Activity activity) {
WindowManager.LayoutParams params = activity.getWindow()
.getAttributes();
params.flags |= WindowManager.LayoutParams.FLAG_FULLSCREEN;
activity.getWindow().setAttributes(params);
activity.getWindow().addFlags(
WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);
}
/**
* 关闭全屏显示
*
* @param activity
*/
public static void cancelFullScreen(Activity activity) {
WindowManager.LayoutParams params = activity.getWindow()
.getAttributes();
params.flags &= (~WindowManager.LayoutParams.FLAG_FULLSCREEN);
activity.getWindow().setAttributes(params);
activity.getWindow().clearFlags(
WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);
}
/**
* 得到应用包名
*
* @param pckName
* @return
*/
public static PackageInfo getPackageInfo(Context context, String pckName) {
try {
return context.getPackageManager().getPackageInfo(pckName, 0);
} catch (PackageManager.NameNotFoundException e) {
Log.e("", e.getMessage());
}
return null;
}
/**
* 获取版本名称
*
* @return
*/
public static String getVersionName(Context context) {
String name = "";
try {
name = context.getPackageManager().getPackageInfo(
context.getPackageName(), 0).versionName;
} catch (PackageManager.NameNotFoundException ex) {
name = "";
}
return name;
}
/**
* 安装apk
*
* @param context
* @param file
*/
public static void installAPK(Context context, File file) {
if (file == null || !file.exists())
return;
Intent intent = new Intent();
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.setAction(Intent.ACTION_VIEW);
intent.setDataAndType(Uri.fromFile(file),
"application/vnd.android.package-archive");
context.startActivity(intent);
}
/**
* 获得安转的apk
*
* @param file
* @return
*/
public static Intent getInstallApkIntent(File file) {
Intent intent = new Intent();
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.setAction(Intent.ACTION_VIEW);
intent.setDataAndType(Uri.fromFile(file),
"application/vnd.android.package-archive");
return intent;
}
/**
* 打电话
*
* @param context
* @param number
*/
public static void openDial(Context context, String number) {
Uri uri = Uri.parse("tel:" + number);
Intent it = new Intent(Intent.ACTION_DIAL, uri);
context.startActivity(it);
}
/**
* 发短信
*
* @param context
* @param smsBody
* @param tel
*/
public static void openSMS(Context context, String smsBody, String tel) {
Uri uri = Uri.parse("smsto:" + tel);
Intent it = new Intent(Intent.ACTION_SENDTO, uri);
it.putExtra("sms_body", smsBody);
context.startActivity(it);
}
public static void openDail(Context context) {
Intent intent = new Intent(Intent.ACTION_DIAL);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(intent);
}
public static void openSendMsg(Context context) {
Uri uri = Uri.parse("smsto:");
Intent intent = new Intent(Intent.ACTION_SENDTO, uri);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(intent);
}
/**
* 调用系统相机
*
* @param context
*/
public static void openCamera(Context context) {
Intent intent = new Intent(); // 调用照相机
intent.setAction("android.media.action.STILL_IMAGE_CAMERA");
intent.setFlags(0x34c40000);
context.startActivity(intent);
}
/**
* 获取移动设备标识码 需要权限android.permission.READ_PHONE_STATE
*
* @return
*/
public static String getIMEI(Context context) {
TelephonyManager tel = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
return tel.getDeviceId();
}
/**
* 获得手机型号
*
* @return
*/
public static String getPhoneType() {
return Build.MODEL;
}
/**
* 打开手机上安装的指定包名的app
*
* @param context
* @param packageName
*/
public static void openApp(Context context, String packageName) {
Intent mainIntent = context.getPackageManager()
.getLaunchIntentForPackage(packageName);
if (mainIntent == null) {
mainIntent = new Intent(packageName);
} else {
Log.i(TAG, "Action:" + mainIntent.getAction());
}
context.startActivity(mainIntent);
}
public static boolean openAppActivity(Context context, String packageName,
String activityName) {
Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_LAUNCHER);
ComponentName cn = new ComponentName(packageName, activityName);
intent.setComponent(cn);
try {
context.startActivity(intent);
return true;
} catch (Exception e) {
return false;
}
}
/**
* 发送邮件
*
* @param context
* @param subject
* 主题
* @param content
* 内容
* @param emails
* 邮件地址
*/
public static void sendEmail(Context context, String subject,
String content, String... emails) {
try {
Intent intent = new Intent(Intent.ACTION_SEND);
// 模拟器
// intent.setType("text/plain");
intent.setType("message/rfc822"); // 真机
intent.putExtra(Intent.EXTRA_EMAIL, emails);
intent.putExtra(Intent.EXTRA_SUBJECT, subject);
intent.putExtra(Intent.EXTRA_TEXT, content);
context.startActivity(intent);
} catch (ActivityNotFoundException e) {
e.printStackTrace();
}
}
public static boolean hasStatusBar(Activity activity) {
WindowManager.LayoutParams attrs = activity.getWindow().getAttributes();
if ((attrs.flags & WindowManager.LayoutParams.FLAG_FULLSCREEN) == WindowManager.LayoutParams.FLAG_FULLSCREEN) {
return false;
} else {
return true;
}
}
/**
* 调用系统安装了的应用分享
*
* @param context
* @param title
* @param url
*/
public static void showSystemShareOption(Activity context,
final String title, final String url) {
Intent intent = new Intent(Intent.ACTION_SEND);
intent.setType("text/plain");
intent.putExtra(Intent.EXTRA_SUBJECT, "分享：" + title);
intent.putExtra(Intent.EXTRA_TEXT, title + " " + url);
context.startActivity(Intent.createChooser(intent, "选择分享"));
}
/**
* 获取当前网络类型
*
* @return 0：没有网络 1：WIFI网络 2：WAP网络 3：NET网络
*/
public static int getNetworkType(Context context) {
int netType = 0;
ConnectivityManager connectivityManager = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
if (networkInfo == null) {
return netType;
}
int nType = networkInfo.getType();
if (nType == ConnectivityManager.TYPE_MOBILE) {
String extraInfo = networkInfo.getExtraInfo();
if (!TextUtils.isEmpty(extraInfo)) {
if (extraInfo.toLowerCase().equals("cmnet")) {
netType = NETTYPE_CMNET;
} else {
netType = NETTYPE_CMWAP;
}
}
} else if (nType == ConnectivityManager.TYPE_WIFI) {
netType = NETTYPE_WIFI;
}
return netType;
}
}
12、打开地图工具类
public class OpenLocalMapUtil {
public OpenLocalMapUtil() {
throw new AssertionError();
}
/**
* 高德地图应用是否安装
*
* @return
*/
public static boolean isGdMapInstalled() {
return isInstallPackage("com.autonavi.minimap");
}
/**
* 百度地图应用是否安装
*
* @return
*/
public static boolean isBaiduMapInstalled() {
return isInstallPackage("com.baidu.BaiduMap");
}
private static boolean isInstallPackage(String packageName) {
return new File("/data/data/" + packageName).exists();
}
/**
* 获取打开百度地图应用uri [http://lbsyun.baidu.com/index.php?title=uri/api/android]
*
* @param originLat
* @param originLon
* @param desLat
* @param desLon
* @return
*/
public static String getBaiduMapUri(String originLat, String originLon,
String originName, String desLat, String desLon,
String destination, String region, String src) {
String uri = "intent://map/direction?origin=latlng:%1$s,%2$s|name:%3$s"
+ "&destination=latlng:%4$s,%5$s|name:%6$s&mode=driving®ion=%7$s&src=%8$s#Intent;"
+ "scheme=bdapp;package=com.baidu.BaiduMap;end";
return String.format(uri, originLat, originLon, originName, desLat,
desLon, destination, region, src);
}
/**
* 获取打开高德地图应用uri
*/
public static String getGdMapUri(String appName, String slat, String slon,
String sname, String dlat, String dlon, String dname) {
String uri = "androidamap://route?sourceApplication=%1$s&slat=%2$s&slon=%3$s&sname=%4$s&dlat=%5$s&dlon=%6$s&dname=%7$s&dev=0&m=0&t=2";
return String
.format(uri, appName, slat, slon, sname, dlat, dlon, dname);
}
/**
* 网页版百度地图 有经纬度
*
* @param originLat
* @param originLon
* @param originName
* ->注：必填
* @param desLat
* @param desLon
* @param destination
* @param region
* : 当给定region时，认为起点和终点都在同一城市，除非单独给定起点或终点的城市。-->注：必填，不填不会显示导航路线
* @param appName
* @return
*/
public static String getWebBaiduMapUri(String originLat, String originLon,
String originName, String desLat, String desLon,
String destination, String region, String appName) {
String uri = "http://api.map.baidu.com/direction?origin=latlng:%1$s,%2$s|name:%3$s"
+ "&destination=latlng:%4$s,%5$s|name:%6$s&mode=driving®ion=%7$s&output=html"
+ "&src=%8$s";
return String.format(uri, originLat, originLon, originName, desLat,
desLon, destination, region, appName);
}
/**
* 百度地图定位经纬度转高德经纬度
*
* @param bd_lat
* @param bd_lon
* @return
*/
public static double[] bdToGaoDe(double bd_lat, double bd_lon) {
double[] gd_lat_lon = new double[2];
double PI = 3.14159265358979324 * 3000.0 / 180.0;
double x = bd_lon - 0.0065, y = bd_lat - 0.006;
double z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * PI);
double theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * PI);
gd_lat_lon[0] = z * Math.cos(theta);
gd_lat_lon[1] = z * Math.sin(theta);
return gd_lat_lon;
}
/**
* 高德地图定位经纬度转百度经纬度
*
* @param gd_lon
* @param gd_lat
* @return
*/
public static double[] gaoDeToBaidu(double gd_lon, double gd_lat) {
double[] bd_lat_lon = new double[2];
double PI = 3.14159265358979324 * 3000.0 / 180.0;
double x = gd_lon, y = gd_lat;
double z = Math.sqrt(x * x + y * y) + 0.00002 * Math.sin(y * PI);
double theta = Math.atan2(y, x) + 0.000003 * Math.cos(x * PI);
bd_lat_lon[0] = z * Math.cos(theta) + 0.0065;
bd_lat_lon[1] = z * Math.sin(theta) + 0.006;
return bd_lat_lon;
}
}
13、SDCard工具类
public class SDCardUtils {
private SDCardUtils() {
/* cannot be instantiated */
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;
}
/**
* 获取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 容量字节 SDCard可用空间，内部存储可用空间
*/
public static long getFreeBytes(String filePath) {
// 如果是sd卡的下的路径，则获取sd卡可用容量
if (filePath.startsWith(getSDCardPath())) {
filePath = getSDCardPath();
} else {// 如果是内部存储的路径，则获取内存存储的可用容量
filePath = Environment.getDataDirectory().getAbsolutePath();
}
StatFs stat = new StatFs(filePath);
long availableBlocks = (long) stat.getAvailableBlocks() - 4;
return stat.getBlockSize() * availableBlocks;
}
/**
* 获取系统存储路径
*
* @return
*/
public static String getRootDirectoryPath() {
return Environment.getRootDirectory().getAbsolutePath();
}
}
14、TimeUtils
public class TimeUtils {
public static final SimpleDateFormat DEFAULT_DATE_FORMAT = new SimpleDateFormat(
"yyyy-MM-dd HH:mm:ss");
public static final SimpleDateFormat DATE_FORMAT_DATE = new SimpleDateFormat(
"yyyy-MM-dd");
private TimeUtils() {
throw new AssertionError();
}
/**
* long time to string
*
* @param timeInMillis
* @param dateFormat
* @return
*/
public static String getTime(long timeInMillis, SimpleDateFormat dateFormat) {
return dateFormat.format(new Date(timeInMillis));
}
/**
* long time to string, format is {@link #DEFAULT_DATE_FORMAT}
*
* @param timeInMillis
* @return
*/
public static String getTime(long timeInMillis) {
return getTime(timeInMillis, DEFAULT_DATE_FORMAT);
}
/**
* get current time in milliseconds
*
* @return
*/
public static long getCurrentTimeInLong() {
return System.currentTimeMillis();
}
/**
* get current time in milliseconds, format is {@link #DEFAULT_DATE_FORMAT}
*
* @return
*/
public static String getCurrentTimeInString() {
return getTime(getCurrentTimeInLong());
}
/**
* get current time in milliseconds
*
* @return
*/
public static String getCurrentTimeInString(SimpleDateFormat dateFormat) {
return getTime(getCurrentTimeInLong(), dateFormat);
}
/**
* UTC转换为本地时间
*
* @param pattern
* @param dateTime
* @return
*/
public static String utc2Local(String dateTime) {
dateTime = DEFAULT_DATE_FORMAT.format(new Date(
(Long.valueOf(dateTime)) * 1000));
return dateTime;
}
}
15、SnackbarUtil
public class SnackbarUtil {
public static final int Info = 1;
public static final int Confirm = 2;
public static final int Warning = 3;
public static final int Alert = 4;
public static int red = 0xfff44336;
public static int green = 0xff4caf50;
public static int blue = 0xff2195f3;
public static int orange = 0xffffc107;
/**
* 短显示Snackbar，自定义颜色
* @param view
* @param message
* @param messageColor
* @param backgroundColor
* @return
*/
public static Snackbar ShortSnackbar(View view, String message, int messageColor, int backgroundColor){
Snackbar snackbar = Snackbar.make(view,message, Snackbar.LENGTH_SHORT);
setSnackbarColor(snackbar,messageColor,backgroundColor);
return snackbar;
}
/**
* 长显示Snackbar，自定义颜色
* @param view
* @param message
* @param messageColor
* @param backgroundColor
* @return
*/
public static Snackbar LongSnackbar(View view, String message, int messageColor, int backgroundColor){
Snackbar snackbar = Snackbar.make(view,message, Snackbar.LENGTH_LONG);
setSnackbarColor(snackbar,messageColor,backgroundColor);
return snackbar;
}
/**
* 自定义时常显示Snackbar，自定义颜色
* @param view
* @param message
* @param messageColor
* @param backgroundColor
* @return
*/
public static Snackbar IndefiniteSnackbar(View view, String message, int duration, int messageColor, int backgroundColor){
Snackbar snackbar = Snackbar.make(view,message, Snackbar.LENGTH_INDEFINITE).setDuration(duration);
setSnackbarColor(snackbar,messageColor,backgroundColor);
return snackbar;
}
/**
* 短显示Snackbar，可选预设类型
* @param view
* @param message
* @param type
* @return
*/
public static Snackbar ShortSnackbar(View view, String message, int type){
Snackbar snackbar = Snackbar.make(view,message, Snackbar.LENGTH_SHORT);
switchType(snackbar,type);
return snackbar;
}
/**
* 长显示Snackbar，可选预设类型
* @param view
* @param message
* @param type
* @return
*/
public static Snackbar LongSnackbar(View view, String message, int type){
Snackbar snackbar = Snackbar.make(view,message, Snackbar.LENGTH_LONG);
switchType(snackbar,type);
return snackbar;
}
/**
* 自定义时常显示Snackbar，可选预设类型
* @param view
* @param message
* @param type
* @return
*/
public static Snackbar IndefiniteSnackbar(View view, String message, int duration, int type){
Snackbar snackbar = Snackbar.make(view,message, Snackbar.LENGTH_INDEFINITE).setDuration(duration);
switchType(snackbar,type);
return snackbar;
}
//选择预设类型
private static void switchType(Snackbar snackbar, int type){
switch (type){
case Info:
setSnackbarColor(snackbar,blue);
break;
case Confirm:
setSnackbarColor(snackbar,green);
break;
case Warning:
setSnackbarColor(snackbar,orange);
break;
case Alert:
setSnackbarColor(snackbar, Color.YELLOW,red);
break;
}
}
/**
* 设置Snackbar背景颜色
* @param snackbar
* @param backgroundColor
*/
public static void setSnackbarColor(Snackbar snackbar, int backgroundColor) {
View view = snackbar.getView();
if(view!=null){
view.setBackgroundColor(backgroundColor);
}
}
/**
* 设置Snackbar文字和背景颜色
* @param snackbar
* @param messageColor
* @param backgroundColor
*/
public static void setSnackbarColor(Snackbar snackbar, int messageColor, int backgroundColor) {
View view = snackbar.getView();
if(view!=null){
view.setBackgroundColor(backgroundColor);
((TextView) view.findViewById(R.id.snackbar_text)).setTextColor(messageColor);
}
}
/**
* 向Snackbar中添加view
* @param snackbar
* @param layoutId
* @param index 新加布局在Snackbar中的位置
*/
public static void SnackbarAddView(Snackbar snackbar, int layoutId, int index) {
View snackbarview = snackbar.getView();
Snackbar.SnackbarLayout snackbarLayout=(Snackbar.SnackbarLayout)snackbarview;
View add_view = LayoutInflater.from(snackbarview.getContext()).inflate(layoutId,null);
LinearLayout.LayoutParams p = new LinearLayout.LayoutParams( LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT);
p.gravity= Gravity.CENTER_VERTICAL;
snackbarLayout.addView(add_view,index,p);
}
}
感谢
[https://github.com/Trinea/android-common/tree/master/src/cn/trinea/android/common]
[http://www.jianshu.com/p/cd1e80e64311]:Android Snackbar花式使用指南
