android 日志服务，存储在文件中

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

 

 

Java代码  

1. import java.io.BufferedReader;  
2. import java.io.File;  
3. import java.io.FileInputStream;  
4. import java.io.FileOutputStream;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.io.InputStreamReader;  
8. import java.io.OutputStreamWriter;  
9. import java.text.ParseException;  
10. import java.text.SimpleDateFormat;  
11. import java.util.ArrayList;  
12. import java.util.Arrays;  
13. import java.util.Calendar;  
14. import java.util.Comparator;  
15. import java.util.Date;  
16. import java.util.List;  
17.   
18. import android.app.AlarmManager;  
19. import android.app.PendingIntent;  
20. import android.app.Service;  
21. import android.content.BroadcastReceiver;  
22. import android.content.Context;  
23. import android.content.Intent;  
24. import android.content.IntentFilter;  
25. import android.os.Environment;  
26. import android.os.IBinder;  
27. import android.os.PowerManager;  
28. import android.os.PowerManager.WakeLock;  
29. import android.util.Log;  
30.   
31. /** 
32.  * 日志服务，日志默认会存储在SDcar里如果没有SDcard会存储在内存中的安装目录下面。 
33.  * 1.本服务默认在SDcard中每天生成一个日志文件, 
34.  * 2.如果有SDCard的话会将之前内存中的文件拷贝到SDCard中 
35.  * 3.如果没有SDCard，在安装目录下只保存当前在写日志 
36.  * 4.SDcard的装载卸载动作会在步骤2,3中切换 
37.  * 5.SDcard中的日志文件只保存7天 
38.  * @author Administrator 
39.  *  
40.  */  
41. public class LogService extends Service {  
42.     private static final String TAG = "LogService";  
43.   
44.     private static final int MEMORY_LOG_FILE_MAX_SIZE = 10 * 1024 * 1024;           //内存中日志文件最大值，10M  
45.     private static final int MEMORY_LOG_FILE_MONITOR_INTERVAL = 10 * 60 * 1000;     //内存中的日志文件大小监控时间间隔，10分钟  
46.     private static final int SDCARD_LOG_FILE_SAVE_DAYS = 7;                         //sd卡中日志文件的最多保存天数  
47.       
48.     private String LOG_PATH_MEMORY_DIR;     //日志文件在内存中的路径(日志文件在安装目录中的路径)  
49.     private String LOG_PATH_SDCARD_DIR;     //日志文件在sdcard中的路径  
50.     @SuppressWarnings("unused")  
51.     private String LOG_SERVICE_LOG_PATH;    //本服务产生的日志，记录日志服务开启失败信息  
52.       
53.     private final int SDCARD_TYPE = 0;          //当前的日志记录类型为存储在SD卡下面  
54.     private final int MEMORY_TYPE = 1;          //当前的日志记录类型为存储在内存中  
55.     private int CURR_LOG_TYPE = SDCARD_TYPE;    //当前的日志记录类型  
56.       
57.     private String CURR_INSTALL_LOG_NAME;   //如果当前的日志写在内存中，记录当前的日志文件名称  
58.       
59.     private String logServiceLogName = "Log.log";//本服务输出的日志文件名称  
60.     private SimpleDateFormat myLogSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
61.     private OutputStreamWriter writer;  
62.       
63.     private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HHmmss");//日志名称格式  
64.       
65.     private Process process;  
66.       
67.     private WakeLock wakeLock;    
68.       
69.     private SDStateMonitorReceiver sdStateReceiver; //SDcard状态监测  
70.     private LogTaskReceiver logTaskReceiver;   
71.       
72.     /* 是否正在监测日志文件大小； 
73.      * 如果当前日志记录在SDcard中则为false 
74.      * 如果当前日志记录在内存中则为true*/  
75.     private boolean logSizeMoniting = false;          
76.       
77.     private static String MONITOR_LOG_SIZE_ACTION = "com.walktour.gui.MONITOR_LOG_SIZE";        //日志文件监测action  
78.     private static String SWITCH_LOG_FILE_ACTION = "com.walktour.gui.SWITCH_LOG_FILE_ACTION";   //切换日志文件action  
79.       
80.     @Override  
81.     public IBinder onBind(Intent intent) {  
82.         return null;  
83.     }  
84.   
85.     @Override  
86.     public void onCreate() {  
87.         super.onCreate();  
88.         init();  
89.         register();  
90.         deploySwitchLogFileTask();    
91.         new LogCollectorThread().start();  
92.     }  
93.       
94.     private void init(){  
95.         LOG_PATH_MEMORY_DIR = getFilesDir().getAbsolutePath() + File.separator + "log";  
96.         LOG_SERVICE_LOG_PATH = LOG_PATH_MEMORY_DIR + File.separator + logServiceLogName;  
97.         LOG_PATH_SDCARD_DIR = Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator  
98.                             +   "walktour" + File.separator + "log";  
99.         createLogDir();  
100.           
101.         /* ****************************************************** 
102.         try { 
103.             writer = new OutputStreamWriter(new FileOutputStream( 
104.                     LOG_SERVICE_LOG_PATH, true)); 
105.         } catch (FileNotFoundException e) { 
106.             Log.e(TAG, e.getMessage(), e); 
107.         } 
108.         * ******************************************************/  
109.         PowerManager pm = (PowerManager) getApplicationContext().getSystemService(Context.POWER_SERVICE);  
110.         wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);  
111.           
112.         CURR_LOG_TYPE = getCurrLogType();  
113.         Log.i(TAG, "LogService onCreate");  
114.     }  
115.       
116.     private void register(){  
117.         IntentFilter sdCarMonitorFilter = new IntentFilter();  
118.         sdCarMonitorFilter.addAction(Intent.ACTION_MEDIA_MOUNTED);  
119.         sdCarMonitorFilter.addAction(Intent.ACTION_MEDIA_UNMOUNTED);  
120.         sdCarMonitorFilter.addDataScheme("file");  
121.         sdStateReceiver = new SDStateMonitorReceiver();  
122.         registerReceiver(sdStateReceiver, sdCarMonitorFilter);  
123.           
124.         IntentFilter logTaskFilter = new IntentFilter();  
125.         logTaskFilter.addAction(MONITOR_LOG_SIZE_ACTION);  
126.         logTaskFilter.addAction(SWITCH_LOG_FILE_ACTION);  
127.         logTaskReceiver = new LogTaskReceiver();  
128.         registerReceiver(logTaskReceiver,logTaskFilter);  
129.     }  
130.       
131.       
132.       
133.     /** 
134.      * 获取当前应存储在内存中还是存储在SDCard中 
135.      * @return 
136.      */  
137.     public int getCurrLogType(){  
138.         if (!Environment.getExternalStorageState().equals(  
139.                 Environment.MEDIA_MOUNTED)) {  
140.             return MEMORY_TYPE;  
141.         }else{  
142.             return SDCARD_TYPE;  
143.         }  
144.     }  
145.   
146.     /** 
147.      * 部署日志切换任务，每天凌晨切换日志文件 
148.      */  
149.     private void deploySwitchLogFileTask() {  
150.         Intent intent = new Intent(SWITCH_LOG_FILE_ACTION);  
151.         PendingIntent sender = PendingIntent.getBroadcast(this, 0, intent, 0);  
152.         Calendar calendar = Calendar.getInstance();  
153.         calendar.add(Calendar.DAY_OF_MONTH, 1);  
154.         calendar.set(Calendar.HOUR_OF_DAY, 0);  
155.         calendar.set(Calendar.MINUTE, 0);  
156.         calendar.set(Calendar.SECOND, 0);  
157.   
158.         // 部署任务  
159.         AlarmManager am = (AlarmManager) getSystemService(ALARM_SERVICE);  
160.         am.setRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), AlarmManager.INTERVAL_DAY, sender);  
161.         recordLogServiceLog("deployNextTask succ,next task time is:"+myLogSdf.format(calendar.getTime()));  
162.     }  
163.   
164.     /** 
165.      * 日志收集 
166.      * 1.清除日志缓存  
167.      * 2.杀死应用程序已开启的Logcat进程防止多个进程写入一个日志文件 
168.      * 3.开启日志收集进程  
169.      * 4.处理日志文件 
170.      *   移动 OR 删除 
171.      */  
172.     class LogCollectorThread extends Thread {  
173.           
174.         public LogCollectorThread(){  
175.             super("LogCollectorThread");  
176.             Log.d(TAG, "LogCollectorThread is create");  
177.         }  
178.           
179.         @Override  
180.         public void run() {  
181.             try {  
182.                 wakeLock.acquire(); //唤醒手机  
183.                   
184.                 clearLogCache();  
185.                   
186.                 List<String> orgProcessList = getAllProcess();  
187.                 List<ProcessInfo> processInfoList = getProcessInfoList(orgProcessList);  
188.                 killLogcatProc(processInfoList);  
189.                   
190.                 createLogCollector();  
191.                   
192.                 Thread.sleep(1000);//休眠，创建文件，然后处理文件，不然该文件还没创建，会影响文件删除  
193.                   
194.                 handleLog();  
195.                   
196.                 wakeLock.release(); //释放  
197.             } catch (Exception e) {  
198.                 e.printStackTrace();  
199.                 recordLogServiceLog(Log.getStackTraceString(e));  
200.             }  
201.         }  
202.     }  
203.       
204.     /** 
205.      * 每次记录日志之前先清除日志的缓存, 不然会在两个日志文件中记录重复的日志 
206.      */  
207.     private void clearLogCache() {  
208.         Process proc = null;  
209.         List<String> commandList = new ArrayList<String>();  
210.         commandList.add("logcat");  
211.         commandList.add("-c");  
212.         try {  
213.             proc = Runtime.getRuntime().exec(  
214.                     commandList.toArray(new String[commandList.size()]));  
215.             StreamConsumer errorGobbler = new StreamConsumer(proc  
216.                     .getErrorStream());  
217.   
218.             StreamConsumer outputGobbler = new StreamConsumer(proc  
219.                     .getInputStream());  
220.   
221.             errorGobbler.start();  
222.             outputGobbler.start();  
223.             if (proc.waitFor() != 0) {  
224.                 Log.e(TAG, " clearLogCache proc.waitFor() != 0");  
225.                 recordLogServiceLog("clearLogCache clearLogCache proc.waitFor() != 0");  
226.             }  
227.         } catch (Exception e) {  
228.             Log.e(TAG, "clearLogCache failed", e);  
229.             recordLogServiceLog("clearLogCache failed");  
230.         } finally {  
231.             try {  
232.                 proc.destroy();  
233.             } catch (Exception e) {  
234.                 Log.e(TAG, "clearLogCache failed", e);  
235.                 recordLogServiceLog("clearLogCache failed");  
236.             }  
237.         }  
238.     }  
239.   
240.     /** 
241.      * 关闭由本程序开启的logcat进程： 
242.      * 根据用户名称杀死进程(如果是本程序进程开启的Logcat收集进程那么两者的USER一致) 
243.      * 如果不关闭会有多个进程读取logcat日志缓存信息写入日志文件 
244.      *  
245.      * @param allProcList 
246.      * @return 
247.      */  
248.     private void killLogcatProc(List<ProcessInfo> allProcList) {  
249.         if(process != null){  
250.             process.destroy();  
251.         }  
252.         String packName = this.getPackageName();  
253.         String myUser = getAppUser(packName, allProcList);  
254.         /* 
255.         recordLogServiceLog("app user is:"+myUser); 
256.         recordLogServiceLog("========================"); 
257.         for (ProcessInfo processInfo : allProcList) { 
258.             recordLogServiceLog(processInfo.toString()); 
259.         } 
260.         recordLogServiceLog("========================"); 
261.         */  
262.         for (ProcessInfo processInfo : allProcList) {  
263.             if (processInfo.name.toLowerCase().equals("logcat")  
264.                     && processInfo.user.equals(myUser)) {  
265.                 android.os.Process.killProcess(Integer  
266.                         .parseInt(processInfo.pid));  
267.                 //recordLogServiceLog("kill another logcat process success,the process info is:"  
268.                 //      + processInfo);  
269.             }  
270.         }  
271.     }  
272.   
273.     /** 
274.      * 获取本程序的用户名称 
275.      *  
276.      * @param packName 
277.      * @param allProcList 
278.      * @return 
279.      */  
280.     private String getAppUser(String packName, List<ProcessInfo> allProcList) {  
281.         for (ProcessInfo processInfo : allProcList) {  
282.             if (processInfo.name.equals(packName)) {  
283.                 return processInfo.user;  
284.             }  
285.         }  
286.         return null;  
287.     }  
288.   
289.     /** 
290.      * 根据ps命令得到的内容获取PID，User，name等信息 
291.      *  
292.      * @param orgProcessList 
293.      * @return 
294.      */  
295.     private List<ProcessInfo> getProcessInfoList(List<String> orgProcessList) {  
296.         List<ProcessInfo> procInfoList = new ArrayList<ProcessInfo>();  
297.         for (int i = 1; i < orgProcessList.size(); i++) {  
298.             String processInfo = orgProcessList.get(i);  
299.             String[] proStr = processInfo.split(" ");  
300.             // USER PID PPID VSIZE RSS WCHAN PC NAME  
301.             // root 1 0 416 300 c00d4b28 0000cd5c S /init  
302.             List<String> orgInfo = new ArrayList<String>();  
303.             for (String str : proStr) {  
304.                 if (!"".equals(str)) {  
305.                     orgInfo.add(str);  
306.                 }  
307.             }  
308.             if (orgInfo.size() == 9) {  
309.                 ProcessInfo pInfo = new ProcessInfo();  
310.                 pInfo.user = orgInfo.get(0);  
311.                 pInfo.pid = orgInfo.get(1);  
312.                 pInfo.ppid = orgInfo.get(2);  
313.                 pInfo.name = orgInfo.get(8);  
314.                 procInfoList.add(pInfo);  
315.             }  
316.         }  
317.         return procInfoList;  
318.     }  
319.   
320.     /** 
321.      * 运行PS命令得到进程信息 
322.      *  
323.      * @return 
324.      *          USER PID PPID VSIZE RSS WCHAN PC NAME 
325.      *          root 1 0 416 300 c00d4b28 0000cd5c S /init 
326.      */  
327.     private List<String> getAllProcess() {  
328.         List<String> orgProcList = new ArrayList<String>();  
329.         Process proc = null;  
330.         try {  
331.             proc = Runtime.getRuntime().exec("ps");  
332.             StreamConsumer errorConsumer = new StreamConsumer(proc  
333.                     .getErrorStream());  
334.   
335.             StreamConsumer outputConsumer = new StreamConsumer(proc  
336.                     .getInputStream(), orgProcList);  
337.   
338.             errorConsumer.start();  
339.             outputConsumer.start();  
340.             if (proc.waitFor() != 0) {  
341.                 Log.e(TAG, "getAllProcess proc.waitFor() != 0");  
342.                 recordLogServiceLog("getAllProcess proc.waitFor() != 0");  
343.             }  
344.         } catch (Exception e) {  
345.             Log.e(TAG, "getAllProcess failed", e);  
346.             recordLogServiceLog("getAllProcess failed");  
347.         } finally {  
348.             try {  
349.                 proc.destroy();  
350.             } catch (Exception e) {  
351.                 Log.e(TAG, "getAllProcess failed", e);  
352.                 recordLogServiceLog("getAllProcess failed");  
353.             }  
354.         }  
355.         return orgProcList;  
356.     }  
357.       
358.     /** 
359.      * 开始收集日志信息 
360.      */  
361.     public void createLogCollector() {  
362.         String logFileName = sdf.format(new Date()) + ".log";// 日志文件名称  
363.         List<String> commandList = new ArrayList<String>();  
364.         commandList.add("logcat");  
365.         commandList.add("-f");  
366.         //commandList.add(LOG_PATH_INSTALL_DIR + File.separator + logFileName);  
367.         commandList.add(getLogPath());  
368.         commandList.add("-v");  
369.         commandList.add("time");  
370.         commandList.add("*:I");  
371.           
372.         //commandList.add("*:E");// 过滤所有的错误信息  
373.   
374.         // 过滤指定TAG的信息  
375.         // commandList.add("MyAPP:V");  
376.         // commandList.add("*:S");  
377.         try {  
378.             process = Runtime.getRuntime().exec(  
379.                     commandList.toArray(new String[commandList.size()]));  
380.             recordLogServiceLog("start collecting the log,and log name is:"+logFileName);  
381.             // process.waitFor();  
382.         } catch (Exception e) {  
383.             Log.e(TAG, "CollectorThread == >" + e.getMessage(), e);  
384.             recordLogServiceLog("CollectorThread == >" + e.getMessage());  
385.         }  
386.     }  
387.       
388.     /** 
389.      * 根据当前的存储位置得到日志的绝对存储路径 
390.      * @return 
391.      */  
392.     public String getLogPath(){  
393.         createLogDir();  
394.         String logFileName = sdf.format(new Date()) + ".log";// 日志文件名称  
395.         if(CURR_LOG_TYPE == MEMORY_TYPE){  
396.             CURR_INSTALL_LOG_NAME = logFileName;  
397.             Log.d(TAG, "Log stored in memory, the path is:"+LOG_PATH_MEMORY_DIR + File.separator + logFileName);  
398.             return LOG_PATH_MEMORY_DIR + File.separator + logFileName;  
399.         }else{  
400.             CURR_INSTALL_LOG_NAME = null;  
401.             Log.d(TAG, "Log stored in SDcard, the path is:"+LOG_PATH_SDCARD_DIR + File.separator + logFileName);  
402.             return LOG_PATH_SDCARD_DIR + File.separator + logFileName;  
403.         }  
404.     }  
405.       
406.     /** 
407.      * 处理日志文件 
408.      * 1.如果日志文件存储位置切换到内存中，删除除了正在写的日志文件 
409.      *   并且部署日志大小监控任务，控制日志大小不超过规定值 
410.      * 2.如果日志文件存储位置切换到SDCard中，删除7天之前的日志，移 
411.      *     动所有存储在内存中的日志到SDCard中，并将之前部署的日志大小 
412.      *   监控取消 
413.      */  
414.     public void handleLog(){  
415.         if(CURR_LOG_TYPE == MEMORY_TYPE){  
416.             deployLogSizeMonitorTask();  
417.             deleteMemoryExpiredLog();  
418.         }else{  
419.             moveLogfile();  
420.             cancelLogSizeMonitorTask();  
421.             deleteSDcardExpiredLog();  
422.         }  
423.     }  
424.       
425.     /** 
426.      * 部署日志大小监控任务 
427.      */  
428.     private void deployLogSizeMonitorTask() {  
429.         if(logSizeMoniting){    //如果当前正在监控着，则不需要继续部署  
430.             return;  
431.         }  
432.         logSizeMoniting = true;  
433.         Intent intent = new Intent(MONITOR_LOG_SIZE_ACTION);  
434.         PendingIntent sender = PendingIntent.getBroadcast(this, 0, intent, 0);  
435.         AlarmManager am = (AlarmManager) getSystemService(ALARM_SERVICE);  
436.         am.setRepeating(AlarmManager.RTC_WAKEUP,System.currentTimeMillis(), MEMORY_LOG_FILE_MONITOR_INTERVAL, sender);  
437.         Log.d(TAG, "deployLogSizeMonitorTask() succ !");  
438.         //recordLogServiceLog("deployLogSizeMonitorTask() succ ,start time is " + calendar.getTime().toLocaleString());  
439.     }  
440.       
441.     /** 
442.      * 取消部署日志大小监控任务 
443.      */    
444.     private void cancelLogSizeMonitorTask() {  
445.         logSizeMoniting = false;  
446.         AlarmManager am = (AlarmManager) getSystemService(ALARM_SERVICE);  
447.         Intent intent = new Intent(MONITOR_LOG_SIZE_ACTION);  
448.         PendingIntent sender = PendingIntent.getBroadcast(this, 0, intent, 0);  
449.         am.cancel(sender);  
450.           
451.         Log.d(TAG, "canelLogSizeMonitorTask() succ");  
452.     }  
453.       
454.     /** 
455.      * 检查日志文件大小是否超过了规定大小 
456.      * 如果超过了重新开启一个日志收集进程 
457.      */  
458.     private void checkLogSize(){  
459.         if(CURR_INSTALL_LOG_NAME != null && !"".equals(CURR_INSTALL_LOG_NAME)){  
460.             String path = LOG_PATH_MEMORY_DIR + File.separator + CURR_INSTALL_LOG_NAME;  
461.             File file = new File(path);  
462.             if(!file.exists()){  
463.                 return;  
464.             }  
465.             Log.d(TAG, "checkLog() ==> The size of the log is too big?");  
466.             if(file.length() >= MEMORY_LOG_FILE_MAX_SIZE){  
467.                 Log.d(TAG, "The log's size is too big!");  
468.                 new LogCollectorThread().start();  
469.             }  
470.         }  
471.     }  
472.       
473.     /** 
474.      * 创建日志目录 
475.      */  
476.     private void createLogDir() {  
477.         File file = new File(LOG_PATH_MEMORY_DIR);  
478.         boolean mkOk;  
479.         if (!file.isDirectory()) {  
480.             mkOk = file.mkdirs();  
481.             if (!mkOk) {  
482.                 mkOk = file.mkdirs();  
483.             }  
484.         }  
485.   
486.         /* ************************************ 
487.         file = new File(LOG_SERVICE_LOG_PATH); 
488.         if (!file.exists()) { 
489.             try { 
490.                 mkOk = file.createNewFile(); 
491.                 if (!mkOk) { 
492.                     file.createNewFile(); 
493.                 } 
494.             } catch (IOException e) { 
495.                 Log.e(TAG, e.getMessage(), e); 
496.             } 
497.         } 
498.         * ************************************/  
499.           
500.         if (Environment.getExternalStorageState().equals(  
501.                 Environment.MEDIA_MOUNTED)) {  
502.             file = new File(LOG_PATH_SDCARD_DIR);  
503.             if (!file.isDirectory()) {  
504.                 mkOk = file.mkdirs();  
505.                 if (!mkOk) {  
506.                     recordLogServiceLog("move file failed,dir is not created succ");  
507.                     return;  
508.                 }  
509.             }  
510.         }  
511.     }  
512.       
513.     /** 
514.      * 将日志文件转移到SD卡下面 
515.      */  
516.     private void moveLogfile() {  
517.         if (!Environment.getExternalStorageState().equals(  
518.                 Environment.MEDIA_MOUNTED)) {  
519.             //recordLogServiceLog("move file failed, sd card does not mount");  
520.             return;  
521.         }  
522.         File file = new File(LOG_PATH_SDCARD_DIR);  
523.         if (!file.isDirectory()) {  
524.             boolean mkOk = file.mkdirs();  
525.             if (!mkOk) {  
526.                 //recordLogServiceLog("move file failed,dir is not created succ");  
527.                 return;  
528.             }  
529.         }  
530.   
531.         file = new File(LOG_PATH_MEMORY_DIR);  
532.         if (file.isDirectory()) {  
533.             File[] allFiles = file.listFiles();  
534.             for (File logFile : allFiles) {  
535.                 String fileName = logFile.getName();  
536.                 if (logServiceLogName.equals(fileName)) {  
537.                     continue;  
538.                 }  
539.                 //String createDateInfo = getFileNameWithoutExtension(fileName);  
540.                 boolean isSucc = copy(logFile, new File(LOG_PATH_SDCARD_DIR  
541.                             + File.separator + fileName));  
542.                 if (isSucc) {  
543.                     logFile.delete();  
544.                     //recordLogServiceLog("move file success,log name is:"+fileName);  
545.                 }  
546.             }  
547.         }  
548.     }  
549.   
550.     /** 
551.      * 删除内存下过期的日志 
552.      */  
553.     private void deleteSDcardExpiredLog() {  
554.         File file = new File(LOG_PATH_SDCARD_DIR);  
555.         if (file.isDirectory()) {  
556.             File[] allFiles = file.listFiles();  
557.             for (File logFile : allFiles) {  
558.                 String fileName = logFile.getName();  
559.                 if (logServiceLogName.equals(fileName)) {  
560.                     continue;  
561.                 }  
562.                 String createDateInfo = getFileNameWithoutExtension(fileName);  
563.                 if (canDeleteSDLog(createDateInfo)) {  
564.                     logFile.delete();  
565.                     Log.d(TAG, "delete expired log success,the log path is:"  
566.                             + logFile.getAbsolutePath());  
567.   
568.                 }  
569.             }  
570.         }  
571.     }  
572.       
573.     /** 
574.      * 判断sdcard上的日志文件是否可以删除 
575.      * @param createDateStr 
576.      * @return 
577.      */  
578.     public boolean canDeleteSDLog(String createDateStr) {  
579.         boolean canDel = false;  
580.         Calendar calendar = Calendar.getInstance();  
581.         calendar.add(Calendar.DAY_OF_MONTH, -1 * SDCARD_LOG_FILE_SAVE_DAYS);//删除7天之前日志  
582.         Date expiredDate = calendar.getTime();  
583.         try {  
584.             Date createDate = sdf.parse(createDateStr);  
585.             canDel = createDate.before(expiredDate);  
586.         } catch (ParseException e) {  
587.             Log.e(TAG, e.getMessage(), e);  
588.             canDel = false;  
589.         }  
590.         return canDel;  
591.     }  
592.   
593.       
594.     /** 
595.      * 删除内存中的过期日志，删除规则： 
596.      * 除了当前的日志和离当前时间最近的日志保存其他的都删除 
597.      */  
598.     private void deleteMemoryExpiredLog(){  
599.         File file = new File(LOG_PATH_MEMORY_DIR);  
600.         if (file.isDirectory()) {  
601.             File[] allFiles = file.listFiles();  
602.             Arrays.sort(allFiles, new FileComparator());  
603.             for (int i=0;i<allFiles.length-2;i++) {  //"-2"保存最近的两个日志文件  
604.                 File _file =  allFiles[i];  
605.                 if (logServiceLogName.equals(_file.getName()) ||  _file.getName().equals(CURR_INSTALL_LOG_NAME)) {  
606.                     continue;  
607.                 }  
608.                 _file.delete();  
609.                 Log.d(TAG, "delete expired log success,the log path is:"+_file.getAbsolutePath());  
610.             }  
611.         }  
612.     }  
613.       
614.     /** 
615.      * 拷贝文件 
616.      * @param source 
617.      * @param target 
618.      * @return 
619.      */  
620.     private boolean copy(File source, File target) {  
621.         FileInputStream in = null;  
622.         FileOutputStream out = null;  
623.         try {  
624.             if(!target.exists()){  
625.                 boolean createSucc = target.createNewFile();  
626.                 if(!createSucc){  
627.                     return false;  
628.                 }  
629.             }  
630.             in = new FileInputStream(source);  
631.             out = new FileOutputStream(target);  
632.             byte[] buffer = new byte[8*1024];  
633.             int count;  
634.             while ((count = in.read(buffer)) != -1) {  
635.                 out.write(buffer, 0, count);  
636.             }  
637.             return true;  
638.         } catch (Exception e) {  
639.             e.printStackTrace();  
640.             Log.e(TAG, e.getMessage(), e);  
641.             recordLogServiceLog("copy file fail");  
642.             return false;  
643.         } finally{  
644.             try {  
645.                 if(in != null){  
646.                     in.close();  
647.                 }  
648.                 if(out != null){  
649.                     out.close();  
650.                 }  
651.             } catch (IOException e) {  
652.                 e.printStackTrace();  
653.                 Log.e(TAG, e.getMessage(), e);  
654.                 recordLogServiceLog("copy file fail");  
655.                 return false;  
656.             }  
657.         }  
658.           
659.     }  
660.   
661.     /** 
662.      * 记录日志服务的基本信息 防止日志服务有错，在LogCat日志中无法查找  
663.      * 此日志名称为Log.log 
664.      *  
665.      * @param msg 
666.      */  
667.     private void recordLogServiceLog(String msg) {  
668.         if (writer != null) {  
669.             try {  
670.                 Date time = new Date();  
671.                 writer.write(myLogSdf.format(time) + " : " + msg);  
672.                 writer.write("\n");  
673.                 writer.flush();  
674.             } catch (IOException e) {  
675.                 e.printStackTrace();  
676.                 Log.e(TAG, e.getMessage(), e);  
677.             }  
678.         }  
679.     }  
680.       
681.     /** 
682.      * 去除文件的扩展类型（.log） 
683.      * @param fileName 
684.      * @return 
685.      */  
686.     private String getFileNameWithoutExtension(String fileName){  
687.         return fileName.substring(0, fileName.indexOf("."));  
688.     }  
689.   
690.     class ProcessInfo {  
691.         public String user;  
692.         public String pid;  
693.         public String ppid;  
694.         public String name;  
695.   
696.         @Override  
697.         public String toString() {  
698.             String str = "user=" + user + " pid=" + pid + " ppid=" + ppid  
699.                     + " name=" + name;  
700.             return str;  
701.         }  
702.     }  
703.     class StreamConsumer extends Thread {  
704.         InputStream is;  
705.         List<String> list;  
706.   
707.         StreamConsumer(InputStream is) {  
708.             this.is = is;  
709.         }  
710.   
711.         StreamConsumer(InputStream is, List<String> list) {  
712.             this.is = is;  
713.             this.list = list;  
714.         }  
715.   
716.         public void run() {  
717.             try {  
718.                 InputStreamReader isr = new InputStreamReader(is);  
719.                 BufferedReader br = new BufferedReader(isr);  
720.                 String line = null;  
721.                 while ((line = br.readLine()) != null) {  
722.                     if (list != null) {  
723.                         list.add(line);  
724.                     }  
725.                 }  
726.             } catch (IOException ioe) {  
727.                 ioe.printStackTrace();  
728.             }  
729.         }  
730.     }  
731.       
732.     /** 
733.      * 监控SD卡状态 
734.      * @author Administrator 
735.      * 
736.      */  
737.     class SDStateMonitorReceiver extends BroadcastReceiver{  
738.         public void onReceive(Context context, Intent intent) {  
739.               
740.             if(Intent.ACTION_MEDIA_UNMOUNTED.equals(intent.getAction())){   //存储卡被卸载  
741.                 if(CURR_LOG_TYPE == SDCARD_TYPE){  
742.                     Log.d(TAG, "SDcar is UNMOUNTED");  
743.                     CURR_LOG_TYPE = MEMORY_TYPE;  
744.                     new LogCollectorThread().start();  
745.                 }  
746.             }else{                                                          //存储卡被挂载  
747.                 if(CURR_LOG_TYPE == MEMORY_TYPE){  
748.                     Log.d(TAG, "SDcar is MOUNTED");  
749.                     CURR_LOG_TYPE = SDCARD_TYPE;  
750.                     new LogCollectorThread().start();  
751.                       
752.                 }  
753.             }  
754.         }  
755.     }  
756.       
757.     /** 
758.      * 日志任务接收 
759.      * 切换日志，监控日志大小 
760.      * @author Administrator 
761.      * 
762.      */  
763.     class LogTaskReceiver extends BroadcastReceiver{  
764.         public void onReceive(Context context, Intent intent) {  
765.             String action = intent.getAction();  
766.             if(SWITCH_LOG_FILE_ACTION.equals(action)){  
767.                 new LogCollectorThread().start();  
768.             }else if(MONITOR_LOG_SIZE_ACTION.equals(action)){  
769.                 checkLogSize();  
770.             }  
771.         }  
772.     }  
773.       
774.     class FileComparator implements Comparator<File>{  
775.         public int compare(File file1, File file2) {  
776.             if(logServiceLogName.equals(file1.getName())){  
777.                 return -1;  
778.             }else if(logServiceLogName.equals(file2.getName())){  
779.                 return 1;  
780.             }  
781.               
782.             String createInfo1 = getFileNameWithoutExtension(file1.getName());  
783.             String createInfo2 = getFileNameWithoutExtension(file2.getName());  
784.               
785.             try {  
786.                 Date create1 = sdf.parse(createInfo1);  
787.                 Date create2 = sdf.parse(createInfo2);  
788.                 if(create1.before(create2)){  
789.                     return -1;  
790.                 }else{  
791.                     return 1;  
792.                 }  
793.             } catch (ParseException e) {  
794.                 return 0;  
795.             }  
796.         }  
797.     }  
798.       
799.     @Override  
800.     public void onDestroy() {  
801.         super.onDestroy();  
802.         recordLogServiceLog("LogService onDestroy");  
803.         if (writer != null) {  
804.             try {  
805.                 writer.close();  
806.             } catch (IOException e) {  
807.                 e.printStackTrace();  
808.             }  
809.         }  
810.         if (process != null) {  
811.             process.destroy();  
812.         }  
813.           
814.         unregisterReceiver(sdStateReceiver);  
815.         unregisterReceiver(logTaskReceiver);  
816.     }  
817.   
818. }  

 最后不要忘记在配置文件中加入

Xml代码  

1. <uses-permission android:name="android.permission.READ_LOGS" />  

 

extramoney 写道

菜鸟问题：怎么使用LogService?

Intent stateService =  new Intent (this,com.app.service.app.LogService.class);
startService( stateService );

原文地址： http://www.jtben.com/document/948608