Android应用程序框架层和系统运行库层日志系统源代码分析

在开发Android应用程序时，少不了使用Log来监控和调试程序的执行。在上一篇文章Android日志系统驱动程序Logger源代码分析中，我们分析了驱动程序Logger的源代码，在前面的文章浅谈Android系统开发中Log的使用一文，我们也简单介绍在应用程序中使Log的方法，在这篇文章中，我们将详细介绍Android应用程序框架层和系统运行库存层日志系统的源代码，使得我们可以更好地理解Android的日志系统的实现。

我们在Android应用程序，一般是调用应用程序框架层的Java接口（android.util.Log）来使用日志系统，这个Java接口通过JNI方法和系统运行库最终调用内核驱动程序Logger把Log写到内核空间中。按照这个调用过程，我们一步步介绍Android应用程序框架层日志系统的源代码。学习完这个过程之后，我们可以很好地理解Android系统的架构，即应用程序层（Application）的接口是如何一步一步地调用到内核空间的。

一. 应用程序框架层日志系统Java接口的实现。

在浅谈Android系统开发中Log的使用一文中，我们曾经介绍过Android应用程序框架层日志系统的源代码接口。这里，为了描述方便和文章的完整性，我们重新贴一下这部份的代码，在frameworks/base/core/java/android/util/Log.java文件中，实现日志系统的Java接口：

1. ................................................
3. publicfinalclassLog{
5. ................................................
7. /**
8. *Priorityconstantfortheprintlnmethod;useLog.v.
9. */
10. publicstaticfinalintVERBOSE=2;
12. /**
13. *Priorityconstantfortheprintlnmethod;useLog.d.
14. */
15. publicstaticfinalintDEBUG=3;
17. /**
18. *Priorityconstantfortheprintlnmethod;useLog.i.
19. */
20. publicstaticfinalintINFO=4;
22. /**
23. *Priorityconstantfortheprintlnmethod;useLog.w.
24. */
25. publicstaticfinalintWARN=5;
27. /**
28. *Priorityconstantfortheprintlnmethod;useLog.e.
29. */
30. publicstaticfinalintERROR=6;
32. /**
33. *Priorityconstantfortheprintlnmethod.
34. */
35. publicstaticfinalintASSERT=7;
37. .....................................................
39. publicstaticintv(Stringtag,Stringmsg){
40. returnprintln_native(LOG_ID_MAIN,VERBOSE,tag,msg);
41. }
43. publicstaticintv(Stringtag,Stringmsg,Throwabletr){
44. returnprintln_native(LOG_ID_MAIN,VERBOSE,tag,msg+'\n'+getStackTraceString(tr));
45. }
47. publicstaticintd(Stringtag,Stringmsg){
48. returnprintln_native(LOG_ID_MAIN,DEBUG,tag,msg);
49. }
51. publicstaticintd(Stringtag,Stringmsg,Throwabletr){
52. returnprintln_native(LOG_ID_MAIN,DEBUG,tag,msg+'\n'+getStackTraceString(tr));
53. }
55. publicstaticinti(Stringtag,Stringmsg){
56. returnprintln_native(LOG_ID_MAIN,INFO,tag,msg);
57. }
59. publicstaticinti(Stringtag,Stringmsg,Throwabletr){
60. returnprintln_native(LOG_ID_MAIN,INFO,tag,msg+'\n'+getStackTraceString(tr));
61. }
63. publicstaticintw(Stringtag,Stringmsg){
64. returnprintln_native(LOG_ID_MAIN,WARN,tag,msg);
65. }
67. publicstaticintw(Stringtag,Stringmsg,Throwabletr){
68. returnprintln_native(LOG_ID_MAIN,WARN,tag,msg+'\n'+getStackTraceString(tr));
69. }
71. publicstaticintw(Stringtag,Throwabletr){
72. returnprintln_native(LOG_ID_MAIN,WARN,tag,getStackTraceString(tr));
73. }
75. publicstaticinte(Stringtag,Stringmsg){
76. returnprintln_native(LOG_ID_MAIN,ERROR,tag,msg);
77. }
79. publicstaticinte(Stringtag,Stringmsg,Throwabletr){
80. returnprintln_native(LOG_ID_MAIN,ERROR,tag,msg+'\n'+getStackTraceString(tr));
81. }
83. ..................................................................
84. /**@hide*/publicstaticnativeintLOG_ID_MAIN=0;
85. /**@hide*/publicstaticnativeintLOG_ID_RADIO=1;
86. /**@hide*/publicstaticnativeintLOG_ID_EVENTS=2;
87. /**@hide*/publicstaticnativeintLOG_ID_SYSTEM=3;
89. /**@hide*/publicstaticnativeintprintln_native(intbufID,
90. intpriority,Stringtag,Stringmsg);
91. }

