Android的log保存到文件上查看

http://www.bangchui.org/simple/?t32309.html


在调试的时候一般都是在logcat中看日志的信息,以便找出BUG和调试信息,但是如果在真机上的话不可能一直连接电脑查看日志,所以生成日志文件并保存,是一个比较普遍的需求,下面就是最近实现的一个例子。欢迎大家讨论并给出别的思路。


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;
import java.util.List;

import android.app.AlarmManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Environment;
import android.os.IBinder;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.util.Log;

/**
* 日志服务,日志默认会存储在SDcar里如果没有SDcard会存储在内存中的安装目录下面。
* 1.本服务默认在SDcard中每天生成一个日志文件,
* 2.如果有SDCard的话会将之前内存中的文件拷贝到SDCard中
* 3.如果没有SDCard,在安装目录下只保存当前在写日志
* 4.SDcard的装载卸载动作会在步骤2,3中切换
* 5.SDcard中的日志文件只保存7天
* @author Administrator
*
*/
public class LogService extends Service {
         private static final String TAG = "LogService";

         private static final int MEMORY_LOG_FILE_MAX_SIZE = 10 * 1024 * 1024;                        //内存中日志文件最大值,10M
         private static final int MEMORY_LOG_FILE_MONITOR_INTERVAL = 10 * 60 * 1000;                //内存中的日志文件大小监控时间间隔,10分钟
         private static final int SDCARD_LOG_FILE_SAVE_DAYS = 7;                                                        //sd卡中日志文件的最多保存天数
        
         private String LOG_PATH_MEMORY_DIR;                //日志文件在内存中的路径(日志文件在安装目录中的路径)
         private String LOG_PATH_SDCARD_DIR;                //日志文件在sdcard中的路径
         @SuppressWarnings("unused")
         private String LOG_SERVICE_LOG_PATH;        //本服务产生的日志,记录日志服务开启失败信息
        
         private final int SDCARD_TYPE = 0;                        //当前的日志记录类型为存储在SD卡下面
         private final int MEMORY_TYPE = 1;                        //当前的日志记录类型为存储在内存中
         private int CURR_LOG_TYPE = SDCARD_TYPE;        //当前的日志记录类型
        
         private String CURR_INSTALL_LOG_NAME;        //如果当前的日志写在内存中,记录当前的日志文件名称
        
         private String logServiceLogName = "Log.log";//本服务输出的日志文件名称
         private SimpleDateFormat myLogSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         private OutputStreamWriter writer;
        
         private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HHmmss");//日志名称格式
        
         private Process process;
        
         private WakeLock wakeLock;  
        
         private SDStateMonitorReceiver sdStateReceiver; //SDcard状态监测
         private LogTaskReceiver logTaskReceiver;
        
         /* 是否正在监测日志文件大小;
          * 如果当前日志记录在SDcard中则为false
          * 如果当前日志记录在内存中则为true*/
         private boolean logSizeMoniting = false;                
        
         private static String MONITOR_LOG_SIZE_ACTION = "MONITOR_LOG_SIZE";                //日志文件监测action
         private static String SWITCH_LOG_FILE_ACTION = "SWITCH_LOG_FILE_ACTION";        //切换日志文件action
        
         @Override
         public IBinder onBind(Intent intent) {
                 return null;
         }

         @Override
         public void onCreate() {
                 super.onCreate();
                 init();
                 register();
                 deploySwitchLogFileTask();        
                 new LogCollectorThread().start();
         }
        
         private void init(){
                 LOG_PATH_MEMORY_DIR = getFilesDir().getAbsolutePath() + File.separator + "log";
                 LOG_SERVICE_LOG_PATH = LOG_PATH_MEMORY_DIR + File.separator + logServiceLogName;
                 LOG_PATH_SDCARD_DIR = Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator
                                                         +        "MyApp" + File.separator + "log";
                 createLogDir();
                
                 /* ******************************************************
                 try {
                         writer = new OutputStreamWriter(new FileOutputStream(
                                         LOG_SERVICE_LOG_PATH, true));
                 } catch (FileNotFoundException e) {
                         Log.e(TAG, e.getMessage(), e);
                 }
                 * ******************************************************/
                 PowerManager pm = (PowerManager) getApplicationContext().getSystemService(Context.POWER_SERVICE);
                 wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
                
                 CURR_LOG_TYPE = getCurrLogType();
                 Log.i(TAG, "LogService onCreate");
         }
        
