Android常用的工具类

常用工具类总结

DownloadUtil.java

import android.app.DownloadManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.net.Uri;
import android.os.Environment;
import android.widget.Toast;

//使用步骤1：
//AndroidManifest注册，最好重新，好监听下载完成
//<receiver android:name="com.wuxiaolong.androidutils.library.DownloadUtil$DownloadManagerReceiver">
//<intent-filter>
//<action android:name="android.intent.action.DOWNLOAD_NOTIFICATION_CLICKED"/>
//<action android:name="android.intent.action.DOWNLOAD_COMPLETE"/>
//</intent-filter>
//</receiver>
//步骤2：
//DownloadUtil downloadUtil=new DownloadUtil(activity,downloadUrl);
////下载显示名字，不能是中文
//downloadUtil.setDownloadFileName("apkName"+System.currentTimeMillis()+".apk");
//downloadUtil.setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED);
//downloadUtil.start();

public class DownloadUtil {
private Context mContext;
private String downloadFileName = "weiyan.apk";
private static long myReference;
private static DownloadManager downloadManager;
private DownloadManager.Request downloadRequest;

public DownloadUtil(Context context, String downloadUrl) {
this.mContext = context;
initDownload(downloadUrl);
}

private void initDownload(String downloadUrl) {
downloadManager = (DownloadManager) mContext.getSystemService(Context.DOWNLOAD_SERVICE);
Uri uri = Uri.parse(downloadUrl);//"http://app.mi.com/download/25323"
downloadRequest = new DownloadManager.Request(uri);
// 设置目标存储在外部目录，一般位置可以用
downloadRequest.setDestinationInExternalFilesDir(mContext, Environment.DIRECTORY_DOWNLOADS, downloadFileName);
//下载的文件能被其他应用扫描到
downloadRequest.allowScanningByMediaScanner();
//设置被系统的Downloads应用扫描到并管理,默认true
downloadRequest.setVisibleInDownloadsUi(true);
//限定在WiFi还是手机网络(NETWORK_MOBILE)下进行下载
downloadRequest.setAllowedNetworkTypes(DownloadManager.Request.NETWORK_WIFI);
// 设置mime类型，这里看服务器配置，一般国家化的都为utf-8编码。
downloadRequest.setMimeType("application/vnd.android.package-archive");
/**
* 设置notification显示状态
* Request.VISIBILITY_VISIBLE：在下载进行的过程中，通知栏中会一直显示该下载的Notification，当下载完成时，该Notification会被移除，这是默认的参数值。
* Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED：在下载过程中通知栏会一直显示该下载的Notification，在下载完成后该Notification会继续显示，直到用户点击该
* Notification或者消除该Notification。
* Request.VISIBILITY_VISIBLE_NOTIFY_ONLY_COMPLETION：只有在下载完成后该Notification才会被显示。
* Request.VISIBILITY_HIDDEN：不显示该下载请求的Notification。如果要使用这个参数，需要在应用的清单文件中加上android.permission.DOWNLOAD_WITHOUT_NOTIFICATION
*/
downloadRequest.setNotificationVisibility(DownloadManager.Request.VISIBILITY_HIDDEN);
//设置notification的标题
downloadRequest.setTitle("下载");
//设置notification的描述
downloadRequest.setDescription("下载应用");
}

public void start() {
myReference = downloadManager.enqueue(downloadRequest);
}

/**
* 须static，不然在AndroidManifest注册时报错：java.lang.InstantiationException has no zero argument constructor
* 或者must be registered and unregistered inside the Parent class
*/
public static class DownloadManagerReceiver extends BroadcastReceiver {

@Override
public void onReceive(Context context, Intent intent) {
//Notification点击
if (intent.getAction().equals(DownloadManager.ACTION_NOTIFICATION_CLICKED)) {
String extraID = DownloadManager.EXTRA_NOTIFICATION_CLICK_DOWNLOAD_IDS;
long[] references = intent.getLongArrayExtra(extraID);
for (long reference : references)
if (reference == myReference) {
}
}
//下载完成
if (intent.getAction().equals(DownloadManager.ACTION_DOWNLOAD_COMPLETE)) {
long completeDownloadId = intent.getLongExtra(DownloadManager.EXTRA_DOWNLOAD_ID, -1);
if (completeDownloadId == myReference) {
Cursor cursor = downloadManager.query(new DownloadManager.Query()
.setFilterById(completeDownloadId));
cursor.moveToFirst();
String filePath = cursor.getString(cursor.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI));
cursor.close();
if (filePath != null) {
if (filePath.contains(context.getPackageName())) {
if (filePath.endsWith("apk")) {
AppUtils.installAPK(context, filePath.trim().substring(7));
} else {
Toast.makeText(context, "下载完成", Toast.LENGTH_SHORT).show();
}
}
} else {
Toast.makeText(context, "网络不给力", Toast.LENGTH_SHORT).show();
}
}
}
}
}

