Android Log 跟踪

最新推荐文章于 2021-09-27 14:22:25 发布
最新推荐文章于 2021-09-27 14:22:25 发布
阅读量827 收藏
点赞数
分类专栏： Android


android log系统。

在android Java code中输出log

android系统有4种类型、6个优先级的log，有一些常量用于标识这些信息，相关的定义在frameworks/base/core/java/android/util/Log.java中可以看到：

01/**
02 * Priority constant for the println method; use Log.v.
03 */
04public static final int VERBOSE = 2;
05 
06/**
07 * Priority constant for the println method; use Log.d.
08 */
09public static final int DEBUG = 3;
10 
11/**
12 * Priority constant for the println method; use Log.i.
13 */
14public static final int INFO = 4;
15 
16/**
17 * Priority constant for the println method; use Log.w.
18 */
19public static final int WARN = 5;
20 
21/**
22 * Priority constant for the println method; use Log.e.
23 */
24public static final int ERROR = 6;
25 
26/**
27 * Priority constant for the println method.
28 */
29public static final int ASSERT = 7;
30 
31/** @hide */ public static final int LOG_ID_MAIN = 0;
32/** @hide */ public static final int LOG_ID_RADIO = 1;
33/** @hide */ public static final int LOG_ID_EVENTS = 2;
34/** @hide */ public static final int LOG_ID_SYSTEM = 3;

Java层可以通过三个class来输出其中三种类型的log，三种类型分别为MAIN、RADIO和SYSTEM，三个class分别为Log、Rlog和Slog，其package则分别为android.util、android.telephony和 android.util。这些用于打印log的classes，其构造函数都为private，因而都不能创建其对象，但它们都提供了静态方法来给用户打印log。各个log打印class的实现都大同小异，可以看一下Log这个class中的一些：

01public static int v(String tag, String msg, Throwable tr) {
02    return println_native(LOG_ID_MAIN, VERBOSE, tag, msg + '\n' + getStackTraceString(tr));
03}
04 
05/**
06 * Send a {@link #DEBUG} log message.
07 * @param tag Used to identify the source of a log message.  It usually identifies
08 *        the class or activity where the log call occurs.
09 * @param msg The message you would like logged.
10 */
11public static int d(String tag, String msg) {
12    return println_native(LOG_ID_MAIN, DEBUG, tag, msg);
13}

最终都会是调用Log.println_native()静态native方法来打印log，各个类中各个方法的不同之处也仅在于参数的差异。

Log.println_native()方法

这个方法的code在/frameworks/base/core/jni/android_util_Log.cpp，为：

01static jint android_util_Log_println_native(JNIEnv* env, jobject clazz,
02        jint bufID, jint priority, jstring tagObj, jstring msgObj)
03{
04    const char* tag = NULL;
05    const char* msg = NULL;
06 
07    if (msgObj == NULL) {
08        jniThrowNullPointerException(env, "println needs a message");
09        return -1;
10    }
11 
12    if (bufID < 0 || bufID >= LOG_ID_MAX) {
13        jniThrowNullPointerException(env, "bad bufID");
14        return -1;
15    }
16 
17    if (tagObj != NULL)
18        tag = env->GetStringUTFChars(tagObj, NULL);
19    msg = env->GetStringUTFChars(msgObj, NULL);
20 
21    int res = __android_log_buf_write(bufID, (android_LogPriority)priority, tag, msg);
22 
23    if (tag != NULL)
24        env->ReleaseStringUTFChars(tagObj, tag);
25    env->ReleaseStringUTFChars(msgObj, msg);
26 
27    return res;
28}
29 
30/*
31 * JNI registration.
32 */
33static JNINativeMethod gMethods[] = {
34    /* name, signature, funcPtr */
35    { "isLoggable",      "(Ljava/lang/String;I)Z", (void*) android_util_Log_isLoggable },
36    { "println_native",  "(IILjava/lang/String;Ljava/lang/String;)I", (void*) android_util_Log_println_native },
37};

可以看到，干的都是转换参数的事情，最终再call到__android_log_buf_write()函数，这个函数的定义在system/core/liblog/logd_write.c，为：

