notedeck

android.rs (4476B)

---

 //#[cfg(target_os = "android")]
 //use egui_android::run_android;
 
 use egui_winit::winit::platform::android::activity::AndroidApp;
 
 use crate::chrome::Chrome;
 use notedeck::Notedeck;
 
 #[no_mangle]
 #[tokio::main]
 pub async fn android_main(android_app: AndroidApp) {
     //use tracing_logcat::{LogcatMakeWriter, LogcatTag};
     use tracing_subscriber::{prelude::*, EnvFilter};
 
     std::env::set_var("RUST_BACKTRACE", "full");
     //std::env::set_var("DAVE_MODEL", "hhao/qwen2.5-coder-tools:latest");
     std::env::set_var(
         "RUST_LOG",
         "egui=debug,egui-winit=debug,winit=debug,notedeck=debug,notedeck_columns=debug,notedeck_chrome=debug,enostr=debug,android_activity=debug",
     );
 
     //std::env::set_var(
     //    "RUST_LOG",
     //    "enostr=debug,notedeck_columns=debug,notedeck_chrome=debug",
     //);
 
     //let writer =
     //LogcatMakeWriter::new(LogcatTag::Target).expect("Failed to initialize logcat writer");
 
     let fmt_layer = tracing_subscriber::fmt::layer()
         .with_level(false)
         .with_target(false)
         .without_time();
 
     let filter_layer = EnvFilter::try_from_default_env()
         .or_else(|_| EnvFilter::try_new("info"))
         .unwrap();
 
     tracing_subscriber::registry()
         .with(filter_layer)
         .with(fmt_layer)
         .init();
 
     let _ = android_keyring::set_android_keyring_credential_builder();
 
     let path = android_app.internal_data_path().expect("data path");
     let mut options = eframe::NativeOptions {
         depth_buffer: 24,
         ..eframe::NativeOptions::default()
     };
 
     options.renderer = eframe::Renderer::Wgpu;
     // Clone `app` to use it both in the closure and later in the function
     //let app_clone_for_event_loop = app.clone();
     //options.event_loop_builder = Some(Box::new(move |builder| {
     //    builder.with_android_app(app_clone_for_event_loop);
     //}));
 
     options.android_app = Some(android_app.clone());
 
     let app_args = get_app_args();
 
     let _res = eframe::run_native(
         "Damus Notedeck",
         options,
         Box::new(move |cc| {
             let ctx = &cc.egui_ctx;
 
             let mut notedeck = Notedeck::new(ctx, path, &app_args);
             notedeck.set_android_context(android_app);
             notedeck.setup(ctx);
             let chrome = Chrome::new_with_apps(cc, &app_args, &mut notedeck)?;
             notedeck.set_app(chrome);
 
             Ok(Box::new(notedeck))
         }),
     );
 }
 /*
 Read args from a config file:
 - allows use of more interesting args w/o risk of checking them in by mistake
 - allows use of different args w/o rebuilding the app
 - uses compiled in defaults if config file missing or broken
 
 Example android-config.json:
 ```
 {
   "args": [
     "argv0-placeholder",
     "--npub",
     "npub1h50pnxqw9jg7dhr906fvy4mze2yzawf895jhnc3p7qmljdugm6gsrurqev",
     "-c",
     "contacts",
     "-c",
     "notifications"
   ]
 }
 ```
 
 Install/update android-config.json with:
 ```
 adb push android-config.json /sdcard/Android/data/com.damus.notedeck/files/android-config.json
 ```
 
 Using internal storage would be better but it seems hard to get the config file onto
 the device ...
 */
 
 fn get_app_args() -> Vec<String> {
     vec!["argv0-placeholder".to_string()]
     /*
     use serde_json::value;
     use std::fs;
     use std::path::PathBuf;
 
     let external_data_path: pathbuf = app
         .external_data_path()
         .expect("external data path")
         .to_path_buf();
     let config_file = external_data_path.join("android-config.json");
 
     let initial_user = hex::encode(notedeck::FALLBACK_PUBKEY().bytes());
     let default_args = vec![
         "argv0-placeholder",
         "--no-tmp-columns",
         "--pub",
         &initial_user,
         "-c",
         "contacts",
         "-c",
         "notifications",
     ]
     .into_iter()
     .map(|s| s.to_string())
     .collect();
 
     if config_file.exists() {
         if let Ok(config_contents) = fs::read_to_string(config_file) {
             if let Ok(json) = serde_json::from_str::<Value>(&config_contents) {
                 if let Some(args_array) = json.get("args").and_then(|v| v.as_array()) {
                     let config_args = args_array
                         .iter()
                         .filter_map(|v| v.as_str().map(String::from))
                         .collect();
 
                     return config_args;
                 }
             }
         }
     }
 
     default_args // Return the default args if config is missing or invalid
     */
 }