public void setDownloadFileName(String downloadFileName) {
// 设置目标存储在外部目录，一般位置可以用
downloadRequest.setDestinationInExternalFilesDir(mContext, Environment.DIRECTORY_DOWNLOADS, downloadFileName);
}

public void setNotificationTitle(CharSequence title) {
//设置notification的标题
downloadRequest.setTitle(title);

}

public void setNotificationDescription(CharSequence description) {
//设置notification的描述
downloadRequest.setDescription(description);
}

/**
* 设置notification显示状态
* Request.VISIBILITY_VISIBLE：在下载进行的过程中，通知栏中会一直显示该下载的Notification，当下载完成时，该Notification会被移除，这是默认的参数值。
* Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED：在下载过程中通知栏会一直显示该下载的Notification，在下载完成后该Notification会继续显示，直到用户点击该
* Notification或者消除该Notification。
* Request.VISIBILITY_VISIBLE_NOTIFY_ONLY_COMPLETION：只有在下载完成后该Notification才会被显示。
* Request.VISIBILITY_HIDDEN：不显示该下载请求的Notification。如果要使用这个参数，需要在应用的清单文件中加上android.permission.DOWNLOAD_WITHOUT_NOTIFICATION
*
* @param visibility 显示标识
*/
public void setNotificationVisibility(int visibility) {

downloadRequest.setNotificationVisibility(visibility);
}

public DownloadManager.Request getDownloadRequest() {
return downloadRequest;
}
}

BitmapCompressUtil.java

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Environment;
import android.util.DisplayMetrics;
import android.view.WindowManager;

import java.io.File;
import java.io.FileOutputStream;

/**
* 图片压缩类
* 需要增加权限：android.permission.WRITE_EXTERNAL_STORAGE
* 使用方法：
* new BitmapCompressUtil(MainActivity.this).bitmapCompress("/storage/sdcard0/dcim/Camera/IMG_20160518_083759.jpg",
* new BitmapCompressUtil.BitmapCompressCallback() {
* <p>
* public void onCompressSuccess(String fileOutputPath) {
* LogUtil.d("fileOutputPath=" + fileOutputPath);
* }
* public void onCompressFailure(String t) {
* LogUtil.d("onCompressFailure=" + t);
* }
* });
*/
public class BitmapCompressUtil {
private Bitmap.CompressFormat compressFormat = Bitmap.CompressFormat.JPEG;
private int compressQuality = 50;
private String mFileOutputPath;
private Context context;

/**
* 压缩
*
* @param fileInputPath 需要压缩图片SD卡路径
* @param bitmapCompressCallback 压缩回调
*/
public void bitmapCompress(String fileInputPath, BitmapCompressCallback bitmapCompressCallback) {
new BitmapCropTask(bitmapCompressCallback).execute(fileInputPath);
}

class BitmapCropTask extends AsyncTask<String, Void, Exception> {
BitmapCompressCallback bitmapCompressCallback;

BitmapCropTask(BitmapCompressCallback bitmapCompressCallback) {
this.bitmapCompressCallback = bitmapCompressCallback;
}

@Override
protected Exception doInBackground(String... params) {
Bitmap bitmap = decodeFile(params[0]);
return compress(bitmap);
}

private Bitmap decodeFile(String param) {
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
int bmpWidth = options.outWidth;
int bmpHeght = options.outHeight;

WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics metrics = new DisplayMetrics();
windowManager.getDefaultDisplay().getMetrics(metrics);
int screenWidth = metrics.widthPixels;
int screenHeight = metrics.heightPixels;

options.inSampleSize = 1;
if (bmpWidth > bmpHeght) {
if (bmpWidth > screenWidth)
options.inSampleSize = bmpWidth / screenWidth;
} else {
if (bmpHeght > screenHeight)
options.inSampleSize = bmpHeght / screenHeight;
}
options.inJustDecodeBounds = false;
return BitmapFactory.decodeFile(param, options);
}

private Exception compress(Bitmap bitmap) {
File outDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
if (!outDir.exists()) {
outDir.mkdirs();
}
File outFile = new File(outDir, System.currentTimeMillis() + ".jpg");
mFileOutputPath = outFile.getAbsolutePath();
try {
FileOutputStream fileOutputStream = new FileOutputStream(outFile);
bitmap.compress(compressFormat, compressQuality, fileOutputStream);
bitmap.recycle();
fileOutputStream.flush();
fileOutputStream.close();
} catch (Exception e) {
e.printStackTrace();
return e;
}
return null;
}

@Override
protected void onPostExecute(Exception e) {
if (e == null) {
bitmapCompressCallback.onCompressSuccess(mFileOutputPath);
} else {
bitmapCompressCallback.onCompressFailure(e.getMessage());
}
super.onPostExecute(e);
}
}

public interface BitmapCompressCallback {

void onCompressSuccess(String fileOutputPath);

void onCompressFailure(String t);

}

public void setCompressFormat(Bitmap.CompressFormat compressFormat) {
this.compressFormat = compressFormat;
}

/**
* 设置压缩图片质量
*
* @param compressQuality 取值0-100
*/
public void setCompressQuality(int compressQuality) {
this.compressQuality = compressQuality;
}

public BitmapCompressUtil(Context context) {
this.context = context;
}

}