01int __android_log_buf_write(int bufID, int prio, const char *tag, const char *msg)
02{
03    struct iovec vec[3];
04    char tmp_tag[32];
05 
06    if (!tag)
07        tag = "";
08 
09    /* XXX: This needs to go! */
10    if ((bufID != LOG_ID_RADIO) &&
11         (!strcmp(tag, "HTC_RIL") ||
12        !strncmp(tag, "RIL", 3) || /* Any log tag with "RIL" as the prefix */
13        !strncmp(tag, "IMS", 3) || /* Any log tag with "IMS" as the prefix */
14        !strcmp(tag, "AT") ||
15        !strcmp(tag, "GSM") ||
16        !strcmp(tag, "STK") ||
17        !strcmp(tag, "CDMA") ||
18        !strcmp(tag, "PHONE") ||
19        !strcmp(tag, "SMS"))) {
20            bufID = LOG_ID_RADIO;
21            // Inform third party apps/ril/radio.. to use Rlog or RLOG
22            snprintf(tmp_tag, sizeof(tmp_tag), "use-Rlog/RLOG-%s", tag);
23            tag = tmp_tag;
24    }
25 
26    vec[0].iov_base   = (unsigned char *) &prio;
27    vec[0].iov_len    = 1;
28    vec[1].iov_base   = (void *) tag;
29    vec[1].iov_len    = strlen(tag) + 1;
30    vec[2].iov_base   = (void *) msg;
31    vec[2].iov_len    = strlen(msg) + 1;
32 
33    return write_to_log(bufID, vec, 3);
34}

做了三件事情，一是根据log的tag，转换bufID，二是用传进来的参数构造一个struct iovec数组，三是将前一步构造的数组作为参数调用write_to_log()。write_to_log()是一个函数指针，在开始时，它指向了__write_to_log_init()：

1static int (*write_to_log)(log_id_t, struct iovec *vec, size_t nr) = __write_to_log_init;

__write_to_log_init()的实现如下：

01static int __write_to_log_init(log_id_t log_id, struct iovec *vec, size_t nr)
02{
03#ifdef HAVE_PTHREADS
04    pthread_mutex_lock(&log_init_lock);
05#endif
06 
07    if (write_to_log == __write_to_log_init) {
08        log_fds[LOG_ID_MAIN] = log_open("/dev/"LOGGER_LOG_MAIN, O_WRONLY);
09        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);
12 
13        write_to_log = __write_to_log_kernel;
14 
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        }
25 
26        if (log_fds[LOG_ID_SYSTEM] < 0) {
27            log_fds[LOG_ID_SYSTEM] = log_fds[LOG_ID_MAIN];
28        }
29    }
30 
31#ifdef HAVE_PTHREADS
32    pthread_mutex_unlock(&log_init_lock);
33#endif
34 
35    return write_to_log(log_id, vec, nr);
36}

这个地方，会检查write_to_log是否指向了__write_to_log_init，也就是是否是第一次打印log，如果是，则打开几个用于输出log的设备文件，然后使write_to_log函数指针指向__write_to_log_kernel，或者在打开输出log设备文件出现异常时，使write_to_log指向__write_to_log_null，最后再次调用经过了重定向的write_to_log，也就是__write_to_log_kernel或者__write_to_log_null函数。我们可以看一下那几个设备文件究竟是什麽(在system/core/include/cutils/logger.h)：

1#define LOGGER_LOG_MAIN     "log/main"
2#define LOGGER_LOG_RADIO    "log/radio"
3#define LOGGER_LOG_EVENTS   "log/events"
4#define LOGGER_LOG_SYSTEM   "log/system"

接着继续来看__write_to_log_kernel或者__write_to_log_null函数：

01static int __write_to_log_null(log_id_t log_fd, struct iovec *vec, size_t nr)
02{
03    return -1;
04}
05 
06static int __write_to_log_kernel(log_id_t log_id, struct iovec *vec, size_t nr)
07{
08    ssize_t ret;
09    int log_fd;
10 
11    if (/*(int)log_id >= 0 &&*/ (int)log_id < (int)LOG_ID_MAX) {
12        log_fd = log_fds[(int)log_id];
13    } else {
14        return EBADF;
15    }
16 
17    do {
18        ret = log_writev(log_fd, vec, nr);
19    } while (ret < 0 && errno == EINTR);
20 
21    return ret;
22}

由log_id获取到对应的log_fd，然后调用log_writev()打印log。可以看一下log_writev()的定义，它是一个宏：

