转: http://easion-zms.iteye.com/blog/981568

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
+ "Wonders"
+ File.separator
+ "log";
LOG_SERVICE_LOG_PATH = LOG_PATH_MEMORY_DIR + File.separator
+ logServiceLogName;
LOG_PATH_SDCARD_DIR = Environment.getExternalStorageDirectory()
.getAbsolutePath()
+ File.separator
+ "Wonders"
+ 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);
} }
Intent stateService =  new Intent (context,LogService.class);

context.stopService(stateService);

 
<service
            android:name="com.wondersgroup.qdyth.zsjc.services.LogService" >
</service>
 

Android日志服务 记录日志的更多相关文章

  1. 基于日志服务的GrowthHacking(1):数据埋点和采集(APP、Web、邮件、短信、二维码埋点技术)

    数据质量决定运营分析的质量 在上文中,我们介绍了GrowthHacking的整体架构,其中数据采集是整个数据分析的基础,只有有了数据,才能进行有价值的分析:只有高质量的数据,才能驱动高质量的运营分析. ...

  2. AngularJS中实现日志服务

    本篇体验使用AngularJS自定义一个记录日志的服务. 在AngularJS中,服务的一些写法是这样的: var app = angular.module('app',[]); app.provid ...

  3. AMQ学习笔记 - 15. 实践方案:基于ActiveMQ的统一日志服务

    概述 以ActiveMQ + Log4j + Spring的技术组合,实现基于消息队列的统一日志服务. 参考:Spring+Log4j+ActiveMQ实现远程记录日志——实战+分析 与参考文章的比较 ...

  4. 基于ActiveMQ的统一日志服务

    概述 以ActiveMQ + Log4j + Spring的技术组合,实现基于消息队列的统一日志服务. 参考:Spring+Log4j+ActiveMQ实现远程记录日志——实战+分析 与参考文章的比较 ...

  5. Android日志系统驱动程序Logger源代码分析

    文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/6595744 我们知道,在Android系统中, ...

  6. 基于Log4Net本地日志服务简单实现

    背景 项目开发中,我们或多或少会使用诸如NLog,Log4Net,Kafka+ELK等等日志套件: 基于关注点分离原则,业务开发的时候不应该关注日志具体实现:并且后续能方便切换其他日志套件: 这里先实 ...

  7. Android日志打印类LogUtils,能够定位到类名,方法名以及出现错误的行数并保存日志文件

    Android日志打印类LogUtils,能够定位到类名,方法名以及出现错误的行数并保存日志文件 在开发中,我们常常用打印log的方式来调试我们的应用.在Java中我们常常使用方法System.out ...

  8. android日志搜集原理及方案比较

    说明: 本文只讨论Log日志,而不是应用的埋点日志. Android 日志架构 用一张图来了解Android Log的架构: 这里涉及到三个进程: APP进程: 调用Log的接口打日志,最终通过soc ...

  9. 5分钟搭建网站实时分析:Grafana+日志服务实战

    原文地址:https://yq.aliyun.com/articles/227006 阿里云日志服务是针对日志类数据一站式服务,用户只需要将精力集中在分析上,过程中数据采集.对接各种存储计算.数据索引 ...

随机推荐

  1. MVC4 开篇

    开篇,肯定不讲技术. 新项目开工了,用到了MVC4,赶快来园子吐槽下. 刚出来一年,学到了一些东西,但是自知比菜鸟还不如,空闲不看书,不练习demo,快吐我吧... 哈哈,吐吧,哥还是一样淡定,淡定, ...

  2. wireshark添加ip.id字段

    wireshark添加ip.id字段 为了在多个设备上追踪同一个数据包. 如果是同一个会话,则可以计算延迟, 如sta和应用服务器慢,这种问题,可以根据这个加上ip.id追踪数据到哪里慢了.    

  3. php基础31:正则匹配-元字符

    <?php //2.正则表达式:元字符 $model = "/php/"; $string = "php"; // 1.元字符 [a-z] 匹配任何a-z ...

  4. 将Html文档整理为规范XML文档

    有多种方式可以在.NET 平台进行HTML文件解析.数据提取,其中最简单.稳妥的办法是先使用工具将Html文档整理成XML文档,再通过XML Dom模型或XPath灵活地进行数据处理.SGML便是一个 ...

  5. 【原创】Junit4详解一:Junit总体介绍

    Junit是一个可编写重复测试的简单框架,是基于Xunit架构的单元测试框架的实例.Junit4最大的改进是大量使用注解(元数据),很多实际执行过程都在Junit的后台做完了,而且写test case ...

  6. C++系列: 如何将十六机制的字符串转成整数

    bool convertHexStringToInt(char* pstrHex, unsigned long* pResult) { ) return false; else return true ...

  7. 动画:UIKitAnimation 简单动画学习 iOS (一) 渐变 、 移动 、翻页、来回翻转 ——转载

    转载请说明(谢谢) http://blog.csdn.net/a21064346/article/details/7851695 点击打开链接 以下 一个系列的 动画效果 在 UIView.h文件中可 ...

  8. UIButton利用分类扩展方法(封装)

    UIButton+BackgroundColor.h #import <UIKit/UIKit.h> @interface UIButton (BackgroundColor) - (vo ...

  9. .NET 关键字

    一.base关键字 可以通过base关键字访问上一级父类方法的访问.静态static函数无法调用base 二.new 关键字new new有2个作用. new运算符   用来分配内存空间和初始化对象. ...

  10. onload是代码在也买你的追加元素的完成,而不是http请求的完成