定义了2~7一共6个日志优先级别ID和4个日志缓冲区ID。回忆一下Android日志系统驱动程序Logger源代码分析一文，在Logger驱动程序模块中，定义了log_main、log_events和log_radio三个日志缓冲区，分别对应三个设备文件/dev/log/main、/dev/log/events和/dev/log/radio。这里的4个日志缓冲区的前面3个ID就是对应这三个设备文件的文件描述符了，在下面的章节中，我们将看到这三个文件描述符是如何创建的。在下载下来的Android内核源代码中，第4个日志缓冲区LOG_ID_SYSTEM并没有对应的设备文件，在这种情况下，它和LOG_ID_MAIN对应同一个缓冲区ID，在下面的章节中，我们同样可以看到这两个ID是如何对应到同一个设备文件的。

在整个Log接口中，最关键的地方声明了println_native本地方法，所有的Log接口都是通过调用这个本地方法来实现Log的定入。下面我们就继续分析这个本地方法println_native。

二. 应用程序框架层日志系统JNI方法的实现。

在frameworks/base/core/jni/Android_util_Log.cpp文件中，实现JNI方法println_native：

1. /*//device/libs/Android_runtime/android_util_Log.cpp
2. **
3. **Copyright2006,TheAndroidOpenSourceProject
4. **
5. **LicensedundertheApacheLicense,Version2.0(the"License");
6. **youmaynotusethisfileexceptincompliancewiththeLicense.
7. **YoumayobtainacopyoftheLicenseat
8. **
9. **http://www.apache.org/licenses/LICENSE-2.0
10. **
11. **Unlessrequiredbyapplicablelaworagreedtoinwriting,software
12. **distributedundertheLicenseisdistributedonan"ASIS"BASIS,
13. **WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
14. **SeetheLicenseforthespecificlanguagegoverningpermissionsand
15. **limitationsundertheLicense.
16. */
18. #defineLOG_NAMESPACE"log.tag."
19. #defineLOG_TAG"Log_println"
21. #include<assert.h>
22. #include<cutils/properties.h>
23. #include<utils/Log.h>
24. #include<utils/String8.h>
26. #include"jni.h"
27. #include"utils/misc.h"
28. #include"Android_runtime/AndroidRuntime.h"
30. #defineMIN(a,b)((a<b)?a:b)
32. namespaceAndroid{
34. structlevels_t{
35. jintverbose;
36. jintdebug;
37. jintinfo;
38. jintwarn;
39. jinterror;
40. jintassert;
41. };
42. staticlevels_tlevels;
44. staticinttoLevel(constchar*value)
45. {
46. switch(value[0]){
47. case'V':returnlevels.verbose;
48. case'D':returnlevels.debug;
49. case'I':returnlevels.info;
50. case'W':returnlevels.warn;
51. case'E':returnlevels.error;
52. case'A':returnlevels.assert;
53. case'S':return-1;//SUPPRESS
54. }
55. returnlevels.info;
56. }
58. staticjbooleanAndroid_util_Log_isLoggable(JNIEnv*env,jobjectclazz,jstringtag,jintlevel)
59. {
60. #ifndefHAVE_Android_OS
61. returnfalse;
62. #else/*HAVE_Android_OS*/
63. intlen;
64. charkey[PROPERTY_KEY_MAX];
65. charbuf[PROPERTY_VALUE_MAX];
67. if(tag==NULL){
68. returnfalse;
69. }
71. jbooleanresult=false;
73. constchar*chars=env->GetStringUTFChars(tag,NULL);
75. if((strlen(chars)+sizeof(LOG_NAMESPACE))>PROPERTY_KEY_MAX){
76. jclassclazz=env->FindClass("java/lang/IllegalArgumentException");
77. charbuf2[200];
78. snprintf(buf2,sizeof(buf2),"Logtag\"%s\"exceedslimitof%dcharacters\n",
79. chars,PROPERTY_KEY_MAX-sizeof(LOG_NAMESPACE));
81. //releasethechars!
82. env->ReleaseStringUTFChars(tag,chars);
84. env->ThrowNew(clazz,buf2);
85. returnfalse;
86. }else{
87. strncpy(key,LOG_NAMESPACE,sizeof(LOG_NAMESPACE)-1);
88. strcpy(key+sizeof(LOG_NAMESPACE)-1,chars);
89. }
91. env->ReleaseStringUTFChars(tag,chars);
93. len=property_get(key,buf,"");
94. intlogLevel=toLevel(buf);
95. return(logLevel>=0&&level>=logLevel)?true:false;
96. #endif/*HAVE_Android_OS*/
97. }
99. /*
100. *InclassAndroid.util.Log:
101. *publicstaticnativeintprintln_native(intbuffer,intpriority,Stringtag,Stringmsg)
102. */
103. staticjintAndroid_util_Log_println_native(JNIEnv*env,jobjectclazz,
104. jintbufID,jintpriority,jstringtagObj,jstringmsgObj)
105. {
106. constchar*tag=NULL;
107. constchar*msg=NULL;
109. if(msgObj==NULL){
110. jclassnpeClazz;
112. npeClazz=env->FindClass("java/lang/NullPointerException");
113. assert(npeClazz!=NULL);
115. env->ThrowNew(npeClazz,"printlnneedsamessage");
116. return-1;
117. }
119. if(bufID<0||bufID>=LOG_ID_MAX){
120. jclassnpeClazz;
122. npeClazz=env->FindClass("java/lang/NullPointerException");
123. assert(npeClazz!=NULL);
125. env->ThrowNew(npeClazz,"badbufID");
126. return-1;
127. }
129. if(tagObj!=NULL)
130. tag=env->GetStringUTFChars(tagObj,NULL);
131. msg=env->GetStringUTFChars(msgObj,NULL);
133. intres=__Android_log_buf_write(bufID,(android_LogPriority)priority,tag,msg);
135. if(tag!=NULL)
136. env->ReleaseStringUTFChars(tagObj,tag);
137. env->ReleaseStringUTFChars(msgObj,msg);
139. returnres;
140. }
142. /*
143. *JNIregistration.
144. */
145. staticJNINativeMethodgMethods[]={
146. /*name,signature,funcPtr*/
147. {"isLoggable","(Ljava/lang/String;I)Z",(void*)Android_util_Log_isLoggable},
148. {"println_native","(IILjava/lang/String;Ljava/lang/String;)I",(void*)Android_util_Log_println_native},
149. };
151. intregister_Android_util_Log(JNIEnv*env)
152. {
153. jclassclazz=env->FindClass("Android/util/Log");
155. if(clazz==NULL){
156. LOGE("Can'tfindAndroid/util/Log");
157. return-1;
158. }
160. levels.verbose=env->GetStaticIntField(clazz,env->GetStaticFieldID(clazz,"VERBOSE","I"));
161. levels.debug=env->GetStaticIntField(clazz,env->GetStaticFieldID(clazz,"DEBUG","I"));
162. levels.info=env->GetStaticIntField(clazz,env->GetStaticFieldID(clazz,"INFO","I"));
163. levels.warn=env->GetStaticIntField(clazz,env->GetStaticFieldID(clazz,"WARN","I"));
164. levels.error=env->GetStaticIntField(clazz,env->GetStaticFieldID(clazz,"ERROR","I"));
165. levels.assert=env->GetStaticIntField(clazz,env->GetStaticFieldID(clazz,"ASSERT","I"));
167. returnAndroidRuntime::registerNativeMethods(env,"android/util/Log",gMethods,NELEM(gMethods));
168. }
170. };//namespaceAndroid

