Android常用工具类

package com.zhy.utils;

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;

/**
* 跟App相关的辅助类
*
* @author zhy
*
*/
public class AppUtils{

private AppUtils(){
/* cannot be instantiated */
throw new UnsupportedOperationException("cannot be instantiated");
}

/**
* 获取应用程序名称
*/
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 (NameNotFoundException e){
e.printStackTrace();
}
return null;
}

/**
* [获取应用程序版本名称信息]
*
* @param context
* @return 当前应用的版本名称
*/
public static String getVersionName(Context context){
try{
PackageManager packageManager = context.getPackageManager();
PackageInfo packageInfo = packageManager.getPackageInfo(
context.getPackageName(), 0);
return packageInfo.versionName;

} catch (NameNotFoundException e){
e.printStackTrace();
}
return null;
}
/**[获取应用程序版本号]
* @param context
* @return应用程序版本号
*/
public static int getVersionCode(Context context){
int versionCode = 0;
try{
// 获取软件版本号，对应AndroidManifest.xml下android:versionCode
versionCode = context.getPackageManager().getPackageInfo("com.zhy.zhy_android_utils", 0).versionCode;
} catch (NameNotFoundException e){
e.printStackTrace();
}
return versionCode;
}
}

package com.zhy.utils;

import android.content.Context;
import android.util.TypedValue;

/**
* 常用单位转换的辅助类
*
* @author zhy
*
*/
public class DensityUtils{
private DensityUtils(){
/* cannot be instantiated */
throw new UnsupportedOperationException("cannot be instantiated");
}

/**
* dp转px
*
* @param context
* @param val
* @return
*/
public static int dp2px(Context context, float dpVal){
return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
dpVal, context.getResources().getDisplayMetrics());
}

/**
* sp转px
*
* @param context
* @param val
* @return
*/
public static int sp2px(Context context, float spVal){
return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP,
spVal, context.getResources().getDisplayMetrics());
}

/**
* px转dp
*
* @param context
* @param pxVal
* @return
*/
public static float px2dp(Context context, float pxVal){
final float scale = context.getResources().getDisplayMetrics().density;
return (pxVal / scale);
}

/**
* px转sp
*
* @param fontScale
* @param pxVal
* @return
*/
public static float px2sp(Context context, float pxVal){
return (pxVal / context.getResources().getDisplayMetrics().scaledDensity);
}
}

package com.zhy.utils;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

public class Encoder {
/**
* @param value
*            string to be encoded
* @return encoded parameters string
*/
public static String encode(String value) {
String encoded = null;
try {
encoded = URLEncoder.encode(value, "UTF-8");
} catch (UnsupportedEncodingException ignore) {
}
StringBuffer buf = new StringBuffer(encoded.length());
char focus;
for (int i = 0; i < encoded.length(); i++) {
focus = encoded.charAt(i);
if (focus == '*') {
buf.append("%2A");
} else if (focus == '+') {
buf.append("%20");
} else if (focus == '%' && (i + 1) < encoded.length() && encoded.charAt(i + 1) == '7'
&& encoded.charAt(i + 2) == 'E') {
buf.append('~');
i += 2;
} else {
buf.append(focus);
}
}
return buf.toString();
}
}

package com.zhy.utils;

import android.content.Context;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

/**
* 打开或关闭软键盘
*
* @author zhy
*
*/
public class KeyBoardUtils
{
/**
* 打卡软键盘
*
* @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);
}
}

package com.zhy.utils;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;

/**
* 跟网络相关的工具类
*
* @author zhy
*
*/
public class NetUtils
{
private NetUtils()
{
/* cannot be instantiated */
throw new UnsupportedOperationException("cannot be instantiated");
}

/**
* 判断网络是否连接
*
* @param context
* @return
*/
public static boolean isConnected(Context context){

ConnectivityManager connectivity = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);

if (null != connectivity){
NetworkInfo info = connectivity.getActiveNetworkInfo();
if (null != info && info.isConnected()){
if (info.getState() == NetworkInfo.State.CONNECTED){
return true;
}
}
}
return false;
}

/**
* 打开网络设置界面
*/
public static void openSetting(Activity activity){
Intent intent = new Intent("/");
ComponentName cm = new ComponentName("com.android.settings",
"com.android.settings.WirelessSettings");
intent.setComponent(cm);
intent.setAction("android.intent.action.VIEW");
activity.startActivityForResult(intent, 0);
}

}

