Android日誌服務 記錄日誌

轉： 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>