01#if FAKE_LOG_DEVICE
02// This will be defined when building for the host.
03#define log_open(pathname, flags) fakeLogOpen(pathname, flags)
04#define log_writev(filedes, vector, count) fakeLogWritev(filedes, vector, count)
05#define log_close(filedes) fakeLogClose(filedes)
06#else
07#define log_open(pathname, flags) open(pathname, (flags) | O_CLOEXEC)
08#define log_writev(filedes, vector, count) writev(filedes, vector, count)
09#define log_close(filedes) close(filedes)
10#endif

这些就都是标准的unix系统调用了。

本地层代码Log输出

以一些比较典型的native代码打印log的case为例。先来看一下，在JNI的code中打印log的方法。在JNI中，比较常见到用ALOGx这一组宏来打印log，比如在frameworks/base/core/jni/android/graphics/TextLayoutCache.cpp这个文件中的dumpCacheStats()函数：

01void TextLayoutCache::dumpCacheStats() {
02    float remainingPercent = 100 * ((mMaxSize - mSize) / ((float)mMaxSize));
03    float timeRunningInSec = (systemTime(SYSTEM_TIME_MONOTONIC) - mCacheStartTime) / 1000000000;
04 
05    size_t cacheSize = mCache.size();
06 
07    ALOGD("------------------------------------------------");
08    ALOGD("Cache stats");
09    ALOGD("------------------------------------------------");
10    ALOGD("pid       : %d", getpid());
11    ALOGD("running   : %.0f seconds", timeRunningInSec);
12    ALOGD("entries   : %d", cacheSize);
13    ALOGD("max size  : %d bytes", mMaxSize);
14    ALOGD("used      : %d bytes according to mSize", mSize);
15    ALOGD("remaining : %d bytes or %2.2f percent", mMaxSize - mSize, remainingPercent);
16    ALOGD("hits      : %d", mCacheHitCount);
17    ALOGD("saved     : %0.6f ms", mNanosecondsSaved * 0.000001f);
18    ALOGD("------------------------------------------------");
19}

使用这组宏，需要定义另外一个宏来作为所打印log的tag：

1#define LOG_TAG "TextLayoutCache"

此外，还要include头文件<cutils/log.h>。来看一下这些宏中的一些的定义：

01/*
02 * Simplified macro to send a debug log message using the current LOG_TAG.
03 */
04#ifndef ALOGD
05#define ALOGD(...) ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__))
06#endif
07 
08/*
09 * Simplified macro to send a warning log message using the current LOG_TAG.
10 */
11#ifndef ALOGW
12#define ALOGW(...) ((void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__))
13#endif
14 
15/*
16 * Basic log message macro.
17 *
18 * Example:
19 *  ALOG(LOG_WARN, NULL, "Failed with error %d", errno);
20 *
21 * The second argument may be NULL or "" to indicate the "global" tag.
22 */
23#ifndef ALOG
24#define ALOG(priority, tag, ...) \
25    LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)
26#endif
27 
28/*
29 * Log macro that allows you to specify a number for the priority.
30 */
31#ifndef LOG_PRI
32#define LOG_PRI(priority, tag, ...) \
33    android_printLog(priority, tag, __VA_ARGS__)
34#endif
35 
36#define android_printLog(prio, tag, fmt...) \
37    __android_log_print(prio, tag, fmt)

先来看一下，在native层中定义的priority(在system/core/include/android/log.h中)：

01/*
02 * Android log priority values, in ascending priority order.
03 */
04typedef enum android_LogPriority {
05    ANDROID_LOG_UNKNOWN = 0,
06    ANDROID_LOG_DEFAULT,    /* only for SetMinPriority() */
07    ANDROID_LOG_VERBOSE,
08    ANDROID_LOG_DEBUG,
09    ANDROID_LOG_INFO,
10    ANDROID_LOG_WARN,
11    ANDROID_LOG_ERROR,
12    ANDROID_LOG_FATAL,
13    ANDROID_LOG_SILENT,     /* only for SetMinPriority(); must be last */
14} android_LogPriority;

另外，这些宏最终都会call到__android_log_print()，也是在system/core/liblog/logd_write.c中：

01int __android_log_print(int prio, const char *tag, const char *fmt, ...)
02{
03    va_list ap;
04    char buf[LOG_BUF_SIZE];
05 
06    va_start(ap, fmt);
07    vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);
08    va_end(ap);
09 
10    return __android_log_write(prio, tag, buf);
11}

先是格式化参数，然后就是调用__android_log_write()函数。这个函数的code如下：