CrashHandlerUtil.java(捕获异常信息，记录错误报告的工具类)

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Environment;
import android.os.Looper;
import android.util.Log;
import android.widget.Toast;

import java.io.File;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.Field;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

/**
* UncaughtException处理类,当程序发生Uncaught异常的时候,有该类来接管程序,并记录发送错误报告.
* public class AndroidUtilsApplication extends Application {
* public void onCreate() {
* super.onCreate();
* //崩溃处理
* CrashHandlerUtil crashHandlerUtil = CrashHandlerUtil.getInstance();
* crashHandlerUtil.init(this);
* crashHandlerUtil.setCrashTip("很抱歉，程序出现异常，即将退出！");
* }
* }
*/
public class CrashHandlerUtil implements Thread.UncaughtExceptionHandler {

public static final String TAG = "CrashHandlerUtil";

//系统默认的UncaughtException处理类
private Thread.UncaughtExceptionHandler mDefaultHandler;
//CrashHandler实例
private static CrashHandlerUtil INSTANCE = new CrashHandlerUtil();
//程序的Context对象
private Context mContext;
//用来存储设备信息和异常信息
private Map<String, String> infos = new HashMap<>();

//用于格式化日期,作为日志文件名的一部分
private DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss", Locale.CHINA);
private String crashTip = "很抱歉，程序出现异常，即将退出！";

public String getCrashTip() {
return crashTip;
}

public void setCrashTip(String crashTip) {
this.crashTip = crashTip;
}

/**
* 保证只有一个CrashHandler实例
*/
private CrashHandlerUtil() {
}

/**
* 获取CrashHandler实例 ,单例模式
*
* @return 单例
*/
public static CrashHandlerUtil getInstance() {
return INSTANCE;
}

/**
* 初始化
*
* @param context 上下文
*/
public void init(Context context) {
mContext = context;
//获取系统默认的UncaughtException处理器
mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();
//设置该CrashHandler为程序的默认处理器
Thread.setDefaultUncaughtExceptionHandler(this);
}

/**
* 当UncaughtException发生时会转入该函数来处理
*
* @param thread 线程
* @param ex 异常
*/
@Override
public void uncaughtException(Thread thread, Throwable ex) {
if (!handleException(ex) && mDefaultHandler != null) {
//如果用户没有处理则让系统默认的异常处理器来处理
mDefaultHandler.uncaughtException(thread, ex);
} else {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
Log.e(TAG, "error : ", e);
e.printStackTrace();
}
//退出程序
ActivityManagerUtil.getInstance().appExit();
}
}

/**
* 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成.
*
* @param throwable 异常
* @return true:如果处理了该异常信息;否则返回false.
*/
private boolean handleException(final Throwable throwable) {
if (throwable == null) {
return false;
}
//使用Toast来显示异常信息
new Thread() {
@Override
public void run() {
Looper.prepare();
throwable.printStackTrace();
Toast.makeText(mContext, getCrashTip(), Toast.LENGTH_LONG).show();
Looper.loop();
}
}.start();
//收集设备参数信息
collectDeviceInfo(mContext);
//保存日志文件
saveCrashInfo2File(throwable);
return true;
}