         private void register(){
                 IntentFilter sdCarMonitorFilter = new IntentFilter();
                 sdCarMonitorFilter.addAction(Intent.ACTION_MEDIA_MOUNTED);
                 sdCarMonitorFilter.addAction(Intent.ACTION_MEDIA_UNMOUNTED);
                 sdCarMonitorFilter.addDataScheme("file");
                 sdStateReceiver = new SDStateMonitorReceiver();
                 registerReceiver(sdStateReceiver, sdCarMonitorFilter);
                
                 IntentFilter logTaskFilter = new IntentFilter();
                 logTaskFilter.addAction(MONITOR_LOG_SIZE_ACTION);
                 logTaskFilter.addAction(SWITCH_LOG_FILE_ACTION);
                 logTaskReceiver = new LogTaskReceiver();
                 registerReceiver(logTaskReceiver,logTaskFilter);
         }
        
        
        
         /**
          * 获取当前应存储在内存中还是存储在SDCard中
          * @return
          */
         public int getCurrLogType(){
                 if (!Environment.getExternalStorageState().equals(
                                 Environment.MEDIA_MOUNTED)) {
                         return MEMORY_TYPE;
                 }else{
                         return SDCARD_TYPE;
                 }
         }

         /**
          * 部署日志切换任务,每天凌晨切换日志文件
          */
         private void deploySwitchLogFileTask() {
                 Intent intent = new Intent(SWITCH_LOG_FILE_ACTION);
                 PendingIntent sender = PendingIntent.getBroadcast(this, 0, intent, 0);
                 Calendar calendar = Calendar.getInstance();
                 calendar.add(Calendar.DAY_OF_MONTH, 1);
                 calendar.set(Calendar.HOUR_OF_DAY, 0);
                 calendar.set(Calendar.MINUTE, 0);
                 calendar.set(Calendar.SECOND, 0);

                 // 部署任务
                 AlarmManager am = (AlarmManager) getSystemService(ALARM_SERVICE);
                 am.setRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), AlarmManager.INTERVAL_DAY, sender);
                 recordLogServiceLog("deployNextTask succ,next task time is:"+myLogSdf.format(calendar.getTime()));
         }

         /**
          * 日志收集
          * 1.清除日志缓存
          * 2.杀死应用程序已开启的Logcat进程防止多个进程写入一个日志文件
          * 3.开启日志收集进程
          * 4.处理日志文件
          *   移动 OR 删除
          */
         class LogCollectorThread extends Thread {
                
                 public LogCollectorThread(){
                         super("LogCollectorThread");
                         Log.d(TAG, "LogCollectorThread is create");
                 }
                
                 @Override
                 public void run() {
                         try {
                                 wakeLock.acquire();        //唤醒手机
                                
                                 clearLogCache();
                                
                                 List<String> orgProcessList = getAllProcess();
                                 List<ProcessInfo> processInfoList = getProcessInfoList(orgProcessList);
                                 killLogcatProc(processInfoList);
                                
                                 createLogCollector();
                                
                                 Thread.sleep(1000);//休眠,创建文件,然后处理文件,不然该文件还没创建,会影响文件删除
                                
                                 handleLog();
                                
                                 wakeLock.release();        //释放
                         } catch (Exception e) {
                                 e.printStackTrace();
                                 recordLogServiceLog(Log.getStackTraceString(e));
                         }
                 }
         }
        
         /**
          * 每次记录日志之前先清除日志的缓存, 不然会在两个日志文件中记录重复的日志
          */
         private void clearLogCache() {
                 Process proc = null;
                 List<String> commandList = new ArrayList<String>();
                 commandList.add("logcat");
                 commandList.add("-c");
                 try {
                         proc = Runtime.getRuntime().exec(
                                         commandList.toArray(new String[commandList.size()]));
                         StreamConsumer errorGobbler = new StreamConsumer(proc
                                         .getErrorStream());

                         StreamConsumer outputGobbler = new StreamConsumer(proc
                                         .getInputStream());

                         errorGobbler.start();
                         outputGobbler.start();
                         if (proc.waitFor() != 0) {
                                 Log.e(TAG, " clearLogCache proc.waitFor() != 0");
                                 recordLogServiceLog("clearLogCache clearLogCache proc.waitFor() != 0");
                         }
                 } catch (Exception e) {
                         Log.e(TAG, "clearLogCache failed", e);
                         recordLogServiceLog("clearLogCache failed");
                 } finally {
                         try {
                                 proc.destroy();
                         } catch (Exception e) {
                                 Log.e(TAG, "clearLogCache failed", e);
                                 recordLogServiceLog("clearLogCache failed");
                         }
                 }
         }

         /**
          * 关闭由本程序开启的logcat进程:
          * 根据用户名称杀死进程(如果是本程序进程开启的Logcat收集进程那么两者的USER一致)
          * 如果不关闭会有多个进程读取logcat日志缓存信息写入日志文件
          *
          * @param allProcList
          * @return
          */
         private void killLogcatProc(List<ProcessInfo> allProcList) {
                 if(process != null){
                         process.destroy();
                 }
                 String packName = this.getPackageName();
                 String myUser = getAppUser(packName, allProcList);
                 /*
                 recordLogServiceLog("app user is:"+myUser);
                 recordLogServiceLog("========================");
                 for (ProcessInfo processInfo : allProcList) {
                         recordLogServiceLog(processInfo.toString());
                 }
                 recordLogServiceLog("========================");
                 */
                 for (ProcessInfo processInfo : allProcList) {
                         if (processInfo.name.toLowerCase().equals("logcat")
                                         && processInfo.user.equals(myUser)) {
                                 android.os.Process.killProcess(Integer
                                                 .parseInt(processInfo.pid));
                                 //recordLogServiceLog("kill another logcat process success,the process info is:"
                                 //                + processInfo);
                         }
                 }
         }

         /**
          * 获取本程序的用户名称
          *
          * @param packName
          * @param allProcList
          * @return
          */
         private String getAppUser(String packName, List<ProcessInfo> allProcList) {
                 for (ProcessInfo processInfo : allProcList) {
                         if (processInfo.name.equals(packName)) {
                                 return processInfo.user;
                         }
                 }
                 return null;
         }

         /**
          * 根据ps命令得到的内容获取PID,User,name等信息
          *
          * @param orgProcessList
          * @return
          */
         private List<ProcessInfo> getProcessInfoList(List<String> orgProcessList) {
                 List<ProcessInfo> procInfoList = new ArrayList<ProcessInfo>();
                 for (int i = 1; i < orgProcessList.size(); i++) {
                         String processInfo = orgProcessList.get(i);
                         String[] proStr = processInfo.split(" ");
                         // USER PID PPID VSIZE RSS WCHAN PC NAME
                         // root 1 0 416 300 c00d4b28 0000cd5c S /init
                         List<String> orgInfo = new ArrayList<String>();
                         for (String str : proStr) {
                                 if (!"".equals(str)) {
                                         orgInfo.add(str);
                                 }
                         }
                         if (orgInfo.size() == 9) {
                                 ProcessInfo pInfo = new ProcessInfo();
                                 pInfo.user = orgInfo.get(0);
                                 pInfo.pid = orgInfo.get(1);
                                 pInfo.ppid = orgInfo.get(2);
                                 pInfo.name = orgInfo.get(8);
                                 procInfoList.add(pInfo);
                         }
                 }
                 return procInfoList;
         }

         /**
          * 运行PS命令得到进程信息
          *
          * @return
          *                         USER PID PPID VSIZE RSS WCHAN PC NAME
          *                         root 1 0 416 300 c00d4b28 0000cd5c S /init
          */
         private List<String> getAllProcess() {
                 List<String> orgProcList = new ArrayList<String>();
                 Process proc = null;
                 try {
                         proc = Runtime.getRuntime().exec("ps");
                         StreamConsumer errorConsumer = new StreamConsumer(proc
                                         .getErrorStream());

                         StreamConsumer outputConsumer = new StreamConsumer(proc
                                         .getInputStream(), orgProcList);

                         errorConsumer.start();
                         outputConsumer.start();
                         if (proc.waitFor() != 0) {
                                 Log.e(TAG, "getAllProcess proc.waitFor() != 0");
                                 recordLogServiceLog("getAllProcess proc.waitFor() != 0");
                         }
                 } catch (Exception e) {
                         Log.e(TAG, "getAllProcess failed", e);
                         recordLogServiceLog("getAllProcess failed");
                 } finally {
                         try {
                                 proc.destroy();
                         } catch (Exception e) {
                                 Log.e(TAG, "getAllProcess failed", e);
                                 recordLogServiceLog("getAllProcess failed");
                         }
                 }
                 return orgProcList;
         }
        
         /**
          * 开始收集日志信息
          */
         public void createLogCollector() {
                 String logFileName = sdf.format(new Date()) + ".log";// 日志文件名称
                 List<String> commandList = new ArrayList<String>();
                 commandList.add("logcat");
                 commandList.add("-f");
                 //commandList.add(LOG_PATH_INSTALL_DIR + File.separator + logFileName);
                 commandList.add(getLogPath());
                 commandList.add("-v");
                 commandList.add("time");
                 commandList.add("*:I");
                
                 //commandList.add("*:E");// 过滤所有的错误信息

                 // 过滤指定TAG的信息
                 // commandList.add("MyAPP:V");
                 // commandList.add("*:S");
                 try {
                         process = Runtime.getRuntime().exec(
                                         commandList.toArray(new String[commandList.size()]));
                         recordLogServiceLog("start collecting the log,and log name is:"+logFileName);
                         // process.waitFor();
                 } catch (Exception e) {
                         Log.e(TAG, "CollectorThread == >" + e.getMessage(), e);
                         recordLogServiceLog("CollectorThread == >" + e.getMessage());
                 }
         }
        
         /**
          * 根据当前的存储位置得到日志的绝对存储路径
          * @return
          */
         public String getLogPath(){
                 createLogDir();
                 String logFileName = sdf.format(new Date()) + ".log";// 日志文件名称
                 if(CURR_LOG_TYPE == MEMORY_TYPE){
                         CURR_INSTALL_LOG_NAME = logFileName;
                         Log.d(TAG, "Log stored in memory, the path is:"+LOG_PATH_MEMORY_DIR + File.separator + logFileName);
                         return LOG_PATH_MEMORY_DIR + File.separator + logFileName;
                 }else{
                         CURR_INSTALL_LOG_NAME = null;
                         Log.d(TAG, "Log stored in SDcard, the path is:"+LOG_PATH_SDCARD_DIR + File.separator + logFileName);
                         return LOG_PATH_SDCARD_DIR + File.separator + logFileName;
                 }
         }
        
         /**
          * 处理日志文件
          * 1.如果日志文件存储位置切换到内存中,删除除了正在写的日志文件
          *   并且部署日志大小监控任务,控制日志大小不超过规定值
          * 2.如果日志文件存储位置切换到SDCard中,删除7天之前的日志,移
          *            动所有存储在内存中的日志到SDCard中,并将之前部署的日志大小
          *   监控取消
          */
         public void handleLog(){
                 if(CURR_LOG_TYPE == MEMORY_TYPE){
                         deployLogSizeMonitorTask();
                         deleteMemoryExpiredLog();
                 }else{
                         moveLogfile();
                         cancelLogSizeMonitorTask();
                         deleteSDcardExpiredLog();
                 }
         }
        
         /**
          * 部署日志大小监控任务
          */
         private void deployLogSizeMonitorTask() {
                 if(logSizeMoniting){        //如果当前正在监控着,则不需要继续部署
                         return;
                 }
                 logSizeMoniting = true;
                 Intent intent = new Intent(MONITOR_LOG_SIZE_ACTION);
                 PendingIntent sender = PendingIntent.getBroadcast(this, 0, intent, 0);
                 AlarmManager am = (AlarmManager) getSystemService(ALARM_SERVICE);
                 am.setRepeating(AlarmManager.RTC_WAKEUP,System.currentTimeMillis(), MEMORY_LOG_FILE_MONITOR_INTERVAL, sender);
                 Log.d(TAG, "deployLogSizeMonitorTask() succ !");
                 //recordLogServiceLog("deployLogSizeMonitorTask() succ ,start time is " + calendar.getTime().toLocaleString());
         }
        
         /**
          * 取消部署日志大小监控任务
          */  
         private void cancelLogSizeMonitorTask() {
                 logSizeMoniting = false;
                 AlarmManager am = (AlarmManager) getSystemService(ALARM_SERVICE);
                 Intent intent = new Intent(MONITOR_LOG_SIZE_ACTION);
                 PendingIntent sender = PendingIntent.getBroadcast(this, 0, intent, 0);
                 am.cancel(sender);
                
                 Log.d(TAG, "canelLogSizeMonitorTask() succ");
         }
        
         /**
          * 检查日志文件大小是否超过了规定大小
          * 如果超过了重新开启一个日志收集进程
          */
         private void checkLogSize(){
                 if(CURR_INSTALL_LOG_NAME != null && !"".equals(CURR_INSTALL_LOG_NAME)){
                         String path = LOG_PATH_MEMORY_DIR + File.separator + CURR_INSTALL_LOG_NAME;
                         File file = new File(path);
                         if(!file.exists()){
                                 return;
                         }
                         Log.d(TAG, "checkLog() ==> The size of the log is too big?");
                         if(file.length() >= MEMORY_LOG_FILE_MAX_SIZE){
                                 Log.d(TAG, "The log's size is too big!");
                                 new LogCollectorThread().start();
                         }
                 }
         }
        
         /**
          * 创建日志目录
          */
         private void createLogDir() {
                 File file = new File(LOG_PATH_MEMORY_DIR);
                 boolean mkOk;
                 if (!file.isDirectory()) {
                         mkOk = file.mkdirs();
                         if (!mkOk) {
                                 mkOk = file.mkdirs();
                         }
                 }

                 /* ************************************
                 file = new File(LOG_SERVICE_LOG_PATH);
                 if (!file.exists()) {
                         try {
                                 mkOk = file.createNewFile();
                                 if (!mkOk) {
                                         file.createNewFile();
                                 }
                         } catch (IOException e) {
                                 Log.e(TAG, e.getMessage(), e);
                         }
                 }
                 * ************************************/
                
                 if (Environment.getExternalStorageState().equals(
                                 Environment.MEDIA_MOUNTED)) {
                         file = new File(LOG_PATH_SDCARD_DIR);
                         if (!file.isDirectory()) {
                                 mkOk = file.mkdirs();
                                 if (!mkOk) {
                                         recordLogServiceLog("move file failed,dir is not created succ");
                                         return;
                                 }
                         }
                 }
         }
        
         /**
          * 将日志文件转移到SD卡下面
          */
         private void moveLogfile() {
                 if (!Environment.getExternalStorageState().equals(
                                 Environment.MEDIA_MOUNTED)) {
                         //recordLogServiceLog("move file failed, sd card does not mount");
                         return;
                 }
                 File file = new File(LOG_PATH_SDCARD_DIR);
                 if (!file.isDirectory()) {
                         boolean mkOk = file.mkdirs();
                         if (!mkOk) {
                                 //recordLogServiceLog("move file failed,dir is not created succ");
                                 return;
                         }
                 }

                 file = new File(LOG_PATH_MEMORY_DIR);
                 if (file.isDirectory()) {
                         File[] allFiles = file.listFiles();
                         for (File logFile : allFiles) {
                                 String fileName = logFile.getName();
                                 if (logServiceLogName.equals(fileName)) {
                                         continue;
                                 }
                                 //String createDateInfo = getFileNameWithoutExtension(fileName);
                                 boolean isSucc = copy(logFile, new File(LOG_PATH_SDCARD_DIR
                                                         + File.separator + fileName));
                                 if (isSucc) {
                                         logFile.delete();
                                         //recordLogServiceLog("move file success,log name is:"+fileName);
                                 }
                         }
                 }
         }

         /**
          * 删除内存下过期的日志
          */
         private void deleteSDcardExpiredLog() {
                 File file = new File(LOG_PATH_SDCARD_DIR);
                 if (file.isDirectory()) {
                         File[] allFiles = file.listFiles();
                         for (File logFile : allFiles) {
                                 String fileName = logFile.getName();
                                 if (logServiceLogName.equals(fileName)) {
                                         continue;
                                 }
                                 String createDateInfo = getFileNameWithoutExtension(fileName);
                                 if (canDeleteSDLog(createDateInfo)) {
                                         logFile.delete();
                                         Log.d(TAG, "delete expired log success,the log path is:"
                                                         + logFile.getAbsolutePath());

                                 }
                         }
                 }
         }
        
         /**
          * 判断sdcard上的日志文件是否可以删除
          * @param createDateStr
          * @return
          */
         public boolean canDeleteSDLog(String createDateStr) {
                 boolean canDel = false;
                 Calendar calendar = Calendar.getInstance();
                 calendar.add(Calendar.DAY_OF_MONTH, -1 * SDCARD_LOG_FILE_SAVE_DAYS);//删除7天之前日志
                 Date expiredDate = calendar.getTime();
                 try {
                         Date createDate = sdf.parse(createDateStr);
                         canDel = createDate.before(expiredDate);
                 } catch (ParseException e) {
                         Log.e(TAG, e.getMessage(), e);
                         canDel = false;
                 }
                 return canDel;
         }

        
         /**
          * 删除内存中的过期日志,删除规则:
          * 除了当前的日志和离当前时间最近的日志保存其他的都删除
          */
         private void deleteMemoryExpiredLog(){
                 File file = new File(LOG_PATH_MEMORY_DIR);
                 if (file.isDirectory()) {
                         File[] allFiles = file.listFiles();
                         Arrays.sort(allFiles, new FileComparator());
                         for (int i=0;i<allFiles.length-2;i++) {        //"-2"保存最近的两个日志文件
                                 File _file =  allFiles;
                                 if (logServiceLogName.equals(_file.getName()) ||  _file.getName().equals(CURR_INSTALL_LOG_NAME)) {
                                         continue;
                                 }
                                 _file.delete();
                                 Log.d(TAG, "delete expired log success,the log path is:"+_file.getAbsolutePath());
                         }
                 }
         }
        
         /**
          * 拷贝文件
          * @param source
          * @param target
          * @return
          */
         private boolean copy(File source, File target) {
                 FileInputStream in = null;
                 FileOutputStream out = null;
                 try {
                         if(!target.exists()){
                                 boolean createSucc = target.createNewFile();
                                 if(!createSucc){
                                         return false;
                                 }
                         }
                         in = new FileInputStream(source);
                         out = new FileOutputStream(target);
                         byte[] buffer = new byte[8*1024];
                         int count;
                         while ((count = in.read(buffer)) != -1) {
                                 out.write(buffer, 0, count);
                         }
                         return true;
                 } catch (Exception e) {
                         e.printStackTrace();
                         Log.e(TAG, e.getMessage(), e);
                         recordLogServiceLog("copy file fail");
                         return false;
                 } finally{
                         try {
                                 if(in != null){
                                         in.close();
                                 }
                                 if(out != null){
                                         out.close();
                                 }
                         } catch (IOException e) {
                                 e.printStackTrace();
                                 Log.e(TAG, e.getMessage(), e);
                                 recordLogServiceLog("copy file fail");
                                 return false;
                         }
                 }
                
         }

         /**
          * 记录日志服务的基本信息 防止日志服务有错,在LogCat日志中无法查找
          * 此日志名称为Log.log
          *
          * @param msg
          */
         private void recordLogServiceLog(String msg) {
                 if (writer != null) {
                         try {
                                 Date time = new Date();
                                 writer.write(myLogSdf.format(time) + " : " + msg);
                                 writer.write("\n");
                                 writer.flush();
                         } catch (IOException e) {
                                 e.printStackTrace();
                                 Log.e(TAG, e.getMessage(), e);
                         }
                 }
         }
        
         /**
          * 去除文件的扩展类型(.log)
          * @param fileName
          * @return
          */
         private String getFileNameWithoutExtension(String fileName){
                 return fileName.substring(0, fileName.indexOf("."));
         }

         class ProcessInfo {
                 public String user;
                 public String pid;
                 public String ppid;
                 public String name;

                 @Override
                 public String toString() {
                         String str = "user=" + user + " pid=" + pid + " ppid=" + ppid
                                         + " name=" + name;
                         return str;
                 }
         }
         class StreamConsumer extends Thread {
                 InputStream is;
                 List<String> list;

                 StreamConsumer(InputStream is) {
                         this.is = is;
                 }

                 StreamConsumer(InputStream is, List<String> list) {
                         this.is = is;
                         this.list = list;
                 }

                 public void run() {
                         try {
                                 InputStreamReader isr = new InputStreamReader(is);
                                 BufferedReader br = new BufferedReader(isr);
                                 String line = null;
                                 while ((line = br.readLine()) != null) {
                                         if (list != null) {
                                                 list.add(line);
                                         }
                                 }
                         } catch (IOException ioe) {
                                 ioe.printStackTrace();
                         }
                 }
         }
        
         /**
          * 监控SD卡状态
          * @author Administrator
          *
          */
         class SDStateMonitorReceiver extends BroadcastReceiver{
                 public void onReceive(Context context, Intent intent) {
                        
                         if(Intent.ACTION_MEDIA_UNMOUNTED.equals(intent.getAction())){        //存储卡被卸载
                                 if(CURR_LOG_TYPE == SDCARD_TYPE){
                                         Log.d(TAG, "SDcar is UNMOUNTED");
                                         CURR_LOG_TYPE = MEMORY_TYPE;
                                         new LogCollectorThread().start();
                                 }
                         }else{                                                                                                                        //存储卡被挂载
                                 if(CURR_LOG_TYPE == MEMORY_TYPE){
                                         Log.d(TAG, "SDcar is MOUNTED");
                                         CURR_LOG_TYPE = SDCARD_TYPE;
                                         new LogCollectorThread().start();
                                        
                                 }
                         }
                 }
         }
        
         /**
          * 日志任务接收
          * 切换日志,监控日志大小
          * @author Administrator
          *
          */
         class LogTaskReceiver extends BroadcastReceiver{
                 public void onReceive(Context context, Intent intent) {
                         String action = intent.getAction();
                         if(SWITCH_LOG_FILE_ACTION.equals(action)){
                                 new LogCollectorThread().start();
                         }else if(MONITOR_LOG_SIZE_ACTION.equals(action)){
                                 checkLogSize();
                         }
                 }
         }
        
         class FileComparator implements Comparator<File>{
                 public int compare(File file1, File file2) {
                         if(logServiceLogName.equals(file1.getName())){
                                 return -1;
                         }else if(logServiceLogName.equals(file2.getName())){
                                 return 1;
                         }
                        
                         String createInfo1 = getFileNameWithoutExtension(file1.getName());
                         String createInfo2 = getFileNameWithoutExtension(file2.getName());
                        
                         try {
                                 Date create1 = sdf.parse(createInfo1);
                                 Date create2 = sdf.parse(createInfo2);
                                 if(create1.before(create2)){
                                         return -1;
                                 }else{
                                         return 1;
                                 }
                         } catch (ParseException e) {
                                 return 0;
                         }
                 }
         }
        
         @Override
         public void onDestroy() {
                 super.onDestroy();
                 recordLogServiceLog("LogService onDestroy");
                 if (writer != null) {
                         try {
                                 writer.close();
                         } catch (IOException e) {
                                 e.printStackTrace();
                         }
                 }
                 if (process != null) {
                         process.destroy();
                 }
                
                 unregisterReceiver(sdStateReceiver);
                 unregisterReceiver(logTaskReceiver);
         }

}



最后不要忘记在配置文件中加入
Xml代码  
<uses-permission android:name="android.permission.READ_LOGS" />

阅读更多
换一批

没有更多推荐了,返回首页