& & &1&&& log文件分类简介
　　实时打印的主要有：logcat main，logcat radio，logcat events，tcpdump，还有高通平台的还会有QXDM日志
　　状态信息的有：adb&&cat /proc/kmsg ，adb shell dmesg，adb shell dumpstate，adb shell dumpsys，adb bugreport，工程 & & & 模式等
　　2&&& LOG抓取详解
　　l& 实时打印
adb logcat -b main -v time&app.log
打印应用程序的log
adb logcat -b radio -v time& radio.log 打印射频相关的log，SIM STK也会在里面，modem相关的ATcommand等，当然跟QXDM差的很远了。
adb logcat -b events -v time
打印系统事件的日志，比如触屏事件。。。
//android log的抓取
adb logcat
//kernel log的抓取
adb shell cat /proc/kmsg
//log 信息的保存
logcat *：V & /data/anr/android
demsg &/data/anr/kernel
//按ctrl+c结束log输出
adb pull /data/anr ./log/
　　tcpdump 是很有用的，对于TCP/IP协议相关的都可以使用这个来抓，adb shell tcpdump -s 10000 -w /sdcard/capture.pcap，比如抓mms下载的时候的UA profile，browser上网的时候，使用proxy的APN下载，streaming的相关内容包括UA profile等。
　　最后是高通平台的QXDM，不管是不是，只要使用高通芯片，都会对它很熟悉，当然了，不是高通的芯片就不用提它了。这个不多讲，内容丰富，射频，电话，上网，...凡是高通提供的解决方案，这个都可以抓。(QXDM 的LOG抓取方法请参考QPST、QXDM的基本使用说明及作用)
　　l& 状态信息
　　o&& bugreport（命令adb bugreport&bugreport.log)。里面包含有dmesg，dumpstate和dumpsys。
　　o&& dumpstate是系统状态信息，里面比较全，包括当前的内存信息、cpu信息、logcat缓存，kernel缓存等等。
　　o&&& adb shell dumpsys这个是关于系统service的内容都在这个里面，这个命令还有更详尽的用法，比如adb shell dumpsys meminfo system是查看system这个process的内存信息。
　　o&& kmsg抓取
　　adb shell cat /proc/kmsg & kmsg.txt，打开后查msm_kgsl字段
　　说明：用于检索用printk生成的内核消息。任何时刻只能有一个具有超级用户权限的进程可以读取这个文件。也可以用系统调用syslog检索这些消息。通常使用工具dmesg或守护进程klogd检索这些消息。proc是一个内存文件系统， 每次读文件kmsg实际是内核内部的循环缓冲区，每读过后，循环缓冲区的东西就被认为已经处理过了(也就是变成无效内容)，所以你再次读为空是很正常的 为什么会这样处理呢，循环缓冲区大小有限，内核又随时可能往里面写东西，所以这样处理很正常. 你去查一下/proc/kmsg的信息有没有跟系统日志关联，如果有的话，你就可以读日志文件
　　o&& dmsg抓取
　　adb shell dmesg & dmesg.txt
　　说明：dmesg用来显示开机信息，kernel会将开机信息存储在ring buffer中。您若是开机时来不及查看信息，可利用dmesg来查看。dmesg是kernel的log，凡是跟kernel相关的，比如driver出了问题（相机，蓝牙，usb，启动，等等）开机信息亦保存在/var/log目录中，名称为dmesg的文件里。more /var/log/dmesg
　　o&& 工程模式下log的抓取
　　对于Apollo手机请拨打*#*#8888#*#* ，然后勾选相应的LOG。待结束后，通过SD卡导出LOG到PC.
3.Log分析：
Get Log from Android System
adb bugreport & bugreport.txt
copy bugreport to the current directory.
bugreport里面包含了各种log信息，大部分log也可以通过直接运行相关的程序来直接获得.
　　步骤如下：
　　1.adb shell 2.进入相关工具程式的目录 3.执行相关程式 4.得到相关信息
　　下面以输出进程信息为例 1.adb shell 2.输入ps -P 3.可以看到相关进程信息
　　Log Archive Analysis
　　1.bugreport
　　bugreport记录android启动过程的log，以及启动后的系统状态，包括进程列表，内存信息，VM信息等等到.
　　单独察看某个数据可使用cat指令察看，例如cat /proc/meminfo
　　2.bugreport结构分析
　　(1)dumpstate
　　MEMORY INFO
　　获取该log：读取文件/proc/meminfo
　　系统内存使用状态
　　CPU INFO
　　获取该log：执行/system/bin/top -n 1 -d 1 -m 30 -t
　　系统CPU使用状态
　　PROCRANK
　　获取该log：执行/system/bin/procrank
　　执行/system/xbin/procrank后输出的结果，查看一些内存使用状态
　　VIRTUAL MEMORY STATS
　　获取该log：读取文件/proc/vmstat
　　虚拟内存分配情况
　　vmalloc申请的内存则位于vmalloc_start～vmalloc_end之间，与物理地址没有简单的转换关系，虽然在逻辑上它们也是连续的，但是在物理上它们不要求连续。
　　VMALLOC INFO
　　获取该log：读取文件/proc/vmallocinfo
　　虚拟内存分配情况
　　SLAB INFO
　　获取该log：读取文件/proc/slabinfo
　　SLAB是一种内存分配器.这里输出该分配器的一些信息
　　ZONEINFO
　　获取该log：读取文件/proc/zoneinfo
　　zone info
　　SYSTEM LOG(需要着重分析)
　　获取该log：执行/system/bin/logcat -v time -d *：v
　　会输出在程序中输出的Log，用于分析系统的当前状态
　　VM TRACES
　　获取该log：读取文件/data/anr/traces.txt
　　因为每个程序都是在各自的VM中运行的，这个Log是现实各自VM的一些traces
　　EVENT LOG TAGS
　　获取该log：读取文件/etc/event-log-tags
　　EVENT LOG
　　获取该log：执行/system/bin/logcat -b events -v time -d *：v
　　输出一些Event的log
　　RADIO LOG
　　获取该log：执行/system/bin/logcat -b radio -v time -d *：v
　　显示一些无线设备的链接状态，如GSM，PHONE，STK(Satellite Tool Kit)&
　　NETWORK STATE
　　获取该log：执行/system/bin/netcfg (得到网络链接状态)
　　获取该log：读取文件/proc/net/route (得到路由状态)
　　显示网络链接和路由
　　SYSTEM PROPERTIES
　　获取该log：参考代码实现
　　显示一些系统属性，如Version，Services，network&
　　KERNEL LOG
　　获取该log：执行/system/bin/dmesg
　　显示Android内核输出的Log
　　KERNEL WAKELOCKS
　　获取该log：读取文件/proc/wakelocks
　　内核对一些程式和服务唤醒和休眠的一些记录
KERNEL CPUFREQ
(Linux kernel CPUfreq subsystem) Clock scaling allows you to change the clock speed of the CPUs on the fly.
This is a nice method to save battery power， because the lower the clock speed is， the less power the CPU consumes.
　　获取该log：执行ps -P&
　　显示当前进程
　　PROCESSES AND THREADS
　　获取该log：执行ps -t -p -P
　　显示当前进程和线程
　　LIBRANK
　　获取该log：执行/system/xbin/librank
　　剔除不必要的library
　　BINDER FAILED TRANSACTION LOG
　　获取该log：读取文件/proc/binder/failed_transaction_log
　　BINDER TRANSACTION LOG
　　获取该log：读取文件/proc/binder/transaction_log
　　BINDER TRANSACTIONS
　　获取该log：读取文件/proc/binder/transactions
　　BINDER STATS
　　获取该log：读取文件/proc/binder/stats
　　BINDER PROCESS STATE
　　获取该log：读取文件/proc/binder/proc/*
　　bind相关的一些状态
　　FILESYSTEMS
　　获取该log：执行/system/bin/df
　　主要文件的一些容量使用状态(cache，sqlite，dev&)
　　PACKAGE SETTINGS
　　获取该log：读取文件/data/system/packages.xml
　　系统中package的一些状态(访问权限，路径&)，类似里面的一些lnk文件吧.
　　PACKAGE UID ERRORS
　　获取该log：读取文件/data/system/uiderrors.txt
阅读(...) 评论()
访客：Copyright (C)系统日志和IIS日志存放路径
系统日志和IIS日志存放路径
【关注偶叫周庆东，让程序员之路越走越踏实。】
一、应用程序日志、安全日志、系统日志、DNS日志默认位置：%systemroot%\system32\config，默认文件大小512KB，管理员都会改变这个默认大小。
1、安全日志文件：%systemroot%\system32\config\SecEvent.EVT
2、系统日志文件：%systemroot%\system32\config\SysEvent.EVT
3、应用程序日志文件：%systemroot%\system32\config\AppEvent.EVT
二、Internet信息服务日志
1、FTP日志默认位置：%systemroot%\system32\logfiles\msftpsvc1\，默认每天一个日志
2、WWW日志默认位置：%systemroot%\system32\logfiles\w3svc1\，默认每天一个日志
三、Scheduler服务日志默认位置：%systemroot%\schedlgu.txt
以上日志在注册表里的键：
应用程序日志，安全日志，系统日志，DNS服务器日志，它们这些LOG文件在注册表中的：
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\Eventlog
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。log文件查看
[问题点数：20分，结帖人wfkmu]
log文件查看
[问题点数：20分，结帖人wfkmu]
不显示删除回复
显示所有回复
显示星级回复
显示得分回复
只显示楼主
2016年8月论坛优秀版主2015年4月优秀版主2014年11月论坛优秀版主
2016年4月 荣获微软MVP称号2015年4月 荣获微软MVP称号2014年4月 荣获微软MVP称号2013年4月 荣获微软MVP称号2009年1月 荣获微软MVP称号2012年4月 荣获微软MVP称号2011年4月 荣获微软MVP称号2010年4月 荣获微软MVP称号
2011年 总版技术专家分年内排行榜第四2010年 总版技术专家分年内排行榜第九2009年 总版技术专家分年内排行榜第八
2011年10月 总版技术专家分月排行榜第一
2016年8月论坛优秀版主2015年4月优秀版主2014年11月论坛优秀版主
2016年4月 荣获微软MVP称号2015年4月 荣获微软MVP称号2014年4月 荣获微软MVP称号2013年4月 荣获微软MVP称号2009年1月 荣获微软MVP称号2012年4月 荣获微软MVP称号2011年4月 荣获微软MVP称号2010年4月 荣获微软MVP称号
2016年8月论坛优秀版主2015年4月优秀版主2014年11月论坛优秀版主
2016年4月 荣获微软MVP称号2015年4月 荣获微软MVP称号2014年4月 荣获微软MVP称号2013年4月 荣获微软MVP称号2009年1月 荣获微软MVP称号2012年4月 荣获微软MVP称号2011年4月 荣获微软MVP称号2010年4月 荣获微软MVP称号
2011年12月 总版技术专家分月排行榜第三2011年9月 总版技术专家分月排行榜第三
2011年6月 MS-SQL Server大版内专家分月排行榜第一
2016年4月荣获微软MVP荣誉称号2015年4月荣获微软MVP称号2014年4月 荣获微软MVP称号
2016年7月 MS-SQL Server大版内专家分月排行榜第一
本帖子已过去太久远了，不再提供回复功能。<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
您的访问请求被拒绝 403 Forbidden - ITeye技术社区
您的访问请求被拒绝
亲爱的会员，您的IP地址所在网段被ITeye拒绝服务，这可能是以下两种情况导致：
一、您所在的网段内有网络爬虫大量抓取ITeye网页，为保证其他人流畅的访问ITeye，该网段被ITeye拒绝
二、您通过某个代理服务器访问ITeye网站，该代理服务器被网络爬虫利用，大量抓取ITeye网页
请您点击按钮解除封锁&android（2）
& & & & 在调试的时候一般都是在logcat中看日志的信息，以便找出BUG和调试信息，但是如果在真机上的话不可能一直连接电脑查看日志，所以生成日志文件并保存，是一个比较普遍的需求，下面就是最近实现的一个例子。欢迎大家讨论并给出别的思路。
import java.io.BufferedR
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.IOE
import java.io.InputS
import java.io.InputStreamR
import java.io.OutputStreamW
import java.text.ParseE
import java.text.SimpleDateF
import java.util.ArrayL
import java.util.A
import java.util.C
import java.util.D
import java.util.L
import android.app.AlarmM
import android.app.PendingI
import android.app.S
import android.content.BroadcastR
import android.content.C
import android.content.I
import android.content.IntentF
import android.os.E
import android.os.IB
import android.os.PowerM
import android.os.PowerManager.WakeL
import android.util.L
* 日志服务，日志默认会存储在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 OutputStreamW
private SimpleDateFormat sdf = new SimpleDateFormat(&yyyy-MM-dd HHmmss&);// 日志名称格式
private WakeLock wakeL
private SDStateMonitorReceiver sdStateR // SDcard状态监测
private LogTaskReceiver logTaskR
* 是否正在监测日志文件大小； 如果当前日志记录在SDcard中则为false 如果当前日志记录在内存中则为true
private boolean logSizeMoniting =
private static String MONITOR_LOG_SIZE_ACTION = &com.walktour.gui.MONITOR_LOG_SIZE&; // 日志文件监测action
private static String SWITCH_LOG_FILE_ACTION = &com.walktour.gui.SWITCH_LOG_FILE_ACTION&; // 切换日志文件action
public IBinder onBind(Intent intent) {
public void onCreate() {
super.onCreate();
register();
deploySwitchLogFileTask();
new LogCollectorThread().start();
private void init() {
LOG_PATH_MEMORY_DIR = getFilesDir().getAbsolutePath() + File.separator
LOG_SERVICE_LOG_PATH = LOG_PATH_MEMORY_DIR + File.separator
+ logServiceLogN
LOG_PATH_SDCARD_DIR = Environment.getExternalStorageDirectory()
.getAbsolutePath()
+ File.separator
+ &walktour&
+ 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中
public int getCurrLogType() {
if (!Environment.getExternalStorageState().equals(
Environment.MEDIA_MOUNTED)) {
return MEMORY_TYPE;
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.处理日志文件 移动
class LogCollectorThread extends Thread {
public LogCollectorThread() {
super(&LogCollectorThread&);
Log.d(TAG, &LogCollectorThread is create&);
public void run() {
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 =
List&String& commandList = new ArrayList&String&();
commandList.add(&logcat&);
commandList.add(&-c&);
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 {
proc.destroy();
} catch (Exception e) {
Log.e(TAG, &clearLogCache failed&, e);
recordLogServiceLog(&clearLogCache failed&);
* 关闭由本程序开启的logcat进程： 根据用户名称杀死进程(如果是本程序进程开启的Logcat收集进程那么两者的USER一致)
* 如果不关闭会有多个进程读取logcat日志缓存信息写入日志文件
* @param allProcList
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
private String getAppUser(String packName, List&ProcessInfo& allProcList) {
for (ProcessInfo processInfo : allProcList) {
if (processInfo.name.equals(packName)) {
return processInfo.
* 根据ps命令得到的内容获取PID，User，name等信息
* @param orgProcessList
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 procInfoL
* 运行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 =
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 {
proc.destroy();
} catch (Exception e) {
Log.e(TAG, &getAllProcess failed&, e);
recordLogServiceLog(&getAllProcess failed&);
return orgProcL
* 开始收集日志信息
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&);
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());
* 根据当前的存储位置得到日志的绝对存储路径
public String getLogPath() {
createLogDir();
String logFileName = sdf.format(new Date()) + &.log&;// 日志文件名称
if (CURR_LOG_TYPE == MEMORY_TYPE) {
CURR_INSTALL_LOG_NAME = logFileN
Log.d(TAG, &Log stored in memory, the path is:&
+ LOG_PATH_MEMORY_DIR + File.separator + logFileName);
return LOG_PATH_MEMORY_DIR + File.separator + logFileN
CURR_INSTALL_LOG_NAME =
Log.d(TAG, &Log stored in SDcard, the path is:&
+ LOG_PATH_SDCARD_DIR + File.separator + logFileName);
return LOG_PATH_SDCARD_DIR + File.separator + logFileN
* 处理日志文件 1.如果日志文件存储位置切换到内存中，删除除了正在写的日志文件 并且部署日志大小监控任务，控制日志大小不超过规定值
* 2.如果日志文件存储位置切换到SDCard中，删除7天之前的日志，移 动所有存储在内存中的日志到SDCard中，并将之前部署的日志大小 监控取消
public void handleLog() {
if (CURR_LOG_TYPE == MEMORY_TYPE) {
deployLogSizeMonitorTask();
deleteMemoryExpiredLog();
moveLogfile();
cancelLogSizeMonitorTask();
deleteSDcardExpiredLog();
* 部署日志大小监控任务
private void deployLogSizeMonitorTask() {
if (logSizeMoniting) { // 如果当前正在监控着，则不需要继续部署
logSizeMoniting =
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 =
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()) {
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&);
* 将日志文件转移到SD卡下面
private void moveLogfile() {
if (!Environment.getExternalStorageState().equals(
Environment.MEDIA_MOUNTED)) {
// recordLogServiceLog(&move file failed, sd card does not mount&);
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&);
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)) {
// 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)) {
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
public boolean canDeleteSDLog(String createDateStr) {
boolean canDel =
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DAY_OF_MONTH, -1 * SDCARD_LOG_FILE_SAVE_DAYS);// 删除7天之前日志
Date expiredDate = calendar.getTime();
Date createDate = sdf.parse(createDateStr);
canDel = createDate.before(expiredDate);
} catch (ParseException e) {
Log.e(TAG, e.getMessage(), e);
return canD
* 删除内存中的过期日志，删除规则： 除了当前的日志和离当前时间最近的日志保存其他的都删除
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)) {
_file.delete();
Log.d(TAG, &delete expired log success,the log path is:&
+ _file.getAbsolutePath());
* 拷贝文件
* @param source
* @param target
private boolean copy(File source, File target) {
FileInputStream in =
FileOutputStream out =
if (!target.exists()) {
boolean createSucc = target.createNewFile();
if (!createSucc) {
in = new FileInputStream(source);
out = new FileOutputStream(target);
byte[] buffer = new byte[8 * 1024];
while ((count = in.read(buffer)) != -1) {
out.write(buffer, 0, count);
} catch (Exception e) {
e.printStackTrace();
Log.e(TAG, e.getMessage(), e);
recordLogServiceLog(&copy file fail&);
} finally {
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&);
* 记录日志服务的基本信息 防止日志服务有错，在LogCat日志中无法查找 此日志名称为Log.log
* @param msg
private void recordLogServiceLog(String msg) {
if (writer != null) {
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
private String getFileNameWithoutExtension(String fileName) {
return fileName.substring(0, fileName.indexOf(&.&));
class ProcessInfo {
public String toString() {
String str = &user=& + user + & pid=& + pid + & ppid=& + ppid
+ & name=& +
class StreamConsumer extends Thread {
List&String&
StreamConsumer(InputStream is) {
StreamConsumer(InputStream is, List&String& list) {
this.list =
public void run() {
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line =
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())) {
String createInfo1 = getFileNameWithoutExtension(file1.getName());
String createInfo2 = getFileNameWithoutExtension(file2.getName());
Date create1 = sdf.parse(createInfo1);
Date create2 = sdf.parse(createInfo2);
if (create1.before(create2)) {
return -1;
} catch (ParseException e) {
public void onDestroy() {
super.onDestroy();
recordLogServiceLog(&LogService onDestroy&);
if (writer != null) {
writer.close();
} catch (IOException e) {
e.printStackTrace();
if (process != null) {
process.destroy();
unregisterReceiver(sdStateReceiver);
unregisterReceiver(logTaskReceiver);
在AndroidManifest.xml提供权限：
&uses-permission android:name=&android.permission.READ_LOGS& /&
&uses-permission android:name=&android.permission.WAKE_LOCK& /&
&uses-permission android:name=&android.permission.WRITE_EXTERNAL_STORAGE& /&
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：21101次
排名：千里之外
原创：14篇
转载：14篇
(1)(2)(1)(4)(1)(1)(1)(1)(2)(2)(4)(4)(1)(3)