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();
        }
    }
}