Using Flutter Rust bridge in 2023

pub fn square(n: u32) -> u32 {
    n * n
}

pub struct Person {
    pub name: String,
    pub age: u16,
}

pub fn save_person(p: Person) -> Result<Person> {
    Ok(Person {
        name: p.name,
        age: p.age + 1
    })
}

pub struct Person {
    pub name: String,
    pub age: u16,
}

pub fn save_person(p: Person) -> Result<Person> {
    // We need to convert Person into othercrate::Person.
    let p2: othercrate::Person = p.into();
    // Now we call a method from an external crate.
    let saved: othercrate::Person = othercrate::save_person(p)?;
    // We need to convert othercrate::Person into Person.
    Ok(saved.into())
}

impl Into<othercrate::Person> for Person {
    fn into(self) -> othercrate::Person {
        othercrate::Person {
            name: self.name,
            age: self.age,
        }
    }
}

impl From<othercrate::Person> for Person {
    fn from(p: othercrate::Person) -> Self {
        Self {
            name: p.name,
            age: p.age,
        }
    }
}

/// Important to re-export Person import.
pub use othercrate::Person;

#[frb(mirror(Person))]
pub struct _Person {
    pub name: String,
    pub age: u16,
}

// Conversions are no longer needed
pub fn save_person(p: Person) -> Result<Person> {
    let saved = othercrate::save_person(p)?;
    Ok(saved)
}

use std::io::Write;

use anyhow::{bail, Result};
use flutter_rust_bridge::StreamSink;
use tracing_subscriber::{fmt::MakeWriter, EnvFilter};

/// Wrapper so that we can implement required Write and MakeWriter traits.
struct LogSink {
    sink: StreamSink<String>,
}

/// Write log lines to our Flutter's sink.
impl<'a> Write for &'a LogSink {
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        let line = String::from_utf8_lossy(buf).to_string();
        self.sink.add(line);
        Ok(buf.len())
    }

    fn flush(&mut self) -> std::io::Result<()> {
        Ok(())
    }
}

impl<'a> MakeWriter<'a> for LogSink {
    type Writer = &'a LogSink;

    fn make_writer(&'a self) -> Self::Writer {
        self
    }
}

/// Public method that Dart will call into.
pub fn setup_logs(sink: StreamSink<String>) -> Result<()> {
    let log_sink = LogSink { sink };

    // Subscribe to tracing events and publish them to the UI
    if let Err(err) = tracing_subscriber::fmt()
        .with_max_level(tracing::Level::TRACE)
        .with_env_filter(EnvFilter::new("info,bolik_sdk=trace"))
        .with_writer(log_sink)
        .try_init()
    {
        bail!("{}", err);
    }
    Ok(())
}

use rusqlite::{params, Connection};

/// Keep a global database reference
static DB: Mutex<Option<Connection>> = Mutex::new(None);

/// First we need to initialize our db connection
pub fn connect() -> Result<()> {
    let conn = Connection::open_in_memory()?;

    conn.execute(
        "CREATE TABLE persons (
            id    INTEGER PRIMARY KEY,
            name  TEXT NOT NULL,
            age   INTEGER
        )",
        [],
    )?;

    *DB.lock().expect("Set db") = Some(conn);
    Ok(())
}


pub struct Person {
    pub id: i32,
    pub name: String,
    pub age: u16,
}

/// Now we can use established connection to save people
pub fn save_person(name: String, age: u16) -> Result<Person> {
    // Mutex boilerplate...
    let db_guard = DB.lock().expect("Get db");
    let conn = db_guard.as_mut().expect("Db present");

    conn.execute(
        "INSERT INTO persons (name, age) VALUES (?1, ?2)",
        params![&name, &age],
    )?;
    Ok(Person {
        id: conn.last_insert_rowid() as i32,
        name,
        age,
    })
}

use tokio::runtime::Runtime;

static RUNTIME: Mutex<Option<Runtime>> = Mutex::new(None);

pub fn start() -> Result<()> {
    // Initialize a runtime
    let rt = tokio::runtime::Builder::new_multi_thread()
        .worker_threads(2)
        .enable_all()
        .thread_name("bolik-timeline-client")
        .build()?;
        
    // Here we can spawn background tasks to be run on the runtime.

    // Store runtime in a global variable
    *RUNTIME.lock().expect("Set runtime") = Some(rt);
    Ok(())
}

pub struct Person {
    pub id: i32,
    pub name: String,
    pub age: u16,
}

pub fn save_person(name: String, age: u16) -> Result<Person> {
    // We are calling async methods from a thread that is not managed by
    // Tokio runtime. For this to work we need to enter the handle first.
    // Ref: https://docs.rs/tokio/latest/tokio/runtime/struct.Handle.html#method.current
    let mut rt_guard = RUNTIME.lock().expect("Get runtime");
    let rt = rt_guard.as_mut().expect("Runtime present");
    let _guard = rt.enter();

    // Let's pretend that we have `othercrate::save_person` function that returns a `Future<String>`.
    let id = rt.block_on(othercrate::save_person(name, age))?;
    Ok(Person {
        id,
        name,
        age,
    })
}