Update to 0.12.0

Test: hello_rust prints to logcat
Test: TH
Change-Id: Ic8d880b8bbb499e12e3bb13f3401b25ae2d130c5

10 files changed, 178 insertions, 75 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..4952ca1
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,54 @@
+`android_logger` changelog
+==========================
+
+All user visible changes to this project will be documented in this file. This project uses [Semantic Versioning 2.0.0].
+
+
+
+
+## [0.12.0] · 2023-01-19
+[0.12.0]: /../../tree/v0.12.0
+
+[Diff](/../../compare/v0.11.3...v0.12.0)
+
+### Added
+
+- `Config::with_max_level()` method to filters logs via `log::LevelFilter`. ([#62])
+
+### Deprecated
+
+- `Config::with_min_level()` method accepting `log::Level`. ([#62])
+
+### Fixed
+
+- Incorrect logs level filtering. ([#62])
+
+[#62]: /../../pull/62
+
+
+
+
+## [0.11.3] · 2022-12-20
+[0.11.3]: /../../tree/v0.11.3
+
+[Diff](/../../compare/38186ece1056d90b8f75fd2a5eb5c860e0a1704e...v0.11.3)
+
+### Fixed 
+
+- Broken compilation on [Android] targets. ([#59], [#58])
+
+[#58]: /../../issues/58
+[#59]: /../../pull/59
+
+
+
+
+## Previous releases
+
+See [Git log](/../../commits/master?after=1a5a07ec6742f0069acc2be223c1bb3b6a9d15f8+0).
+
+
+
+
+[Android]: https://www.android.com
+[Semantic Versioning 2.0.0]: https://semver.org
diff --git a/Cargo.toml b/Cargo.toml
index 1638036..a9fd573 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,7 +11,7 @@
 
 [package]
 name = "android_logger"
-version = "0.11.1"
+version = "0.12.0"
 authors = ["The android_logger Developers"]
 description = """
 A logging implementation for `log` which hooks to android log output.
@@ -31,7 +31,7 @@ repository = "https://github.com/Nercury/android_logger-rs"
 version = "0.2"
 
 [dependencies.env_logger]
-version = "0.9"
+version = "0.10"
 default-features = false
 
 [dependencies.log]
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index 37c6496..ca1b723 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,6 +1,6 @@
 [package]
 name = "android_logger"
-version = "0.11.1"
+version = "0.12.0"
 authors = ["The android_logger Developers"]
 license = "MIT OR Apache-2.0"
 readme = "README.md"
@@ -25,7 +25,7 @@ version = "0.4"
 version = "0.2"
 
 [dependencies.env_logger]
-version = "0.9"
+version = "0.10"
 default-features = false
 
 [badges]
diff --git a/METADATA b/METADATA
index fba05dd..df2996f 100644
--- a/METADATA
+++ b/METADATA
@@ -1,5 +1,5 @@
 name: "android_logger"
-description: "A logging implementation for `log` which hooks to android log output."
+description: "()"
 third_party {
   url {
     type: HOMEPAGE
@@ -7,13 +7,14 @@ third_party {
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/android_logger/android_logger-0.11.1.crate"
+    value: "https://static.crates.io/crates/android_logger/android_logger-0.12.0.crate"
   }
-  version: "0.11.1"
+  version: "0.12.0"
+  # Dual-licensed, using the least restrictive per go/thirdpartylicenses#same.
   license_type: NOTICE
   last_upgrade_date {
-    year: 2022
-    month: 12
-    day: 5
+    year: 2023
+    month: 2
+    day: 2
   }
 }
diff --git a/OWNERS b/OWNERS
index 46fc303..45dc4dd 100644
--- a/OWNERS
+++ b/OWNERS
@@ -1 +1 @@
-include platform/prebuilts/rust:/OWNERS
+include platform/prebuilts/rust:master:/OWNERS
diff --git a/README.md b/README.md
index cc408d6..eec1eba 100644
--- a/README.md
+++ b/README.md
@@ -22,13 +22,13 @@ Example of initialization on activity creation, with log configuration:
 #[macro_use] extern crate log;
 extern crate android_logger;
 
-use log::Level;
+use log::LevelFilter;
 use android_logger::{Config,FilterBuilder};
 
 fn native_activity_create() {
     android_logger::init_once(
         Config::default()
-            .with_min_level(Level::Trace) // limit log level
+            .with_max_level(LevelFilter::Trace) // limit log level
             .with_tag("mytag") // logs will show under mytag tag
             .with_filter( // configure messages for specific crate
                 FilterBuilder::new()
@@ -47,12 +47,13 @@ To allow all logs, use the default configuration with min level Trace:
 #[macro_use] extern crate log;
 extern crate android_logger;
 
-use log::Level;
+use log::LevelFilter;
 use android_logger::Config;
 
 fn native_activity_create() {
     android_logger::init_once(
-        Config::default().with_min_level(Level::Trace));
+        Config::default().with_max_level(LevelFilter::Trace),
+    );
 }
 ```
 
diff --git a/patches/0001-Support-selecting-target-log-buffer.patch b/patches/0001-Support-selecting-target-log-buffer.patch
index 6731ea8..a9e11a4 100644
--- a/patches/0001-Support-selecting-target-log-buffer.patch
+++ b/patches/0001-Support-selecting-target-log-buffer.patch
@@ -1,7 +1,7 @@
-From eaa9cff3c99ed9e172c9d9fb369b70f84587f297 Mon Sep 17 00:00:00 2001
+From a41a079a81f381f2002917fb1c030690e0798f0c Mon Sep 17 00:00:00 2001
 From: Jeff Vander Stoep <jeffv@google.com>
-Date: Mon, 5 Dec 2022 12:38:24 +0100
-Subject: [PATCH 1/2] Support selecting target log buffer
+Date: Thu, 2 Feb 2023 13:33:47 +0100
+Subject: [PATCH] Support selecting target log buffer
 
 Android has several different log buffers. Previously, this library
 would only support logging to the "Main" log. Now, it logs to the
@@ -9,13 +9,13 @@ default log (which is Main for most processes), with the option to
 override which log buffer you send messages to in the config.
 
 Test: atest
-Change-Id: Id13515bb2cb042d1c31d4095444ae87cdcb13291
+Change-Id: I3cc393b989b8189675581ba6bf700f95715aa9e9
 ---
- src/lib.rs | 70 ++++++++++++++++++++++++++++++++++++++++++++----------
- 1 file changed, 57 insertions(+), 13 deletions(-)
+ src/lib.rs | 73 +++++++++++++++++++++++++++++++++++++++++++-----------
+ 1 file changed, 59 insertions(+), 14 deletions(-)
 
 diff --git a/src/lib.rs b/src/lib.rs
-index ef2027a..4bcce0c 100644
+index 0446fad..9ec7f0d 100644
 --- a/src/lib.rs
 +++ b/src/lib.rs
 @@ -85,21 +85,49 @@ pub use env_logger::fmt::Formatter;
@@ -75,7 +75,7 @@ index ef2027a..4bcce0c 100644
  
  /// Underlying android logger backend
  pub struct AndroidLogger {
-@@ -160,7 +188,7 @@ impl Log for AndroidLogger {
+@@ -172,7 +200,7 @@ impl Log for AndroidLogger {
  
          // message must not exceed LOGGING_MSG_MAX_LEN
          // therefore split log message into multiple log calls
@@ -84,15 +84,15 @@ index ef2027a..4bcce0c 100644
  
          // If a custom tag is used, add the module path to the message.
          // Use PlatformLogWriter to output chunks if they exceed max size.
-@@ -203,6 +231,7 @@ impl AndroidLogger {
+@@ -215,6 +243,7 @@ impl AndroidLogger {
  #[derive(Default)]
  pub struct Config {
-     log_level: Option<Level>,
+     log_level: Option<LevelFilter>,
 +    log_id: Option<LogId>,
      filter: Option<env_logger::filter::Filter>,
      tag: Option<CString>,
      custom_format: Option<FormatFn>,
-@@ -218,6 +247,15 @@ impl Config {
+@@ -241,6 +270,15 @@ impl Config {
          self
      }
  
@@ -108,7 +108,7 @@ index ef2027a..4bcce0c 100644
      fn filter_matches(&self, record: &Record) -> bool {
          if let Some(ref filter) = self.filter {
              filter.matches(record)
-@@ -259,6 +297,8 @@ pub struct PlatformLogWriter<'a> {
+@@ -282,6 +320,8 @@ pub struct PlatformLogWriter<'a> {
      priority: LogPriority,
      #[cfg(not(target_os = "android"))]
      priority: Level,
@@ -117,24 +117,31 @@ index ef2027a..4bcce0c 100644
      len: usize,
      last_newline_index: usize,
      tag: &'a CStr,
-@@ -267,7 +307,7 @@ pub struct PlatformLogWriter<'a> {
+@@ -290,10 +330,11 @@ pub struct PlatformLogWriter<'a> {
  
  impl<'a> PlatformLogWriter<'a> {
      #[cfg(target_os = "android")]
--    pub fn new(level: Level, tag: &CStr) -> PlatformLogWriter {
-+    pub fn new(log_id: Option<LogId>, level: Level, tag: &CStr) -> PlatformLogWriter {
+-    pub fn new_with_priority(priority: log_ffi::LogPriority, tag: &CStr) -> PlatformLogWriter {
++    pub fn new_with_priority(log_id: Option<LogId>, priority: log_ffi::LogPriority, tag: &CStr) -> PlatformLogWriter {
          #[allow(deprecated)] // created an issue #35 for this
          PlatformLogWriter {
-             priority: match level {
-@@ -277,6 +317,7 @@ impl<'a> PlatformLogWriter<'a> {
-                 Level::Error => LogPriority::ERROR,
-                 Level::Trace => LogPriority::VERBOSE,
-             },
+             priority,
 +            log_id: LogId::to_native(log_id),
              len: 0,
              last_newline_index: 0,
              tag,
-@@ -285,10 +326,11 @@ impl<'a> PlatformLogWriter<'a> {
+@@ -302,8 +343,9 @@ impl<'a> PlatformLogWriter<'a> {
+     }
+ 
+     #[cfg(target_os = "android")]
+-    pub fn new(level: Level, tag: &CStr) -> PlatformLogWriter {
++    pub fn new(log_id: Option<LogId>, level: Level, tag: &CStr) -> PlatformLogWriter {
+         Self::new_with_priority(
++            log_id,
+             match level {
+                 Level::Warn => LogPriority::WARN,
+                 Level::Info => LogPriority::INFO,
+@@ -316,10 +358,11 @@ impl<'a> PlatformLogWriter<'a> {
      }
  
      #[cfg(not(target_os = "android"))]
@@ -147,7 +154,7 @@ index ef2027a..4bcce0c 100644
              len: 0,
              last_newline_index: 0,
              tag,
-@@ -345,7 +387,7 @@ impl<'a> PlatformLogWriter<'a> {
+@@ -376,7 +419,7 @@ impl<'a> PlatformLogWriter<'a> {
          });
  
          let msg: &CStr = unsafe { CStr::from_ptr(self.buffer.as_ptr().cast()) };
@@ -156,19 +163,19 @@ index ef2027a..4bcce0c 100644
  
          unsafe { *self.buffer.get_unchecked_mut(len) = last_byte };
      }
-@@ -450,9 +492,11 @@ mod tests {
+@@ -481,9 +524,11 @@ mod tests {
          // Filter is checked in config_filter_match below.
          let config = Config::default()
-             .with_min_level(Level::Trace)
+             .with_max_level(LevelFilter::Trace)
 +            .with_log_id(LogId::System)
              .with_tag("my_app");
  
-         assert_eq!(config.log_level, Some(Level::Trace));
+         assert_eq!(config.log_level, Some(LevelFilter::Trace));
 +        assert_eq!(config.log_id, Some(LogId::System));
          assert_eq!(config.tag, Some(CString::new("my_app").unwrap()));
      }
  
-@@ -523,7 +567,7 @@ mod tests {
+@@ -556,7 +601,7 @@ mod tests {
      fn platform_log_writer_init_values() {
          let tag = CStr::from_bytes_with_nul(b"tag\0").unwrap();
  
@@ -177,7 +184,7 @@ index ef2027a..4bcce0c 100644
  
          assert_eq!(writer.tag, tag);
          // Android uses LogPriority instead, which doesn't implement equality checks
-@@ -628,7 +672,7 @@ mod tests {
+@@ -661,7 +706,7 @@ mod tests {
      }
  
      fn get_tag_writer() -> PlatformLogWriter<'static> {
@@ -187,5 +194,5 @@ index ef2027a..4bcce0c 100644
  
      unsafe fn assume_init_slice<T>(slice: &[MaybeUninit<T>]) -> &[T] {
 -- 
-2.39.0.rc0.267.gcb52ba06e7-goog
+2.39.1.456.gfc5497dd1b-goog
 
diff --git a/src/lib.rs b/src/lib.rs
index 59f942b..c22f07e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -13,13 +13,13 @@
 //! #[macro_use] extern crate log;
 //! extern crate android_logger;
 //!
-//! use log::Level;
+//! use log::LevelFilter;
 //! use android_logger::Config;
 //!
 //! /// Android code may not have obvious "main", this is just an example.
 //! fn main() {
 //!     android_logger::init_once(
-//!         Config::default().with_min_level(Level::Trace),
+//!         Config::default().with_max_level(LevelFilter::Trace),
 //!     );
 //!
 //!     debug!("this is a debug {}", "message");
@@ -36,13 +36,13 @@
 //! #[macro_use] extern crate log;
 //! extern crate android_logger;
 //!
-//! use log::Level;
+//! use log::LevelFilter;
 //! use android_logger::{Config,FilterBuilder};
 //!
 //! fn main() {
 //!     android_logger::init_once(
 //!         Config::default()
-//!             .with_min_level(Level::Trace)
+//!             .with_max_level(LevelFilter::Trace)
 //!             .with_tag("mytag")
 //!             .with_filter(FilterBuilder::new().parse("debug,hello::crate=trace").build()),
 //!     );
@@ -58,7 +58,7 @@
 //!
 //! android_logger::init_once(
 //!     Config::default()
-//!         .with_min_level(log::Level::Trace)
+//!         .with_max_level(log::LevelFilter::Trace)
 //!         .format(|f, record| write!(f, "my_app: {}", record.args()))
 //! )
 //! ```
@@ -72,7 +72,7 @@ extern crate log;
 
 extern crate env_logger;
 
-use log::{Level, Log, Metadata, Record};
+use log::{Level, LevelFilter, Log, Metadata, Record};
 #[cfg(target_os = "android")]
 use log_ffi::LogPriority;
 use std::ffi::{CStr, CString};
@@ -135,6 +135,10 @@ impl AndroidLogger {
             config: OnceCell::from(config),
         }
     }
+
+    fn config(&self) -> &Config {
+        self.config.get_or_init(Config::default)
+    }
 }
 
 static ANDROID_LOGGER: OnceCell<AndroidLogger> = OnceCell::new();
@@ -152,13 +156,21 @@ impl Default for AndroidLogger {
 }
 
 impl Log for AndroidLogger {
-    fn enabled(&self, _: &Metadata) -> bool {
-        true
+    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)
     }
 
     fn log(&self, record: &Record) {
-        let config = self.config.get_or_init(Config::default);
+        let config = self.config();
 
+        if !self.enabled(record.metadata()) {
+            return;
+        }
+
+        // this also checks the level, but only if a filter was
+        // installed.
         if !config.filter_matches(record) {
             return;
         }
@@ -224,7 +236,7 @@ impl AndroidLogger {
 /// Filter for android logger.
 #[derive(Default)]
 pub struct Config {
-    log_level: Option<Level>,
+    log_level: Option<LevelFilter>,
     log_id: Option<LogId>,
     filter: Option<env_logger::filter::Filter>,
     tag: Option<CString>,
@@ -232,11 +244,22 @@ pub struct Config {
 }
 
 impl Config {
-    /// Change the minimum log level.
+    // TODO: Remove on 0.13 version release.
+    /// **DEPRECATED**, use [`Config::with_max_level()`] instead.
+    #[deprecated(note = "use `.with_max_level()` instead")]
+    pub fn with_min_level(self, level: Level) -> Self {
+        self.with_max_level(level.to_level_filter())
+    }
+
+    /// Changes the maximum log level.
     ///
-    /// All values above the set level are logged. For example, if
-    /// `Warn` is set, the `Error` is logged too, but `Info` isn't.
-    pub fn with_min_level(mut self, level: Level) -> Self {
+    /// Note, that `Trace` is the maximum level, because it provides the
+    /// maximum amount of detail in the emitted logs.
+    ///
+    /// If `Off` level is provided, then nothing is logged at all.
+    ///
+    /// [`log::max_level()`] is considered as the default level.
+    pub fn with_max_level(mut self, level: LevelFilter) -> Self {
         self.log_level = Some(level);
         self
     }
@@ -273,7 +296,7 @@ impl Config {
     /// # use android_logger::Config;
     /// android_logger::init_once(
     ///     Config::default()
-    ///         .with_min_level(log::Level::Trace)
+    ///         .with_max_level(log::LevelFilter::Trace)
     ///         .format(|f, record| write!(f, "my_app: {}", record.args()))
     /// )
     /// ```
@@ -301,22 +324,31 @@ pub struct PlatformLogWriter<'a> {
 
 impl<'a> PlatformLogWriter<'a> {
     #[cfg(target_os = "android")]
-    pub fn new(log_id: Option<LogId>, level: Level, tag: &CStr) -> PlatformLogWriter {
+    pub fn new_with_priority(log_id: Option<LogId>, priority: log_ffi::LogPriority, tag: &CStr) -> PlatformLogWriter {
         #[allow(deprecated)] // created an issue #35 for this
         PlatformLogWriter {
-            priority: match level {
+            priority,
+            log_id: LogId::to_native(log_id),
+            len: 0,
+            last_newline_index: 0,
+            tag,
+            buffer: uninit_array(),
+        }
+    }
+
+    #[cfg(target_os = "android")]
+    pub fn new(log_id: Option<LogId>, level: Level, tag: &CStr) -> PlatformLogWriter {
+        Self::new_with_priority(
+            log_id,
+            match level {
                 Level::Warn => LogPriority::WARN,
                 Level::Info => LogPriority::INFO,
                 Level::Debug => LogPriority::DEBUG,
                 Level::Error => LogPriority::ERROR,
                 Level::Trace => LogPriority::VERBOSE,
             },
-            log_id: LogId::to_native(log_id),
-            len: 0,
-            last_newline_index: 0,
             tag,
-            buffer: uninit_array(),
-        }
+        )
     }
 
     #[cfg(not(target_os = "android"))]
@@ -465,7 +497,7 @@ pub fn init_once(config: Config) {
     if let Err(err) = log::set_logger(logger) {
         debug!("android_logger: log::set_logger failed: {}", err);
     } else if let Some(level) = log_level {
-        log::set_max_level(level.to_level_filter());
+        log::set_max_level(level);
     }
 }
 
@@ -485,11 +517,11 @@ mod tests {
     fn check_config_values() {
         // Filter is checked in config_filter_match below.
         let config = Config::default()
-            .with_min_level(Level::Trace)
+            .with_max_level(LevelFilter::Trace)
             .with_log_id(LogId::System)
             .with_tag("my_app");
 
-        assert_eq!(config.log_level, Some(Level::Trace));
+        assert_eq!(config.log_level, Some(LevelFilter::Trace));
         assert_eq!(config.log_id, Some(LogId::System));
         assert_eq!(config.tag, Some(CString::new("my_app").unwrap()));
     }
@@ -498,7 +530,7 @@ mod tests {
     fn log_calls_formatter() {
         static FORMAT_FN_WAS_CALLED: AtomicBool = AtomicBool::new(false);
         let config = Config::default()
-            .with_min_level(Level::Info)
+            .with_max_level(LevelFilter::Info)
             .format(|_, _| {
                 FORMAT_FN_WAS_CALLED.store(true, Ordering::SeqCst);
                 Ok(())
@@ -511,10 +543,12 @@ mod tests {
     }
 
     #[test]
-    fn logger_always_enabled() {
-        let logger = AndroidLogger::new(Config::default());
+    fn logger_enabled_threshold() {
+        let logger = AndroidLogger::new(Config::default().with_max_level(LevelFilter::Info));
 
-        assert!(logger.enabled(&log::MetadataBuilder::new().build()));
+        assert!(logger.enabled(&log::MetadataBuilder::new().level(Level::Warn).build()));
+        assert!(logger.enabled(&log::MetadataBuilder::new().level(Level::Info).build()));
+        assert!(!logger.enabled(&log::MetadataBuilder::new().level(Level::Debug).build()));
     }
 
     // Test whether the filter gets called correctly. Not meant to be exhaustive for all filter
diff --git a/tests/config_log_level.rs b/tests/config_log_level.rs
index 7904371..864b229 100644
--- a/tests/config_log_level.rs
+++ b/tests/config_log_level.rs
@@ -3,7 +3,9 @@ extern crate log;
 
 #[test]
 fn config_log_level() {
-    android_logger::init_once(android_logger::Config::default().with_min_level(log::Level::Trace));
+    android_logger::init_once(
+        android_logger::Config::default().with_max_level(log::LevelFilter::Trace),
+    );
 
     assert_eq!(log::max_level(), log::LevelFilter::Trace);
 }
diff --git a/tests/multiple_init.rs b/tests/multiple_init.rs
index b46f48e..26f815d 100644
--- a/tests/multiple_init.rs
+++ b/tests/multiple_init.rs
@@ -3,10 +3,14 @@ extern crate log;
 
 #[test]
 fn multiple_init() {
-    android_logger::init_once(android_logger::Config::default().with_min_level(log::Level::Trace));
+    android_logger::init_once(
+        android_logger::Config::default().with_max_level(log::LevelFilter::Trace),
+    );
 
     // Second initialization should be silently ignored
-    android_logger::init_once(android_logger::Config::default().with_min_level(log::Level::Error));
+    android_logger::init_once(
+        android_logger::Config::default().with_max_level(log::LevelFilter::Error),
+    );
 
     assert_eq!(log::max_level(), log::LevelFilter::Trace);
 }