/**
* 收集设备参数信息
*
* @param ctx 上下文
*/
public void collectDeviceInfo(Context ctx) {
try {
PackageManager pm = ctx.getPackageManager();
PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(), PackageManager.GET_ACTIVITIES);
if (pi != null) {
String versionName = pi.versionName == null ? "null" : pi.versionName;
String versionCode = pi.versionCode + "";
infos.put("versionName", versionName);
infos.put("versionCode", versionCode);
}
} catch (PackageManager.NameNotFoundException e) {
Log.e(TAG, "an error occured when collect package info", e);
}
Field[] fields = Build.class.getDeclaredFields();
for (Field field : fields) {
try {
field.setAccessible(true);
infos.put(field.getName(), field.get(null).toString());
Log.d(TAG, field.getName() + " : " + field.get(null));
} catch (Exception e) {
Log.e(TAG, "an error occured when collect crash info", e);
}
}
}

/**
* 保存错误信息到文件中
*
* @param ex 异常
* @return 返回文件名称, 便于将文件传送到服务器
*/
private String saveCrashInfo2File(Throwable ex) {

StringBuffer sb = new StringBuffer();
for (Map.Entry<String, String> entry : infos.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
sb.append(key + "=" + value + "\n");
}

Writer writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
ex.printStackTrace(printWriter);
Throwable cause = ex.getCause();
while (cause != null) {
cause.printStackTrace(printWriter);
cause = cause.getCause();
}
printWriter.close();
String result = writer.toString();
sb.append(result);
try {
long timestamp = System.currentTimeMillis();
String time = formatter.format(new Date());
String fileName = "crash-" + time + "-" + timestamp + ".log";
if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
String path = Environment.getExternalStorageDirectory().getPath() + "/crash/";
LogUtil.d("path=" + path);
File dir = new File(path);
if (!dir.exists()) {
dir.mkdirs();
}
FileOutputStream fos = new FileOutputStream(path + fileName);
fos.write(sb.toString().getBytes());
Log.d(TAG, "saveCrashInfo2File:-------------------> "+path + fileName);
fos.close();
}
return fileName;
} catch (Exception e) {
Log.e(TAG, "an error occured while writing file...", e);
}
return null;
}

}

ActivityManagerUtil.java

import android.app.Activity;

import java.util.Stack;

/**
* public class BaseActivity extends AppCompatActivity {
* private ActivityManagerUtil activityManagerUtil;
* protected void onCreate(Bundle savedInstanceState) {
* super.onCreate(savedInstanceState);
* setContentView(R.layout.activity_base);
* activityManagerUtil = ActivityManagerUtil.getInstance();
* activityManagerUtil.pushOneActivity(this);
* }
* protected void onDestroy() {
* super.onDestroy();
* activityManagerUtil.popOneActivity(this);
* }
* }
*/
public class ActivityManagerUtil {
private static ActivityManagerUtil instance;
//activity栈
private Stack<Activity> activityStack = new Stack<>();

/**
* 单例模式
*
* @return 单例
*/

public static ActivityManagerUtil getInstance() {
if (instance == null) {
instance = new ActivityManagerUtil();
}
return instance;
}

/**
* 把一个activity压入栈中
*
* @param actvity activity
*/
public void pushOneActivity(Activity actvity) {
activityStack.add(actvity);
}

/**
* 移除一个activity
*
* @param activity activity
*/
public void popOneActivity(Activity activity) {
if (activityStack != null && activityStack.size() > 0) {
if (activity != null) {
activityStack.remove(activity);
activity.finish();
}
}
}

/**
* 获取栈顶的activity，先进后出原则
*
* @return 栈顶的activity
*/
public Activity getLastActivity() {
return activityStack.lastElement();
}

/**
* 结束指定的Activity
*
* @param activity activity
*/
public void finishActivity(Activity activity) {
if (activity != null) {
activityStack.remove(activity);
activity.finish();
}
}

/**
* 结束指定类名的Activity
*
* @param cls 指定的Activity
*/
public void finishActivity(Class<?> cls) {
for (Activity activity : activityStack) {
if (activity.getClass().equals(cls)) {
finishActivity(activity);
}
}
}

/**
* 结束所有activity
*/
public void finishAllActivity() {
try {
for (int i = 0; i < activityStack.size(); i++) {
if (null != activityStack.get(i)) {
activityStack.get(i).finish();
}
}
activityStack.clear();
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 退出应用程序
*/
public void appExit() {
try {
finishAllActivity();
//退出JVM(java虚拟机),释放所占内存资源,0表示正常退出(非0的都为异常退出)
System.exit(0);
//从操作系统中结束掉当前程序的进程
android.os.Process.killProcess(android.os.Process.myPid());
} catch (Exception e) {
e.printStackTrace();
}
}
}