01int __android_log_write(int prio, const char *tag, const char *msg)
02{
03    struct iovec vec[3];
04    log_id_t log_id = LOG_ID_MAIN;
05    char tmp_tag[32];
06 
07    if (!tag)
08        tag = "";
09 
10    /* XXX: This needs to go! */
11    if (!strcmp(tag, "HTC_RIL") ||
12        !strncmp(tag, "RIL", 3) || /* Any log tag with "RIL" as the prefix */
13        !strncmp(tag, "IMS", 3) || /* Any log tag with "IMS" as the prefix */
14        !strcmp(tag, "AT") ||
15        !strcmp(tag, "GSM") ||
16        !strcmp(tag, "STK") ||
17        !strcmp(tag, "CDMA") ||
18        !strcmp(tag, "PHONE") ||
19        !strcmp(tag, "SMS")) {
20            log_id = LOG_ID_RADIO;
21            // Inform third party apps/ril/radio.. to use Rlog or RLOG
22            snprintf(tmp_tag, sizeof(tmp_tag), "use-Rlog/RLOG-%s", tag);
23            tag = tmp_tag;
24    }
25 
26    vec[0].iov_base   = (unsigned char *) &prio;
27    vec[0].iov_len    = 1;
28    vec[1].iov_base   = (void *) tag;
29    vec[1].iov_len    = strlen(tag) + 1;
30    vec[2].iov_base   = (void *) msg;
31    vec[2].iov_len    = strlen(msg) + 1;
32 
33    return write_to_log(log_id, vec, 3);
34}

这个函数与我们前面看到的__android_log_buf_write()非常相似。所不同的就是这个函数没有log_id参数，因而它默认是输出MAIN log，当log的TAG为某些特殊字串时，则输出RADIO log。最后同样是调用write_to_log这个函数指针来输出log。

我们再来看一个skia里面打log的SkDebugf()函数的实现：

1#include <android/log.h>
2 
3void SkDebugf(const char format[], ...) {
4    va_list args;
5    va_start(args, format);
6    __android_log_vprint(ANDROID_LOG_DEBUG, LOG_TAG, format, args);
7    va_end(args);
8}

call到了__android_log_vprint()来输出log，__android_log_vprint()的定义也在system/core/liblog/logd_write.c中：

1int __android_log_vprint(int prio, const char *tag, const char *fmt, va_list ap)
2{
3    char buf[LOG_BUF_SIZE];
4 
5    vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);
6 
7    return __android_log_write(prio, tag, buf);
8}

一样是__android_log_write()函数。

Done.

