Use __android_log_is_loggable in AndroidLogger::enabled

Android's C logging API determines the effective log level based on a
combination [1] of a global variable, system-wide properties [2], and
call-specific default. log + android_logger crates add another layer of
log filtering on top of that, independent from the C API.

```
        .-----.
        | app |
        '-----'
           |
           v
     .-----------.   filter by STATIC_MAX_LEVEL [3] +
     | log crate | - MAX_LOG_LEVEL_FILTER [4],
     '-----------'   overrideable via log::set_max_level
           |
           v
.----------------------.
| android_logger crate | - filter by Config::max_level [5]
'----------------------'
           |
           v
       .--------.
       | liblog | - filter by global state or system-wide properties [2]
       '--------'
```

The result is that in mixed C/C++ + Rust applications, logs originating
from Rust use the least verbose level configured, which sometimes
results in unexpected loss of logs.

In addition, adjusting the log level globally via system properties,
very useful in work on the AOSP itself, currently works only up to the
level android_logger defaults to.

This change makes AndroidLogger completely delegate log filtering to the
underlying liblog when Config::max_level is unset by using
__android_log_is_loggable.

Setting Config::max_level, or calling log::set_max_level still keep the
existing behavior of filtering the logs before they reach liblog, but
the default is now to have the log level consistent between Rust and
C/C++ logs.

It also removes one TODO from the code :)

Tested by:
- running a test app that uses Rust logs of all levels on a rooted
  device, using both Android's liblog C API and android_logger ones
- adjusting the log.tag system property [2] via adb shell setprop
- verifying the message filtering changes according to log.tag changes
  consistently for logs from both languages

[1] https://cs.android.com/android/platform/superproject/main/+/main:system/logging/liblog/properties.cpp;l=243;drc=b74a506c1b69f5b295a8cdfd7e2da3b16db15934
[2] https://cs.android.com/android/platform/superproject/main/+/main:system/logging/logd/README.property;l=45;drc=99c545d3098018a544cb292e1501daca694bee0f
[3] https://github.com/rust-lang/log/blob/0551261bb4588b7f8afc8be05640347c97b67e10/src/lib.rs#L1536
[4] https://github.com/rust-lang/log/blob/0551261bb4588b7f8afc8be05640347c97b67e10/src/lib.rs#L469
[5] https://github.com/rust-mobile/android_logger-rs/blob/d51b7ffdacf20fb09fd36a6b309b50240ef50728/src/lib.rs#L198

Author: Marcin Radomski

src/lib.rs

@@ -159,6 +159,56 @@ fn android_log(
 #[cfg(not(target_os = "android"))]
 fn android_log(_buf_id: Option<LogId>, _priority: Level, _tag: &CStr, _msg: &CStr) {}
 
+/// Outputs log to Android system.
+#[cfg(target_os = "android")]
+fn android_is_loggable_len(
+    prio: log_ffi::LogPriority,
+    tag: &str,
+    default_prio: log_ffi::LogPriority,
+) -> bool {
+    // SAFETY: tag points to a valid string tag.len() bytes long.
+    unsafe {
+        log_ffi::__android_log_is_loggable_len(
+            prio as log_ffi::c_int,
+            tag.as_ptr() as *const log_ffi::c_char,
+            tag.len() as log_ffi::c_size_t,
+            default_prio as log_ffi::c_int,
+        ) != 0
+    }
+}
+
+#[cfg(target_os = "android")]
+fn android_log_priority_from_level(level: Level) -> LogPriority {
+    match level {
+        Level::Warn => LogPriority::WARN,
+        Level::Info => LogPriority::INFO,
+        Level::Debug => LogPriority::DEBUG,
+        Level::Error => LogPriority::ERROR,
+        Level::Trace => LogPriority::VERBOSE,
+    }
+}
+
+#[cfg(target_os = "android")]
+fn should_log(tag: &str, level: Level, logger_config: &Config) -> bool {
+    let prio = android_log_priority_from_level(level);
+    // Priority to use in case no system-wide or process-wide overrides are set.
+    let default_prio = match logger_config.log_level {
+        Some(level_filter) => match level_filter.to_level() {
+            Some(level) => android_log_priority_from_level(level),
+            // LevelFilter::to_level() returns None only for LevelFilter::Off
+            None => log_ffi::LogPriority::SILENT,
+        },
+        None => log_ffi::LogPriority::INFO,
+    };
+    android_is_loggable_len(prio, tag, default_prio)
+}
+
+/// Dummy placeholder for tests.
+#[cfg(not(target_os = "android"))]
+fn should_log(_tag: &str, level: Level, logger_config: &Config) -> bool {
+    level <= logger_config.log_level.unwrap_or(LevelFilter::Trace)
+}
+
 /// Underlying android logger backend
 pub struct AndroidLogger {
     config: OnceLock<Config>,
@@ -193,9 +243,7 @@ impl Default for AndroidLogger {
 
 impl Log for AndroidLogger {
     fn enabled(&self, metadata: &Metadata) -> bool {
-        let config = self.config();
-        // todo: consider __android_log_is_loggable.
-        metadata.level() <= config.log_level.unwrap_or_else(log::max_level)
+        should_log(metadata.target(), metadata.level(), self.config())
     }
 
     fn log(&self, record: &Record) {
@@ -375,17 +423,7 @@ impl<'a> PlatformLogWriter<'a> {
 
     #[cfg(target_os = "android")]
     pub fn new(buf_id: Option<LogId>, level: Level, tag: &CStr) -> PlatformLogWriter<'_> {
-        PlatformLogWriter::new_with_priority(
-            buf_id,
-            match level {
-                Level::Warn => LogPriority::WARN,
-                Level::Info => LogPriority::INFO,
-                Level::Debug => LogPriority::DEBUG,
-                Level::Error => LogPriority::ERROR,
-                Level::Trace => LogPriority::VERBOSE,
-            },
-            tag,
-        )
+        PlatformLogWriter::new_with_priority(buf_id, android_log_priority_from_level(level), tag)
     }
 
     #[cfg(not(target_os = "android"))]
@@ -535,6 +573,9 @@ pub fn init_once(config: Config) {
         log::debug!("android_logger: log::set_logger failed: {}", err);
     } else if let Some(level) = log_level {
         log::set_max_level(level);
+    } else {
+        // Do not filter logs at log crate level. Delegate all filtering to underlying liblog.
+        log::set_max_level(LevelFilter::Trace);
     }
 }
 

tests/default_init.rs

@@ -5,6 +5,6 @@ extern crate log;
 fn default_init() {
     android_logger::init_once(Default::default());
 
-    // android_logger has default log level "off"
-    assert_eq!(log::max_level(), log::LevelFilter::Off);
+    // android_logger has default log level "trace"
+    assert_eq!(log::max_level(), log::LevelFilter::Trace);
 }