在gMethods变量中，定义了println_native本地方法对应的函数调用是Android_util_Log_println_native。在android_util_Log_println_native函数中，通过了各项参数验证正确后，就调用运行时库函数__android_log_buf_write来实现Log的写入操作。__android_log_buf_write函实实现在liblog库中，它有4个参数，分别缓冲区ID、优先级别ID、Tag字符串和Msg字符串。下面运行时库liblog中的__android_log_buf_write的实现。

三. 系统运行库层日志系统的实现。

在系统运行库层liblog库的实现中，内容比较多，这里，我们只关注日志写入操作__Android_log_buf_write的相关实现：

1. int__Android_log_buf_write(intbufID,intprio,constchar*tag,constchar*msg)
2. {
3. structiovecvec[3];
5. if(!tag)
6. tag="";
8. /*XXX:Thisneedstogo!*/
9. if(!strcmp(tag,"HTC_RIL")||
10. !strncmp(tag,"RIL",3)||/*Anylogtagwith"RIL"astheprefix*/
11. !strcmp(tag,"AT")||
12. !strcmp(tag,"GSM")||
13. !strcmp(tag,"STK")||
14. !strcmp(tag,"CDMA")||
15. !strcmp(tag,"PHONE")||
16. !strcmp(tag,"SMS"))
17. bufID=LOG_ID_RADIO;
19. vec[0].iov_base=(unsignedchar*)&prio;
20. vec[0].iov_len=1;
21. vec[1].iov_base=(void*)tag;
22. vec[1].iov_len=strlen(tag)+1;
23. vec[2].iov_base=(void*)msg;
24. vec[2].iov_len=strlen(msg)+1;
26. returnwrite_to_log(bufID,vec,3);
27. }