Android输出Log控制
cuojue1234的博客
10-26 287
首先确定测试版本Log与打包版本Log 自定义LogUtil 通过DeBugMode控制是否输出Log 在需要加Log的地方使用LogUtil中的方法 import android.content.Context; import android.util.Log; import android.widget.Toast; public class LogUtil { public
android 在屏幕上打印log
05-04
项目中为了调试方便,将log打印在屏幕上面
android的Log输出
热门推荐
alley_zhang的专栏
07-05 10万+
<br /><br />一个android应用程序运行后 并不会在 ide的控制台内输出任何信息. 不能在控制台输出。但是android提供的Log类。<br /> <br />在程序中输出日志, 使用 android.util.Log 类. <br />该类提供了若干静态方法 <br />Log.v(String tag, String msg); <br />Log.d(String tag, String msg); <br />Log.i(String tag, String msg); <br /
android log机制——输出log
weixin_33670713的博客
09-27 678
android log系统。 在android Jav...
Android输出日志Log类
weixin_30872499的博客
10-28 162
android.util.Log常用的方法有以下5个： Log.v()Log.d()Log.i()Log.w()以及Log.e()。根据首字母分别对应VERBOSE,DEBUG,INFO,WARN,ERROR。 1、Log.v的调试颜色为黑色的,任何消息都会输出,这里的v代表verbose啰嗦的意思,平时使用就是Log.v("",""); 2、Log.d的输出颜色是蓝色的,...
Android Log详解
haibinglong的专栏
09-03 2518
　　  android.util.Log常用的方法有以下5个：Log.v() Log.d() Log.i() Log.w() 以及 Log.e() 。根据首字母对应VERBOSE，DEBUG,INFO, WARN，ERROR。　　  1、Log.v 的调试颜色为黑色的，任何消息都会输出，这里的v代表verbose啰嗦的意思，平时使用就是Log.v("","");　　  2、Log.d的输出颜色是蓝色的，仅输出debug调试的意思，但他会输出上层的信息，过滤起来可以通过DDMS的Logcat标签来选择.　　 
AndroidLogCollector Java崩溃日志收集.zip_AndroidLog 崩溃_android_log col
09-24
在Android开发过程中，确保应用程序的稳定性和可靠性至关重要。当应用出现异常或崩溃时，开发者需要及时获取相关的错误信息以便进行调试和修复。AndroidLogCollector是一个专门为Android系统设计的工具，用于收集...
Android-AndroidLog日志打印输出到文件方便查看和上传到服务器
08-13
标题"Android-AndroidLog日志打印输出到文件方便查看和上传到服务器"所描述的，就是一种将Android应用的日志信息写入到本地文件的方法，以便后续分析或上传到远程服务器。这个方法能够帮助开发者在无法直接访问设备...
Android-AndroidLog工具
08-13
`AndroidLog工具`是为了提供比标准Android `Log`类更为实用的功能而设计的。标题中的"1个类，100个方法、9 KiB"表明这是一个轻量级且功能丰富的库，旨在提高开发效率。 这个工具可能包含了以下特性： 1. **多级别...
Android Log介绍
03-21
4. 使用异常堆栈跟踪：当捕获到异常时，使用`Log.e()`配合`Exception.printStackTrace()`，这样可以获得完整的堆栈跟踪信息。 总结，Android Log系统是开发者调试和优化应用程序不可或缺的工具。熟练掌握LogCat的...
Android-一个精简全面方便的AndroidLog库--ALog
08-13
在Android开发过程中，日志（Log）系统是开发者不可或缺的工具，用于调试、监测应用运行状态和记录异常信息。ALog是一个专为Android设计的精简、全面且方便的日志库，它旨在提供比默认的Android Log类更高效、更易用...
在Android界面上显示和获取Logcat日志输出
03-19
在Android界面上显示和获取Logcat日志输出 在Android界面上显示和获取Logcat日志输出
Android Log分析
11-12
对android log的详细分析 希望对大家有帮助
Android Log系统介绍 (基于Android N)
06-06
Android Log系统介绍 (基于Android N). 从调用 Log.d("xxx", "test") 到你从logcat中看到它的输出, 这中间都发生了什么? native代码中的"ALOG/ALOGD/ALOGE"等的"宏函数"log都打到哪里去了? 什么是 kernel log? 请看本文分析.
Android中Log信息的输出方法
guopeixin的专栏
06-09 2万+
<br />共两篇文章，第一篇讲述了如何在程序中输出Log信息，第二篇详细的分析了Log信息的输出机制。<br /> <br />下面是第一篇（转自：http://blog.163.com/binghaitao@126/blog/static/3383532520099309366435/）<br /> <br />1：在编译so文件的c或cpp文件之前中加入以下代码，就可以在android中的log显示日志内容<br />        #include <android/log.h><br />   
android Log
铁锹在手，天下我有
05-29 1286
log封装类 ，借鉴了imagelo
android log
Dylan_Sen的博客
12-02 3189
Android log的重要性不言而喻，是我们分析问题的依据，理解代码的好助手。 本文从以下两方面对log做一些简单总结： 1. Log分类 2. Log打印控制 1. Log分类 Android 打印的log分以下几类： 1. main log 2. sytem log 3. radio log 4. event log 5. kernel log 6. crash......
Android 日志输出（println、logv、logd、logi、logw、loge、logwtf）
卡尔特斯
09-27 8567
输出日志代码 // System.out：正常输出 System.out.println("onCreate：System.out"); // Log.println：即 Verbose，输出普通信息 Log.println(1, TAG, "onCreate: log.println"); // logv：即 Verbose，输出普通信息 Log.v(TAG, "onCreate: logv"); // logd：即 Debug，输出调试信息 Log.d(TAG, "onCreate: log...
Android log 系统
D_Music的博客
11-15 332
log文件分类简介 实时打印 的主要有： logcat main ， logcat radio ， logcat events ， tcpdump ，还有高通平台的还会有 QXDM 日志 状态信息 的有： adb shell cat /proc/kmsg ， adb shell dmesg ， adb shell dumpstate ， adb shell dump...
Android Log详解：从入门到精通
"Android中级教程之----Log图文详解" 在Android开发过程中，日志（Log）是一种非常重要的工具，用于记录程序运行过程中的各种信息，便于开发者追踪和调试问题。本教程将详细讲解Android中的日志系统，特别是如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值