Android收集日志文件
package example.com.baseknowledge.IO;
import android.os.Environment;
import android.os.Process;
import android.os.SystemClock;
import android.text.TextUtils;
import android.util.Base64;
import android.util.Log;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.security.KeyFactory;
import java.security.MessageDigest;
import java.security.PublicKey;
import java.security.spec.X509EncodedKeySpec;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import timber.log.Timber;
/**
* ================================================
* 作 者：zhoujianan
* 版 本：v1.0
* 创建日期：2020/8/31
* 描 述:
* 修订历史：
* ================================================
*/
public class FileTreeIo extends Timber.Tree {
private static final SimpleDateFormat LOG_TIME_FORMAT = new SimpleDateFormat("MM-dd HH:mm:ss.SSS");
private static final String LOG_FORMAT = "%s %d-%d %c/%s: %s";
private static final char[] PRIORITY = {'V', 'V', 'V', 'D', 'I', 'W', 'E', 'E', 'E'};
private static final String TAG = "FileLoggingTree";
/************************************* 写入文件 ****************************************/
private LinkedBlockingQueue<String> mLogQueue = new LinkedBlockingQueue<>();
private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("MM-dd HH-mm-ss");
private List<String> mLogFiles = new ArrayList<>();
private boolean mIsEncode;
private volatile boolean mUploadNewFile;
private boolean mIsExit;
ExecutorService mZipService;
@Override
protected void log(int priority, String tag, String message, Throwable t) {
String timeStamp = LOG_TIME_FORMAT.format(Calendar.getInstance().getTime());
String formatInfo = String.format(LOG_FORMAT, timeStamp, Process.myPid(), Process.myTid(), PRIORITY[priority], tag, message);
//mTempCache.write(formatInfo);
System.out.println("log is " + formatInfo);
if (mLogQueue != null && !mLogQueue.offer(formatInfo)) {
Log.e(TAG, "File LogQueue is Full.!!!!");
}
}
private void startWriteFile() {
while (true) {
BufferedOutputStream opt = null;
try {
synchronized (this) {
String fileName = "Log-" + simpleDateFormat.format(Calendar.getInstance().getTime())
+ "(" + Process.myPid() + ")" + ".log";
opt = new BufferedOutputStream(new FileOutputStream(mFileDir + fileName));
System.out.println("startWriteFile: mFileDir " + mFileDir + " fileName: " + fileName);
mLogFiles.add(fileName);
}
if (mIsEncode) {
opt.write(("DecodeAESKey:" + mDecodeAESKey + "\n").getBytes("UTF-8"));
}
mUploadNewFile = false;
String logInfo;
int logCount = 0;
while (true) {
logInfo = mLogQueue.take();
if (logInfo != null && !TextUtils.isEmpty(logInfo = logInfo.trim())) {
logInfo = logInfo.replace("\n", "\n ");
if (mIsEncode) {
logInfo = encodeAES(logInfo);
}
System.out.println("write: " + logInfo);
System.out.println("logCount: " + logCount + " 消息剩余 " + mLogQueue.size());
opt.write((logInfo + "\n").getBytes("UTF-8"));
logCount++;
if (mIsExit) {
opt.flush();
}
}
if (mUploadNewFile || logCount > 5 * 10000) {
opt.write(("消息剩余 " + mLogQueue.size()).getBytes("UTF-8"));
opt.flush();
opt.close();
zipLog();
break;
}
}
} catch (IOException e) {
if (opt != null) {
try {
opt.flush();
opt.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
if (!trySolveException(e)) {
mLogQueue = null;
return;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void zipLog() {
mZipService.execute(zipRunnable);
}
private Runnable zipRunnable = new Runnable() {
@Override
public void run() {
BufferedOutputStream zipOpt = null;
ZipOutputStream zipOutputStream = null;
System.out.println("zipRunnable");
try {
String zipName = "Log-" + simpleDateFormat.format(Calendar.getInstance().getTime())
+ "(" + Process.myPid() + ")" + ".zip";
zipOutputStream = new ZipOutputStream(new FileOutputStream(mFileDir + zipName));
zipOpt = new BufferedOutputStream(zipOutputStream);
LinkedList<File> LogFileList = new LinkedList<>();
for (int i = mLogFiles.size() - 1; i >= 0; i--) {
File file = new File(mFileDir, mLogFiles.get(i));
if (file.exists() && file.length() > 0) {
LogFileList.addFirst(file);
}
if (LogFileList.size() > 2) {
break;
}
}
int fileCount = 0;
for (File file : LogFileList) {
String fileName = "Log-" + simpleDateFormat.format(Calendar.getInstance().getTime())
+ "(" + Process.myPid() + ")" + "-" + fileCount + ".log";
zipOutputStream.putNextEntry(new ZipEntry(fileName));
byte[] data = new byte[1024];
int read;
BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(file));
while ((read = inputStream.read(data, 0, data.length)) != -1) {
zipOpt.write(data, 0, read);
}
fileCount++;
file.delete();
}
zipOpt.flush();
zipOpt.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
try {
if (zipOpt != null) {
zipOpt.flush();
zipOpt.close();
}
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
};
private int mtrySolveCount;
private boolean trySolveException(IOException e) {
if (mtrySolveCount++ > 10) {
return false;
}
if (e instanceof FileNotFoundException) {
prepare();
return new File(mFileDir).exists();
}
File[] files = new File(mFileDir).listFiles(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return !mLogFiles.contains(name);
}
});
if (files != null && files.length / 3 > 0) {
int index = files.length / 3;
for (int i = 0; i < index; i++) {
files[i].delete();
}
return true;
}
return false;
}
/************************************* 初始化 ****************************************/
private FileTreeIo(boolean isDebug) {
new Thread(new Runnable() {
@Override
public void run() {
init(isDebug);
prepare();
deleteExpiredlog();
startWriteFile();
mIsEncode = true;
}
}).start();
mZipService = Executors.newSingleThreadExecutor();
}
private static FileTreeIo INSTANCE;
public static FileTreeIo setup(boolean isDebug) {
INSTANCE = new FileTreeIo(isDebug);
return INSTANCE;
}
public static FileTreeIo getInstance() {
return INSTANCE;
}
/************************************* 初始化文件目录 ****************************************/
private String mFileDir;
private void prepare() {
File directory = Environment.getExternalStorageDirectory();
String saveDirectoy = directory + "/xxx/LIVE/Log";
Log.d(TAG, "saveDirectoy =>" + saveDirectoy);
File folder = new File(saveDirectoy);
if (!folder.exists()) {
folder.mkdirs();
}
mFileDir = saveDirectoy + "/";
}
/**
* 删除过期的日志
*/
private void deleteExpiredlog() {
File saveDir = new File(mFileDir);
File[] files = saveDir.listFiles();
if (files == null) {
return;
}
long currentTimeMillis = System.currentTimeMillis();
long lastModified;
for (File file : files) {
lastModified = file.lastModified();
if ((currentTimeMillis - lastModified) > (24 * 60 * 60 * 1000)) {
file.delete();
}
}
}
/************************************* - 收集日志 - ****************************************/
public LinkedList<File> collectLog() {
synchronized (this) {
mUploadNewFile = true;
Timber.tag(TAG).i("collectLog UpNewFile");
SystemClock.sleep(500);
LinkedList<File> collectFiles = new LinkedList<>();
for (int i = mLogFiles.size() - 1; i >= 0; i--) {
File file = new File(mFileDir, mLogFiles.get(i));
if (file.exists() && file.length() > 0) {
collectFiles.addFirst(file);
}
if (collectFiles.size() >= 2) {
break;
}
}
return collectFiles;
}
}
/************************************* 初始化加解密 ****************************************/
private static final String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCvXe+pNk/oqMRL5wdjG5CWPxAK0lNoHqanS2NsGyej2SgO6yD6MtUFmrhdNnhe0rlGE9U5zrEEHwjiLPVE+SQ9atmMo0GTZwsI9drBkm0vSYjYIv5c7Uy5c0HZCcjCxGvQDPU6MmhtA4f4GUOD0XWYhqWO+U0spkh8uZGVq7CIXQIDAQAB";
private String mDecodeAESKey;
private Cipher mEnCipher;
private String encodeAES(String content) {
try {
byte[] bytes = mEnCipher.doFinal(content.getBytes("UTF-8"));
return new String(Base64.encode(bytes, Base64.NO_WRAP), "UTF-8");
} catch (Exception e) {
mIsEncode = false;
Timber.tag(TAG).e(e, "encodeAES error");
}
return content;
}
private void init(boolean isDebug) {
if (!isDebug) {
try {
String randomKey = getRandomString(32);
byte[] bytes = encryptByPublicKey(randomKey.getBytes("UTF-8"), Base64.decode(PUBLIC_KEY, Base64.NO_WRAP));
mDecodeAESKey = new String(Base64.encode(bytes, Base64.NO_WRAP), "UTF-8");
Log.d(TAG, "DecodeAESKey:" + mDecodeAESKey);
mEnCipher = generateAESCipher(randomKey);
mIsEncode = true;
} catch (Exception e) {
Timber.tag(TAG).e(e, "init encode error");
}
}
}
/**
* 随机生成字符串
*
* @param length
* @return
*/
private static String getRandomString(int length) {
String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
Random random = new Random();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < length; i++) {
int number = random.nextInt(62);
sb.append(str.charAt(number));
}
return sb.toString();
}
private static Cipher generateAESCipher(String password) throws Exception {
byte[] rawKey = MessageDigest.getInstance("MD5").digest(password.getBytes("UTF-8"));
SecretKeySpec skeySpec = new SecretKeySpec(rawKey, "AES");
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
return cipher;
}
/**
* RSA算法
*/
private static final String RSA_ANDROID = "RSA/ECB/PKCS1Padding";
/**
* 使用公钥加密
*/
private static byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
// 得到公钥对象
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey pubKey = keyFactory.generatePublic(keySpec);
// 加密数据
Cipher cp = Cipher.getInstance(RSA_ANDROID);
cp.init(Cipher.ENCRYPT_MODE, pubKey);
byte[] bytes = cp.doFinal(data);
return bytes;
}
}
在打印日志的根部：需要调用log方法，加入到队列中