Android的log保存到文件上查看

本文摘自

点击打开链接

package com.cccc.service;

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;

/**
* 日志服务，日志默认会存储在SDcard里如果没有SDcard会存储在内存中的安装目录下面。
* 1.本服务默认在SDcard中每天生成一个日志文件,
* 2.如果有SDCard的话会将之前内存中的文件拷贝到SDCard中
* 3.如果没有SDCard，在安装目录下只保存当前在写日志
* 4.SDcard的装载卸载动作会在步骤2,3中切换
* 5.SDcard中的日志文件只保存7天
* @author Administrator
*
*
* 最后不要忘记在配置文件中加入
* Xml代码
* <uses-permission android:name="android.permission.READ_LOGS" />
*
*/
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(
4000
) != 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[i];
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(
b2cf
logTaskReceiver);
}

}


最后在配置文件AndroidManifest.xml中加入权限
Xml代码  
<uses-permission android:name="android.permission.READ_LOGS" />