4.5 Java日志寫入接口 · Android系統源代碼情景分析（第三版）

Android系統在應用程序框架層中定義了三個Java日志寫入接口，它們分別是android.util.Log、android.util.Slog和android.util.EventLog，寫入的日志記錄類型分別為main、system和events。這三個Java日志寫入接口是通過JNI方法來調用日志庫liblog提供的函數來實現日志記錄的寫入功能的。在本節內容中，我們就分別分析這三個Java日志寫入接口的實現。 **android.util.Log** **frameworks/base/core/java/android/util/Log.java** ~~~ public final class Log { ...... /** * Priority constant for the println method; use Log.v. */ public static final int VERBOSE = 2; /** * Priority constant for the println method; use Log.d */ public static final int DEBUG = 3; /** * Priority constant for the println method; use Log.i. */ public static final int INFO = 4; /** * Priority constant for the println method; use Log.w */ public static final int WARN = 5; /** * Priority constant for the println method; use Log.e. */ public static final int ERROR = 6; /** * Priority constant for the println method. */ public static final int ASSERT = 7; ...... public static int v(String tag， String msg) { return println_native(LOG_ID_MAIN， VERBOSE， tag， msg); } public static int d(String tag， String msg) { return println_native(LOG_ID_MAIN， DEBUG， tag， msg); } public static int i(String tag， String msg) { return println_native(LOG_ID_MAIN， INFO， tag， msg); } public static int w(String tag， String msg) { return println_native(LOG_ID_MAIN， WARN， tag， msg); } public static int e(String tag， String msg) { return println_native(LOG_ID_MAIN， ERROR， tag， msg); } ...... /** @hide */ public static native int LOG_ID_MAIN = 0; /** @hide */ public static native int LOG_ID_RADIO = 1; /** @hide */ public static native int LOG_ID_EVENTS = 2; /** @hide */ public static native int LOG_ID_SYSTEM = 3; /** @hide */ public static native int println_native(int bufID， int priority， String tag， String msg); } ~~~ 接口android.util.Log提供的日志記錄寫入成員函數比較多，不過我們只關注常用的成員函數v、d、i、w和e。這些成員函數寫入的日志記錄的類型都是main，而對應的日志記錄的優先級分別為VERBOSE、DEBUG、INFO、WARN和ERROR。它們是通過調用JNI方法println_native來實現日志記錄寫入功能的，如下所示。 **frameworks/base/core/jni/android_util_Log.cpp** ~~~ /* * In class android.util.Log: * public static native int println_native(int buffer， int priority， String tag， String msg) */ static jint android_util_Log_println_native(JNIEnv* env， jobject clazz， jint bufID， jint priority， jstring tagObj， jstring msgObj) { const char* tag = NULL; const char* msg = NULL; if (msgObj == NULL) { jclass npeClazz; npeClazz = env->FindClass("java/lang/NullPointerException"); assert(npeClazz != NULL); env->ThrowNew(npeClazz， "println needs a message"); return -1; } if (bufID < 0 || bufID >= LOG_ID_MAX) { jclass npeClazz; npeClazz = env->FindClass("java/lang/NullPointerException"); assert(npeClazz != NULL); env->ThrowNew(npeClazz， "bad bufID"); return -1; } if (tagObj != NULL) tag = env->GetStringUTFChars(tagObj， NULL); msg = env->GetStringUTFChars(msgObj， NULL); int res = __android_log_buf_write(bufID， (android_LogPriority)priority， tag， msg); if (tag != NULL) env->ReleaseStringUTFChars(tagObj， tag); env->ReleaseStringUTFChars(msgObj， msg); return res; } ~~~ 在JNI函數android_util_Log_println_native中，第11行到19行代碼檢查寫入的日志記錄的內容msgObj是否為null，接著第21行到29行代碼檢查寫入的日志記錄的類型值是否位于0和LOG_ID_MAX之間，其中，0、1、2和3四個值表示的日志記錄的類型分別為main、radio、events和system。通過這兩個合法性檢查之后，最后第35行就調用日志庫liblog提供的函數__android_log_buf_write來往Logger日志驅動程序中寫入日志記錄。函數__android_log_buf_write的實現可以參考前面4.3小節的內容，這里不再詳述。 **android.util.Slog** **frameworks/base/core/java/android/util/Slog.java** ~~~ /** * @hide */ public final class Slog { ...... public static int v(String tag， String msg) { return Log.println_native(Log.LOG_ID_SYSTEM， Log.VERBOSE， tag， msg); } public static int d(String tag， String msg) { return Log.println_native(Log.LOG_ID_SYSTEM， Log.DEBUG， tag， msg); } public static int i(String tag， String msg) { return Log.println_native(Log.LOG_ID_SYSTEM， Log.INFO， tag， msg); } public static int w(String tag， String msg) { return Log.println_native(Log.LOG_ID_SYSTEM， Log.WARN， tag， msg); } public static int e(String tag， String msg) { return Log.println_native(Log.LOG_ID_SYSTEM， Log.ERROR， tag， msg); } ...... } ~~~ > 在接口android.util.Slog定義前面的注釋中有一個“@hide”關鍵字，表示這是一個隱藏接口，只在系統內部使用，應用程序一般不應該使用該接口來寫入日志記錄。接口android.util.Slog寫入的日志記錄的類型為system，它常用的成員函數有v、d、i、w和e，對應的日志記錄的優先級分別為VERBOSE、DEBUG、INFO、WARN和ERROR，并且它們都是通過調用接口android.util.Log的JNI方法println_native來實現的。JNI方法println_native的實現已經在前面分析過了，這里不再詳述。 **android.util.EventLog** **frameworks/base/core/java/android/util/EventLog.java** ~~~ public class EventLog { ...... /** * Record an event log message. * @param tag The event type tag code * @param value A value to log * @return The number of bytes written */ public static native int writeEvent(int tag， int value); /** * Record an event log message. * @param tag The event type tag code * @param value A value to log * @return The number of bytes written */ public static native int writeEvent(int tag， long value); /** * Record an event log message. * @param tag The event type tag code * @param str A value to log * @return The number of bytes written */ public static native int writeEvent(int tag， String str); /** * Record an event log message. * @param tag The event type tag code * @param list A list of values to log * @return The number of bytes written */ public static native int writeEvent(int tag， Object... list); ...... } ~~~ 接口android.util.EventLog提供了四個重載版本的JNI方法writeEvent向Logger日志驅動程序中寫入類型為events的日志記錄，這些日志記錄的內容分別為整數、長整數、字符串和列表。我們首先分析寫入整數和長整數類型日志記錄的JNI方法writeEvent的實現。 **frameworks/base/core/jni/android_util_EventLog.cpp** ~~~ /* * In class android.util.EventLog: * static native int writeEvent(int tag， int value) */ static jint android_util_EventLog_writeEvent_Integer(JNIEnv* env， jobject clazz， jint tag， jint value) { return android_btWriteLog(tag， EVENT_TYPE_INT， &value， sizeof(value)); } /* * In class android.util.EventLog: * static native int writeEvent(long tag， long value) */ static jint android_util_EventLog_writeEvent_Long(JNIEnv* env， jobject clazz， jint tag， jlong value) { return android_btWriteLog(tag， EVENT_TYPE_LONG， &value， sizeof(value)); } ~~~ 它們都是通過調用宏android_btWriteLog向Logger日志驅動程序中寫入日志記錄的。前者在調用宏android_btWriteLog時，指定第二個參數為EVENT_TYPE_INT，表示要寫入的日志記錄的內容為一個整數，它的內存布局如圖4-8所示。后者在調用宏android_btWriteLog時，指定第二個參數為EVENT_TYPE_LONG，表示要寫入的日志記錄的內容為一個長整數，它的內存布局如圖4-9所示。內容為整數的日志記錄的內存布局 ![內容為整數的日志記錄的內存布局](https://box.kancloud.cn/e9c6be1c13d19e69c270056c692334fd_796x43.jpg =796x43) 內容為長整數的日志記錄的內存布局 ![內容為長整數的日志記錄的內存布局](https://box.kancloud.cn/320a6a0859aa620fec081f1a60ba33e8_796x42.jpg =796x42) 宏android_btWriteLog的定義如下所示。 **system/core/include/cutils/log.h** ~~~ #define android_btWriteLog(tag， type， payload， len) \ __android_log_btwrite(tag， type， payload， len) ~~~ 它指向了日志庫liblog提供的函數__android_log_btwrite。函數__android_log_btwrite的實現可以參考前面4.3小節的內容，這里不再詳述。接下來，我們分析寫入字符串類型日志記錄的JNI方法writeEvent的實現。 **frameworks/base/core/jni/android_util_EventLog.cpp** ~~~ /* * In class android.util.EventLog: * static native int writeEvent(int tag， String value) */ static jint android_util_EventLog_writeEvent_String(JNIEnv* env， jobject clazz， jint tag， jstring value) { uint8_t buf[MAX_EVENT_PAYLOAD]; // Don't throw NPE -- I feel like it's sort of mean for a logging function // to be all crashy if you pass in NULL -- but make the NULL value explicit. const char *str = value != NULL ? env->GetStringUTFChars(value， NULL) : "NULL"; jint len = strlen(str); const int max = sizeof(buf) - sizeof(len) - 2; // Type byte， final newline if (len > max) len = max; buf[0] = EVENT_TYPE_STRING; memcpy(&buf[1]， &len， sizeof(len)); memcpy(&buf[1 + sizeof(len)]， str， len); buf[1 + sizeof(len) + len] = '\n'; if (value != NULL) env->ReleaseStringUTFChars(value， str); return android_bWriteLog(tag， buf， 2 + sizeof(len) + len); } ~~~ 內容為字符串的日志記錄的內存布局如圖4-10所示。 ![內容為字符串的日志記錄的內存布局](https://box.kancloud.cn/98642825e80297828b58dd746b05e02d_810x43.jpg =810x43) 第一個字段記錄日志記錄內容的類型為字符串，第二個字段描述該字符串的長度，第三個字段保存的是字符串內容，第四個字段使用特殊字符‘\n’來結束該日志記錄。結合這個內存布局圖，就不難理解函數android_util_EventLog_writeEvent_String的實現了。第22行使用宏android_bWriteLog將日志記錄寫入到Logger日志驅動程序中，它的定義如下所示。 **system/core/include/cutils/log.h** ~~~ #define android_bWriteLog(tag， payload， len) \ __android_log_bwrite(tag， payload， len) ~~~ 它指向了日志庫liblog提供的函數__android_log_bwrite。函數__android_log_bwrite的實現可以參考前面4.3小節的內容，這里不再詳述。最后，我們分析寫入列表類型日志記錄的JNI方法writeEvent的實現。 **frameworks/base/core/jni/android_util_EventLog.cpp** ~~~ /* * In class android.util.EventLog: * static native int writeEvent(long tag， Object... value) */ static jint android_util_EventLog_writeEvent_Array(JNIEnv* env， jobject clazz， jint tag， jobjectArray value) { if (value == NULL) { return android_util_EventLog_writeEvent_String(env， clazz， tag， NULL); } uint8_t buf[MAX_EVENT_PAYLOAD]; const size_t max = sizeof(buf) - 1; // leave room for final newline size_t pos = 2; // Save room for type tag & array count jsize copied = 0， num = env->GetArrayLength(value); for (; copied < num && copied < 255; ++copied) { jobject item = env->GetObjectArrayElement(value， copied); if (item == NULL || env->IsInstanceOf(item， gStringClass)) { if (pos + 1 + sizeof(jint) > max) break; const char *str = item != NULL ? env->GetStringUTFChars((jstring) item， NULL) : "NULL"; jint len = strlen(str); if (pos + 1 + sizeof(len) + len > max) len = max - pos - 1 - sizeof(len); buf[pos++] = EVENT_TYPE_STRING; memcpy(&buf[pos]， &len， sizeof(len)); memcpy(&buf[pos + sizeof(len)]， str， len); pos += sizeof(len) + len; if (item != NULL) env->ReleaseStringUTFChars((jstring) item， str); } else if (env->IsInstanceOf(item， gIntegerClass)) { jint intVal = env->GetIntField(item， gIntegerValueID); if (pos + 1 + sizeof(intVal) > max) break; buf[pos++] = EVENT_TYPE_INT; memcpy(&buf[pos]， &intVal， sizeof(intVal)); pos += sizeof(intVal); } else if (env->IsInstanceOf(item， gLongClass)) { jlong longVal = env->GetLongField(item， gLongValueID); if (pos + 1 + sizeof(longVal) > max) break; buf[pos++] = EVENT_TYPE_LONG; memcpy(&buf[pos]， &longVal， sizeof(longVal)); pos += sizeof(longVal); } else { jniThrowException(env， "java/lang/IllegalArgumentException"， "Invalid payload item type"); return -1; } env->DeleteLocalRef(item); } buf[0] = EVENT_TYPE_LIST; buf[1] = copied; buf[pos++] = '\n'; return android_bWriteLog(tag， buf， pos); } ~~~ 位于列表中的元素的值類型只能為整數、長整數或者字符串;否則，函數就會在第41行到第43行拋出一個異常。一個列表中最多可以包含255個元素，如果超過這個數值，多余的元素就會被忽略。在函數第16行到第47行的for循環中，依次取出列表中的元素，并且根據它們的值類型來組織緩沖區buf的內存布局。如果值類型為整數，那么寫入到緩沖區buf的第一個字節設置為一個EVENT_TYPE_INT值，再加上一個整數值;如果值類型為長整數，那么寫入到緩沖區buf的內容就為一個EVENT_TYPE_LONG值，再加上一個長整數值;如果值類型為字符串，那么寫入到緩沖區buf的內容就為一個EVENT_TYPE_STRING值和一個字符串長度值，再加上字符串的內容。將列表中的元素都寫入到緩沖區buf之后，函數第49行將緩沖區buf的第一個字節設置為EVENT_TYPE_LIST，表示這是一個列表類型的日志記錄;接著第50行將緩沖區buf的第二個字節設置為變量copied的值，表示在緩沖區buf中的列表元素個數;最后第51行將緩沖區buf的最后一個字節的內容設置為特殊字符‘\n’，用作該日志記錄的結束標志。這時候，緩沖區buf的內存布局就類似于圖4-11。 ![內容為列表的日志記錄的內存布局](https://box.kancloud.cn/51a78e4f6831bb32e1bc4a5e3726a145_923x66.jpg =923x66) 函數第52行使用了宏android_bWriteLog將日志記錄寫入到Logger日志驅動程序中。前面提到，宏android_bWriteLog指向的是日志庫liblog提供的函數__android_log_bwrite，它的實現可以參考前面4.3小節的內容，這里不再詳述。至此，我們就介紹完了Android系統的日志寫入接口。接下來，我們繼續分析如何讀取并且顯示Logger日志驅動程序中的日志記錄。