函数首先是检查传进来的tag参数是否是为HTC_RIL、RIL、AT、GSM、STK、CDMA、PHONE和SMS中的一个，如果是，就无条件地使用ID为LOG_ID_RADIO的日志缓冲区作为写入缓冲区，接着，把传进来的参数prio、tag和msg分别存放在一个向量数组中，调用write_to_log函数来进入下一步操作。write_to_log是一个函数指针，定义在文件开始的位置上：

2. staticint__write_to_log_init(log_id_t,structiovec*vec,size_tnr);

• staticint(*write_to_log)(log_id_t,structiovec*vec,size_tnr)=__write_to_log_init;

并且初始化为__write_to_log_init函数：

1. staticint__write_to_log_init(log_id_tlog_id,structiovec*vec,size_tnr)
2. {
3. #ifdefHAVE_PTHREADS
4. pthread_mutex_lock(&log_init_lock);
5. #endif
7. if(write_to_log==__write_to_log_init){
8. log_fds[LOG_ID_MAIN]=log_open("/dev/"LOGGER_LOG_MAIN,O_WRONLY);
9. log_fds[LOG_ID_RADIO]=log_open("/dev/"LOGGER_LOG_RADIO,O_WRONLY);
10. log_fds[LOG_ID_EVENTS]=log_open("/dev/"LOGGER_LOG_EVENTS,O_WRONLY);
11. log_fds[LOG_ID_SYSTEM]=log_open("/dev/"LOGGER_LOG_SYSTEM,O_WRONLY);
13. write_to_log=__write_to_log_kernel;
15. if(log_fds[LOG_ID_MAIN]<0||log_fds[LOG_ID_RADIO]<0||
16. log_fds[LOG_ID_EVENTS]<0){
17. log_close(log_fds[LOG_ID_MAIN]);
18. log_close(log_fds[LOG_ID_RADIO]);
19. log_close(log_fds[LOG_ID_EVENTS]);
20. log_fds[LOG_ID_MAIN]=-1;
21. log_fds[LOG_ID_RADIO]=-1;
22. log_fds[LOG_ID_EVENTS]=-1;
23. write_to_log=__write_to_log_null;
24. }
26. if(log_fds[LOG_ID_SYSTEM]<0){
27. log_fds[LOG_ID_SYSTEM]=log_fds[LOG_ID_MAIN];
28. }
29. }
31. #ifdefHAVE_PTHREADS
32. pthread_mutex_unlock(&log_init_lock);
33. #endif
35. returnwrite_to_log(log_id,vec,nr);
36. }

