在应用发布之后，怎么手机用户的崩溃日志呢，我们可以通过手机用户的崩溃日志并将日志发到指定的邮箱。下面就来看看具体实现吧。
1.首先要下载下列三个jar包，放入libs下，下面是下载地址
链接: https://pan.baidu.com/s/1wVkIWBxvZx0mT876goFBHQ 密码: 6qxh
2.在app的build.gradle导入包
implementation files('libs/mail.jar')
implementation files('libs/additionnal.jar')
implementation files('libs/activation.jar')
implementation 'com.githang:android-crash:1.0'
3.carsh文件
public class CrashHandler implements UncaughtExceptionHandler {
private static String TAG = "MyCrash";
// 系统默认的UncaughtException处理类
private UncaughtExceptionHandler mDefaultHandler;
@SuppressLint("StaticFieldLeak")
private static CrashHandler instance = new CrashHandler();
private Context mContext;
// 用来存储设备信息和异常信息
private Map<String, String> infos = new HashMap<>();
// 用于格式化日期,作为日志文件名的一部分
private DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm");
/**
* 保证只有一个CrashHandler实例
*/
private CrashHandler() {
}
/**
* 获取CrashHandler实例 ,单例模式
*/
public static CrashHandler getInstance() {
return instance;
}
/**
* 初始化
*/
public void init(Context context) {
mContext = context;
// 获取系统默认的UncaughtException处理器
mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();
// 设置该CrashHandler为程序的默认处理器
Thread.setDefaultUncaughtExceptionHandler(this);
}
/**
* 当UncaughtException发生时会转入该函数来处理
*/
@Override
public void uncaughtException(Thread thread, Throwable ex) {
Log.e(TAG, ex.getMessage());
for (StackTraceElement element : ex.getStackTrace()) {
Log.e(TAG, element.toString());
}
ex.printStackTrace();
if (!handleException(ex) && mDefaultHandler != null) {
// 如果用户没有处理则让系统默认的异常处理器来处理
mDefaultHandler.uncaughtException(thread, ex);
} else {
SystemClock.sleep(3000);
// 退出程序
android.os.Process.killProcess(android.os.Process.myPid());
System.exit(1);
}
}
/**
* 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成.
*
* @return true:如果处理了该异常信息; 否则返回false.
*/
private boolean handleException(Throwable ex) {
if (ex == null)
return false;
try {
// 使用Toast来显示异常信息
new Thread() {
@Override
public void run() {
Looper.prepare();
Looper.loop();
}
}.start();
// 收集设备参数信息
collectDeviceInfo(mContext);
// 保存日志文件
saveCrashInfoFile(ex);
SystemClock.sleep(3000);
} catch (Exception e) {
e.printStackTrace();
}
return true;
}
/**
* 收集设备参数信息
*/
private 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 + "";
String versionCode = pi.versionCode + "";
infos.put("versionName", versionName);
infos.put("versionCode", versionCode);
}
} catch (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());
} catch (Exception e) {
Log.e(TAG, "an error occured when collect crash info", e);
}
}
}
/**
* 保存错误信息到文件中
*
* @return 返回文件名称, 便于将文件传送到服务器
*/
private void saveCrashInfoFile(Throwable ex) throws Exception {
StringBuilder sb = new StringBuilder();
try {
SimpleDateFormat sDateFormat = new SimpleDateFormat(
"yyyy-MM-dd HH:mm:ss");
String date = sDateFormat.format(new Date());
sb.append("\r\n").append(date).append("\n");
for (Map.Entry<String, String> entry : infos.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
sb.append(key).append("=").append(value).append("\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.flush();
printWriter.close();
String result = writer.toString();
sb.append(result);
writeFile(sb.toString());
} catch (Exception e) {
Log.e(TAG, "an error occured while writing file...", e);
sb.append("an error occured while writing file...\r\n");
writeFile(sb.toString());
}
}
@SuppressWarnings("ResultOfMethodCallIgnored")
private void writeFile(String sb) throws Exception {
String time = formatter.format(new Date());
String fileName = "crash-" + time + ".log";
if (FileUtil.hasSdcard()) {
String path = getGlobalpath();
File dir = new File(path);
if (!dir.exists())
//noinspection ResultOfMethodCallIgnored
dir.mkdirs();
FileOutputStream fos = new FileOutputStream(path + fileName, true);
fos.write(sb.getBytes());
fos.flush();
fos.close();
initEmailReporter(new File(path + fileName));
}
}
private static String getGlobalpath() {
return Environment.getExternalStorageDirectory().getAbsolutePath()
+ File.separator + "crash" + File.separator;
}
/**
* 使用EMAIL发送日志
*/
private void initEmailReporter(File file) {
CrashEmailReporter reporter = new CrashEmailReporter(mContext);
reporter.setReceiver("1122334455@qq.com");
reporter.setSender("112244555@163.com");
reporter.setSendPassword("a123456");//说到这个密码，你可以设置一个客户端授权码，它是登录第三方客户端的专用密码，和主登录密码不冲突
reporter.setSMTPHost("smtp.163.com");//这里使用的是163发送邮件的服务，所以主机名是163的，有需要修改的，也可以更改对应的主机名
reporter.setPort("465");//端口号，可选25端口号，具体的看是否使用ssl安全协议
reporter.sendFile(file);
AndroidCrash.getInstance().setCrashReporter(reporter).init(mContext);
}
}
4.在应用的application中初始化
CrashHandler.getInstance().init(this);
附上上面用到的FileUtil类
public final class FileUtil {
private FileUtil() {
throw new Error("￣﹏￣");
}
/** 分隔符. */
private final static String FILE_EXTENSION_SEPARATOR = ".";
/**"/"*/
public final static String SEP = File.separator;
/** SD卡根目录 */
public static final String SDPATH = Environment
.getExternalStorageDirectory() + File.separator;
/**
* 判断SD卡是否可用
* @return SD卡可用返回true
*/
public static boolean hasSdcard() {
String status = Environment.getExternalStorageState();
return Environment.MEDIA_MOUNTED.equals(status);
}
/**
* 读取文件的内容
* <br>
* 默认utf-8编码
* @param filePath 文件路径
* @return 字符串
*/
public static String readFile(String filePath) throws IOException {
return readFile(filePath, "utf-8");
}
/**
* 读取文件的内容
* @param filePath 文件目录
* @param charsetName 字符编码
* @return String字符串
*/
private static String readFile(String filePath, String charsetName)
throws IOException {
if (TextUtils.isEmpty(filePath))
return null;
if (TextUtils.isEmpty(charsetName))
charsetName = "utf-8";
File file = new File(filePath);
StringBuilder fileContent = new StringBuilder("");
if (!file.isFile())
return null;
BufferedReader reader = null;
try {
InputStreamReader is = new InputStreamReader(new FileInputStream(
file), charsetName);
reader = new BufferedReader(is);
String line;
while ((line = reader.readLine()) != null) {
if (!fileContent.toString().equals("")) {
fileContent.append("\r\n");
}
fileContent.append(line);
}
return fileContent.toString();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 读取文本文件到List字符串集合中(默认utf-8编码)
* @param filePath 文件目录
* @return 文件不存在返回null，否则返回字符串集合
*/
public static List<String> readFileToList(String filePath)
throws IOException {
return readFileToList(filePath, "utf-8");
}
/**
* 读取文本文件到List字符串集合中
* @param filePath 文件目录
* @param charsetName 字符编码
* @return 文件不存在返回null，否则返回字符串集合
*/
private static List<String> readFileToList(String filePath,
String charsetName) throws IOException {
if (TextUtils.isEmpty(filePath))
return null;
if (TextUtils.isEmpty(charsetName))
charsetName = "utf-8";
File file = new File(filePath);
List<String> fileContent = new ArrayList<>();
if (!file.isFile()) {
return null;
}
BufferedReader reader = null;
try {
InputStreamReader is = new InputStreamReader(new FileInputStream(
file), charsetName);
reader = new BufferedReader(is);
String line;
while ((line = reader.readLine()) != null) {
fileContent.add(line);
}
return fileContent;
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 向文件中写入数据
* @param filePath 文件目录
* @param content 要写入的内容
* @param append 如果为 true，则将数据写入文件末尾处，而不是写入文件开始处
* @return 写入成功返回true， 写入失败返回false
*/
public static boolean writeFile(String filePath, String content,
boolean append) throws IOException {
if (TextUtils.isEmpty(filePath))
return false;
if (TextUtils.isEmpty(content))
return false;
FileWriter fileWriter = null;
try {
createFile(filePath);
fileWriter = new FileWriter(filePath, append);
fileWriter.write(content);
fileWriter.flush();
return true;
} finally {
if (fileWriter != null) {
try {
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 向文件中写入数据<br>
* 默认在文件开始处重新写入数据
* @param filePath 文件目录
* @param stream 字节输入流
* @return 写入成功返回true，否则返回false
*/
private static boolean writeFile(String filePath, InputStream stream)
throws IOException {
return writeFile(filePath, stream, false);
}
/**
* 向文件中写入数据
* @param filePath 文件目录
* @param stream 字节输入流
* @param append 如果为 true，则将数据写入文件末尾处；
* 为false时，清空原来的数据，从头开始写
* @return 写入成功返回true，否则返回false
*/
private static boolean writeFile(String filePath, InputStream stream,
boolean append) throws IOException {
if (TextUtils.isEmpty(filePath))
throw new NullPointerException("filePath is Empty");
if (stream == null)
throw new NullPointerException("InputStream is null");
return writeFile(new File(filePath), stream,
append);
}
/**
* 向文件中写入数据
* 默认在文件开始处重新写入数据
* @param file 指定文件
* @param stream 字节输入流
* @return 写入成功返回true，否则返回false
*/
public static boolean writeFile(File file, InputStream stream)
throws IOException {
return writeFile(file, stream, false);
}
/**
* 向文件中写入数据
* @param file 指定文件
* @param stream 字节输入流
* @param append 为true时，在文件开始处重新写入数据；
* 为false时，清空原来的数据，从头开始写
* @return 写入成功返回true，否则返回false
*/
private static boolean writeFile(File file, InputStream stream,
boolean append) throws IOException {
if (file == null)
throw new NullPointerException("file = null");
OutputStream out = null;
try {
createFile(file.getAbsolutePath());
out = new FileOutputStream(file, append);
byte data[] = new byte[1024];
int length;
while ((length = stream.read(data)) != -1) {
out.write(data, 0, length);
}
out.flush();
return true;
} finally {
if (out != null) {
try {
out.close();
stream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 复制文件
* @param sourceFilePath 源文件目录（要复制的文件目录）
* @param destFilePath 目标文件目录（复制后的文件目录）
* @return 复制文件成功返回true，否则返回false
*/
public static boolean copyFile(String sourceFilePath, String destFilePath)
throws IOException {
InputStream inputStream;
inputStream = new FileInputStream(sourceFilePath);
return writeFile(destFilePath, inputStream);
}
/**
* 获取某个目录下的文件名
* @param dirPath 目录
* @param fileFilter 过滤器
* @return 某个目录下的所有文件名
*/
public static List<String> getFileNameList(String dirPath,
FilenameFilter fileFilter) {
if (fileFilter == null)
return getFileNameList(dirPath);
if (TextUtils.isEmpty(dirPath))
return Collections.emptyList();
File dir = new File(dirPath);
File[] files = dir.listFiles(fileFilter);
if (files == null)
return Collections.emptyList();
List<String> conList = new ArrayList<>();
for (File file : files) {
if (file.isFile())
conList.add(file.getName());
}
return conList;
}
/**
* 获取某个目录下的文件名
* @param dirPath 目录
* @return 某个目录下的所有文件名
*/
private static List<String> getFileNameList(String dirPath) {
if (TextUtils.isEmpty(dirPath))
return Collections.emptyList();
File dir = new File(dirPath);
File[] files = dir.listFiles();
if (files == null)
return Collections.emptyList();
List<String> conList = new ArrayList<>();
for (File file : files) {
if (file.isFile())
conList.add(file.getName());
}
return conList;
}
/**
* 获取某个目录下的指定扩展名的文件名称
* @param dirPath 目录
* @return 某个目录下的所有文件名
*/
public static List<String> getFileNameList(String dirPath,
final String extension) {
if (TextUtils.isEmpty(dirPath))
return Collections.emptyList();
File dir = new File(dirPath);
File[] files = dir.listFiles((dir1, filename) -> filename.indexOf("." + extension) > 0);
if (files == null)
return Collections.emptyList();
List<String> conList = new ArrayList<>();
for (File file : files) {
if (file.isFile())
conList.add(file.getName());
}
return conList;
}
/**
* 获得文件的扩展名
* @param filePath 文件路径
* @return 如果没有扩展名，返回""
*/
public static String getFileExtension(String filePath) {
if (TextUtils.isEmpty(filePath)) {
return filePath;
}
int extenPosi = filePath.lastIndexOf(FILE_EXTENSION_SEPARATOR);
int filePosi = filePath.lastIndexOf(File.separator);
if (extenPosi == -1) {
return "";
}
return (filePosi >= extenPosi) ? "" : filePath.substring(extenPosi + 1);
}
/**
* 创建文件
* @param path 文件的绝对路径
*/
private static void createFile(String path) {
if (TextUtils.isEmpty(path))
return;
createFile(new File(path));
}
/**
* 创建文件
* @return 创建成功返回true
*/
private static void createFile(File file) {
if (file == null || !makeDirs(getFolderName(file.getAbsolutePath())))
return;
if (!file.exists())
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 创建目录（可以是多个）
* @param filePath 目录路径
* @return 如果路径为空时，返回false；如果目录创建成功，则返回true，否则返回false
*/
private static boolean makeDirs(String filePath) {
if (TextUtils.isEmpty(filePath)) {
return false;
}
File folder = new File(filePath);
return (folder.exists() && folder.isDirectory()) || folder
.mkdirs();
}
/**
* 创建目录（可以是多个）
* @param dir 目录
* @return 如果目录创建成功，则返回true，否则返回false
*/
public static boolean makeDirs(File dir) {
return dir != null && ((dir.exists() && dir.isDirectory()) || dir.mkdirs());
}
/**
* 判断文件是否存在
* @param filePath 文件路径
* @return 如果路径为空或者为空白字符串，就返回false；如果文件存在，且是文件，
* 就返回true；如果不是文件或者不存在，则返回false
*/
public static boolean isFileExist(String filePath) {
if (TextUtils.isEmpty(filePath)) {
return false;
}
File file = new File(filePath);
return (file.exists() && file.isFile());
}
/**
* 获得不带扩展名的文件名称
* @param filePath 文件路径
*/
public static String getFileNameWithoutExtension(String filePath) {
if (TextUtils.isEmpty(filePath)) {
return filePath;
}
int extenPosi = filePath.lastIndexOf(FILE_EXTENSION_SEPARATOR);
int filePosi = filePath.lastIndexOf(File.separator);
if (filePosi == -1) {
return (extenPosi == -1 ? filePath : filePath.substring(0,
extenPosi));
}
if (extenPosi == -1) {
return filePath.substring(filePosi + 1);
}
return (filePosi < extenPosi ? filePath.substring(filePosi + 1,
extenPosi) : filePath.substring(filePosi + 1));
}
/**
* 获得文件名
* @param filePath 文件路径
* @return 如果路径为空或空串，返回路径名；不为空时，返回文件名
*/
public static String getFileName(String filePath) {
if (TextUtils.isEmpty(filePath)) {
return filePath;
}
int filePosi = filePath.lastIndexOf(File.separator);
return (filePosi == -1) ? filePath : filePath.substring(filePosi + 1);
}
/**
* 获得所在目录名称
* @param filePath 文件的绝对路径
* @return 如果路径为空或空串，返回路径名；不为空时，如果为根目录，返回"";
* 如果不是根目录，返回所在目录名称，格式如：C:/Windows/Boot
*/
private static String getFolderName(String filePath) {
if (TextUtils.isEmpty(filePath)) {
return filePath;
}
int filePosi = filePath.lastIndexOf(File.separator);
return (filePosi == -1) ? "" : filePath.substring(0, filePosi);
}
/**
* 判断目录是否存在
* @return 如果路径为空或空白字符串，返回false；如果目录存在且，确实是目录文件夹，
* 返回true；如果不是文件夹或者不存在，则返回false
*/
public static boolean isFolderExist(String directoryPath) {
if (TextUtils.isEmpty(directoryPath)) {
return false;
}
File dire = new File(directoryPath);
return (dire.exists() && dire.isDirectory());
}
/**
* 删除指定文件或指定目录内的所有文件
* @param path 文件或目录的绝对路径
* @return 路径为空或空白字符串，返回true；文件不存在，返回true；文件删除返回true；
* 文件删除异常返回false
*/
private static void deleteFile(String path) {
if (TextUtils.isEmpty(path)) {
return;
}
deleteFile(new File(path));
}
/**
* 删除指定文件或指定目录内的所有文件
* @return 路径为空或空白字符串，返回true；文件不存在，返回true；文件删除返回true；
* 文件删除异常返回false
*/
private static void deleteFile(File file) {
if (file == null)
throw new NullPointerException("file is null");
if (!file.exists()) {
return;
}
if (file.isFile()) {
file.delete();
return;
}
if (!file.isDirectory()) {
return;
}
File[] files = file.listFiles();
if (files == null)
return;
for (File f : files) {
if (f.isFile()) {
//noinspection ResultOfMethodCallIgnored
f.delete();
} else if (f.isDirectory()) {
deleteFile(f.getAbsolutePath());
}
}
file.delete();
}
/**
* 删除指定目录中特定的文件
*/
public static void delete(String dir, FilenameFilter filter) {
if (TextUtils.isEmpty(dir))
return;
File file = new File(dir);
if (!file.exists())
return;
if (file.isFile())
//noinspection ResultOfMethodCallIgnored
file.delete();
if (!file.isDirectory())
return;
File[] lists;
if (filter != null)
lists = file.listFiles(filter);
else
lists = file.listFiles();
if (lists == null)
return;
for (File f : lists) {
if (f.isFile()) {
//noinspection ResultOfMethodCallIgnored
f.delete();
}
}
}
/**
* 获得文件或文件夹的大小
* @param path 文件或目录的绝对路径
* @return 返回当前目录的大小 ，注：当文件不存在，为空，或者为空白字符串，返回 -1
*/
public static long getFileSize(String path) {
if (TextUtils.isEmpty(path)) {
return -1;
}
File file = new File(path);
return (file.exists() && file.isFile() ? file.length() : -1);
}
}
这样就可以实现将错误日志自动发送到邮箱了
