Add some more code from pidgin-icq

src/logging.rs

@@ -0,0 +1,121 @@
+// This is a copy of https://github.com/Flared/purple-icq/blob/master/src/logging.rs
+
+//use crate::messages::{FdSender, SystemMessage};
+use crate::purple;
+use std::cell::RefCell;
+use std::sync::Mutex;
+
+std::thread_local! {
+    pub static LOGGER: RefCell<Option<Box<dyn log::Log>>> = RefCell::new(None);
+}
+
+lazy_static::lazy_static! {
+    static ref PURPLE_BUFFER: Mutex<Vec<(String, log::Level, String)>> = Default::default();
+}
+
+static TLS_LOGGER: ThreadLocalLogger = ThreadLocalLogger;
+
+pub struct ThreadLocalLogger;
+
+impl log::Log for ThreadLocalLogger {
+    fn enabled(&self, _metadata: &log::Metadata) -> bool {
+        true
+    }
+
+    fn log(&self, record: &log::Record) {
+        LOGGER.with(|cell| {
+            if let Some(ref logger) = cell.borrow().as_ref() {
+                logger.log(record);
+            }
+        })
+    }
+
+    fn flush(&self) {
+        LOGGER.with(|cell| {
+            if let Some(ref logger) = cell.borrow().as_ref() {
+                logger.flush()
+            }
+        })
+    }
+}
+
+pub struct PurpleDebugLogger;
+
+impl log::Log for PurpleDebugLogger {
+    fn enabled(&self, metadata: &log::Metadata) -> bool {
+        metadata.level() < log::Level::Debug
+    }
+
+    fn log(&self, record: &log::Record) {
+        let purple_level = match record.level() {
+            log::Level::Error => purple::PurpleDebugLevel::PURPLE_DEBUG_ERROR,
+            log::Level::Warn => purple::PurpleDebugLevel::PURPLE_DEBUG_WARNING,
+            log::Level::Info => purple::PurpleDebugLevel::PURPLE_DEBUG_INFO,
+            _ => purple::PurpleDebugLevel::PURPLE_DEBUG_MISC,
+        };
+
+        let target = if !record.target().is_empty() {
+            record.target()
+        } else {
+            record.module_path().unwrap_or_default()
+        };
+        let line = format!("[{}] {}\n", target, record.args());
+        purple::debug(purple_level, "", &line);
+    }
+
+    fn flush(&self) {
+        let buffer = {
+            match PURPLE_BUFFER.lock() {
+                Ok(mut buffer) => buffer.split_off(0),
+                Err(_) => return,
+            }
+        };
+        for (target, level, message) in buffer {
+            log::log!(target: &target, level, "{}", message);
+        }
+    }
+}
+
+/*
+pub struct RemoteLogger(pub FdSender<SystemMessage>);
+
+impl log::Log for RemoteLogger {
+    fn enabled(&self, metadata: &log::Metadata) -> bool {
+        metadata.level() < log::Level::Debug
+    }
+
+    fn log(&self, record: &log::Record) {
+        let target = if !record.target().is_empty() {
+            record.target()
+        } else {
+            record.module_path().unwrap_or_default()
+        };
+
+        if let Ok(mut buffer) = PURPLE_BUFFER.lock() {
+            buffer.push((target.into(), record.level(), record.args().to_string()));
+        }
+    }
+
+    fn flush(&self) {
+        self.0.clone().try_send(SystemMessage::FlushLogs);
+    }
+}
+*/
+pub fn init(level: log::LevelFilter) -> Result<(), log::SetLoggerError> {
+    log::set_logger(&TLS_LOGGER).map(|()| log::set_max_level(level))
+}
+
+pub fn set_thread_logger<T>(logger: T)
+where
+    T: log::Log + 'static,
+{
+    LOGGER.with(|cell| *cell.borrow_mut() = Some(Box::new(logger)))
+}
+
+pub fn flush() {
+    LOGGER.with(|cell| {
+        if let Some(ref logger) = cell.borrow().as_ref() {
+            logger.flush();
+        }
+    })
+}