这里我们可以看到，如果是第一次调write_to_log函数，write_to_log == __write_to_log_init判断语句就会true，于是执行log_open函数打开设备文件，并把文件描述符保存在log_fds数组中。如果打开/dev/LOGGER_LOG_SYSTEM文件失败，即log_fds[LOG_ID_SYSTEM] < 0，就把log_fds[LOG_ID_SYSTEM]设置为log_fds[LOG_ID_MAIN]，这就是我们上面描述的如果不存在ID为LOG_ID_SYSTEM的日志缓冲区，就把LOG_ID_SYSTEM设置为和LOG_ID_MAIN对应的日志缓冲区了。LOGGER_LOG_MAIN、LOGGER_LOG_RADIO、LOGGER_LOG_EVENTS和LOGGER_LOG_SYSTEM四个宏定义在system/core/include/cutils/logger.h文件中：

1. #defineLOGGER_LOG_MAIN"log/main"
2. #defineLOGGER_LOG_RADIO"log/radio"
3. #defineLOGGER_LOG_EVENTS"log/events"
4. #defineLOGGER_LOG_SYSTEM"log/system"

接着，把write_to_log函数指针指向__write_to_log_kernel函数：

1. staticint__write_to_log_kernel(log_id_tlog_id,structiovec*vec,size_tnr)
2. {
3. ssize_tret;
4. intlog_fd;
6. if(/*(int)log_id>=0&&*/(int)log_id<(int)LOG_ID_MAX){
7. log_fd=log_fds[(int)log_id];
8. }else{
9. returnEBADF;
10. }
12. do{
13. ret=log_writev(log_fd,vec,nr);
14. }while(ret<0&&errno==EINTR);
16. returnret;
17. }

函数调用log_writev来实现Log的写入，注意，这里通过一个循环来写入Log，直到写入成功为止。这里log_writev是一个宏，在文件开始的地方定义为：

1. #ifFAKE_LOG_DEVICE
2. //Thiswillbedefinedwhenbuildingforthehost.
3. #definelog_open(pathname,flags)fakeLogOpen(pathname,flags)
4. #definelog_writev(filedes,vector,count)fakeLogWritev(filedes,vector,count)
5. #definelog_close(filedes)fakeLogClose(filedes)
6. #else
7. #definelog_open(pathname,flags)open(pathname,flags)
8. #definelog_writev(filedes,vector,count)writev(filedes,vector,count)
9. #definelog_close(filedes)close(filedes)
10. #endif

这里，我们看到，一般情况下，log_writev就是writev了，这是个常见的批量文件写入函数，就不多说了。

至些，整个调用过程就结束了。总结一下，首先是从应用程序层调用应用程序框架层的Java接口，应用程序框架层的Java接口通过调用本层的JNI方法进入到系统运行库层的C接口，系统运行库层的C接口通过设备文件来访问内核空间层的Logger驱动程序。这是一个典型的调用过程，很好地诠释Android的系统架构，希望读者好好领会。

转自：

http://www.linuxidc.com/Linux/2011-07/38989.htm

更多相关文章

1. Android应用程序的开发
2. Android新手轻松入门十问十答
3. C#/mono开发Android应用程序入门（三）-平台的意义和思考
4. android中的文件存储操作总结
5. Android应用程序的快速启动是怎样炼成的
6. 成为更好的Android开发者的30多个技巧
7. Android(安卓)数据存储和IO——SharedPreferences(一)
8. Android系统
9. Android之初步---摘录

随机推荐

1. Android事件处理方法总结-Handler消息处
2. Android(安卓)Studio常用设置
3. Android(安卓)4.4 KITKAT SDK的直接下载
4. 比较详细的handle机制
5. Android开发者应该深入学习的10个开源应
6. Android——用户登陆及用户名和密码的保
7. 部署应用程序到Android手机
8. Android(安卓)Studio 从安装到配置使用
9. Android之NDK开发详解
10. android 事件分发机制(源码解析)