Android的log保存到文件上查看

转载自：http://www.eoeandroid.com/thread-153626-1-1.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[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(logTaskReceiver);
	}

}

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