package com.zhy.utils;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Rect;
import android.util.DisplayMetrics;
import android.view.View;
import android.view.WindowManager;

/**
* 获得屏幕相关的辅助类
*
* @author zhy
*
*/
public class ScreenUtils{
private ScreenUtils(){
/* cannot be instantiated */
throw new UnsupportedOperationException("cannot be instantiated");
}

/**
* 获得屏幕高度
*
* @param context
* @return
*/
public static int getScreenWidth(Context context){
WindowManager wm = (WindowManager) context
.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics outMetrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(outMetrics);
return outMetrics.widthPixels;
}

/**
* 获得屏幕宽度
*
* @param context
* @return
*/
public static int getScreenHeight(Context context){
WindowManager wm = (WindowManager) context
.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics outMetrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(outMetrics);
return outMetrics.heightPixels;
}

/**
* 获得状态栏的高度
*
* @param context
* @return
*/
public static int getStatusHeight(Context context){

int statusHeight = -1;
try{
Class<?> clazz = Class.forName("com.android.internal.R$dimen");
Object object = clazz.newInstance();
int height = Integer.parseInt(clazz.getField("status_bar_height")
.get(object).toString());
statusHeight = context.getResources().getDimensionPixelSize(height);
} catch (Exception e){
e.printStackTrace();
}
return statusHeight;
}

/**
* 获取当前屏幕截图，包含状态栏
*
* @param activity
* @return
*/
public static Bitmap snapShotWithStatusBar(Activity activity){
View view = activity.getWindow().getDecorView();
view.setDrawingCacheEnabled(true);
view.buildDrawingCache();
Bitmap bmp = view.getDrawingCache();
int width = getScreenWidth(activity);
int height = getScreenHeight(activity);
Bitmap bp = null;
bp = Bitmap.createBitmap(bmp, 0, 0, width, height);
view.destroyDrawingCache();
return bp;

}

/**
* 获取当前屏幕截图，不包含状态栏
*
* @param activity
* @return
*/
public static Bitmap snapShotWithoutStatusBar(Activity activity){
View view = activity.getWindow().getDecorView();
view.setDrawingCacheEnabled(true);
view.buildDrawingCache();
Bitmap bmp = view.getDrawingCache();
Rect frame = new Rect();
activity.getWindow().getDecorView().getWindowVisibleDisplayFrame(frame);
int statusBarHeight = frame.top;

int width = getScreenWidth(activity);
int height = getScreenHeight(activity);
Bitmap bp = null;
bp = Bitmap.createBitmap(bmp, 0, statusBarHeight, width, height
- statusBarHeight);
view.destroyDrawingCache();
return bp;
}
}

package com.zhy.utils;

import java.io.File;

import android.os.Environment;
import android.os.StatFs;

/**
* SD卡相关的辅助类
*
* @author zhy
*
*/
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
*/
@SuppressWarnings("deprecation")
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可用空间，内部存储可用空间
*/
@SuppressWarnings("deprecation")
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();
}
}

package com.zhy.utils;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;

import android.content.Context;
import android.content.SharedPreferences;

public class SPUtils{
public SPUtils(){
/* cannot be instantiated */
throw new UnsupportedOperationException("cannot be instantiated");
}

/**
* 保存在手机里面的文件名
*/
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());
}
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 zhy
*
*/
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){
}
editor.commit();
}
}
}