Merge pull request #477 from m1sterc001guy/version_fix

feat: Query Fedimint Observer

Author: m1sterc001guy

android/app/src/main/kotlin/app/ecash/MainActivity.kt

@@ -14,6 +14,19 @@ import io.flutter.plugin.common.MethodChannel
 
 class MainActivity : FlutterActivity() {
 
+    companion object {
+        init {
+            // Load the Rust library through the JVM so its `JNI_OnLoad` runs and
+            // initializes `ndk_context`. Native networking crates used by
+            // fedimint's iroh transport (hickory-resolver for DNS, netdev) read
+            // the Android system network config through `ndk_context`; without it
+            // the first federation DNS lookup panics with
+            // "android context was not initialized". Flutter later dlopen()s the
+            // same .so from Dart, which just reuses this already-loaded library.
+            System.loadLibrary("ecashapp")
+        }
+    }
+
     private val hceComponent by lazy {
         ComponentName(this, EcashHceService::class.java)
     }

rust/ecashapp/Cargo.lock

@@ -52,6 +52,16 @@ serde_json = "1.0.140"
 thiserror = "1.0"
 tokio = "1.45.1"
 
+# Android-only. `iroh` (fedimint's guardian transport) pulls in native
+# networking crates — `hickory-resolver` (DNS) and `netdev` — that, since the
+# hickory 0.26 / netdev 0.44 upgrade, read the device network config through
+# `ndk_context`. Flutter loads our .so via Dart `dlopen`, which never runs
+# `JNI_OnLoad`, so nothing initializes that context. We do it ourselves in
+# src/android_init.rs using these crates. See that file for the full story.
+[target.'cfg(target_os = "android")'.dependencies]
+jni = "0.21"
+ndk-context = "0.1"
+
 [profile.dev.package]
 librocksdb-sys = { opt-level = 3 }
 secp256k1 = { opt-level = 3}

rust/ecashapp/Cargo.toml

@@ -0,0 +1,76 @@
+//! Android-only JNI bootstrap.
+//!
+//! Since the hickory-resolver 0.26 / netdev 0.44 upgrade (pulled in transitively
+//! by `iroh`, fedimint's guardian transport), the crates that read the device's
+//! network configuration do so through the Android framework. They reach the
+//! `JavaVM` and the `Context` via the `ndk_context` crate's global
+//! `AndroidContext` — e.g. `hickory-resolver`'s `system_conf/android.rs` calls
+//! `ndk_context::android_context()` to read DNS servers from `ConnectivityManager`.
+//! Older hickory (0.25.2) used `resolv-conf` instead and never touched this.
+//!
+//! On a normal `ndk-glue` app `ndk_context` is initialized before `main`, but
+//! here Flutter owns the activity and loads our `.so` with `dlopen` from Dart —
+//! which never runs `JNI_OnLoad` — so nobody initializes it. The first DNS lookup
+//! then panics with "android context was not initialized", which surfaces on the
+//! Dart side as `PanicException` (e.g. when fetching a federation's metadata).
+//!
+//! Fix: `MainActivity` calls `System.loadLibrary("ecashapp")`, which DOES run
+//! `JNI_OnLoad` below. We grab the `JavaVM`, look up the process-wide
+//! `Application` via `ActivityThread.currentApplication()` (so we need no help
+//! from Kotlin and stay independent of the dev/prod application id), and hand
+//! both to `ndk_context`. This module is compiled only on Android; desktop reads
+//! `/etc/resolv.conf` and never touches `ndk_context`.
+
+use std::ffi::c_void;
+
+use jni::sys::{jint, JNI_VERSION_1_6};
+use jni::JavaVM;
+
+/// Invoked by the JVM when `System.loadLibrary("ecashapp")` loads this library.
+#[no_mangle]
+pub extern "system" fn JNI_OnLoad(vm: JavaVM, _reserved: *mut c_void) -> jint {
+    if let Err(e) = init_android_context(&vm) {
+        // The Flutter event bus isn't wired up this early, so this only reaches
+        // logcat — but a failure here means networking will panic later anyway.
+        eprintln!("ecashapp: failed to initialize Android context for native networking: {e:?}");
+    }
+    JNI_VERSION_1_6
+}
+
+fn init_android_context(vm: &JavaVM) -> anyhow::Result<()> {
+    // `JNI_OnLoad` runs on a thread that is already attached to the JVM.
+    let mut env = vm.get_env()?;
+
+    // android.app.ActivityThread.currentApplication() -> Application (a Context).
+    let activity_thread = env.find_class("android/app/ActivityThread")?;
+    let application = env
+        .call_static_method(
+            activity_thread,
+            "currentApplication",
+            "()Landroid/app/Application;",
+            &[],
+        )?
+        .l()?;
+
+    if application.is_null() {
+        anyhow::bail!("ActivityThread.currentApplication() returned null");
+    }
+
+    // Promote to a global ref and leak it so the jobject stays valid for the
+    // whole process lifetime — `ndk_context` only stores the raw pointer.
+    let application = env.new_global_ref(&application)?;
+    let context_ptr = application.as_obj().as_raw();
+    std::mem::forget(application);
+
+    // SAFETY: the pointers are valid, and `JNI_OnLoad` runs once per library
+    // load so `initialize_android_context` (which asserts it is called once) is
+    // not invoked twice.
+    unsafe {
+        ndk_context::initialize_android_context(
+            vm.get_java_vm_pointer().cast::<c_void>(),
+            context_ptr.cast::<c_void>(),
+        );
+    }
+
+    Ok(())
+}

rust/ecashapp/src/android_init.rs

@@ -1,5 +1,7 @@
 #![allow(unexpected_cfgs)]
 
+#[cfg(target_os = "android")]
+mod android_init;
 mod app_error;
 mod db;
 mod event_bus;

rust/ecashapp/src/lib.rs

@@ -1573,67 +1573,55 @@ impl Multimint {
         // Get the connection status stream from the client
         let status_stream = client.api().connection_status_stream();
 
-        // Fold the guardian version into each peer status so the UI reflects
-        // upgrades in real time without a separate timer. The version only needs
-        // (re)fetching when a peer comes online: a guardian upgrade restarts
-        // fedimintd, which surfaces here as an offline->online transition. We
-        // cache the last-known version per peer and refetch only on that
-        // transition (or if we never managed to fetch it) to avoid hitting every
-        // guardian on each unrelated connectivity change.
-        let mapped_stream = stream::unfold(
-            (
-                Box::pin(status_stream),
-                client,
-                peers,
-                BTreeMap::<u16, Option<String>>::new(),
-                BTreeMap::<u16, bool>::new(),
-            ),
-            |(mut status_stream, client, peers, mut cached_versions, mut prev_online)| async move {
-                let status_map = status_stream.next().await?;
-
-                let mut peers_status = Vec::with_capacity(peers.len());
-                for (peer_id, (name, url)) in peers.iter() {
-                    let (online, connectivity) = match status_map.get(&(*peer_id).into()) {
-                        Some(FedimintPeerStatus::Connected(c)) => (true, (*c).into()),
-                        Some(FedimintPeerStatus::Disconnected) | None => {
-                            (false, PeerConnectivity::Unknown)
-                        }
-                    };
+        // Guardian versions are refreshed out-of-band by the periodic meta cache
+        // task (`spawn_cache_task` -> `cache_federation_meta`) and persisted under
+        // `FederationMetaKey`. We read them from that cache rather than fetching
+        // inline, so this stream stays a cheap, purely-local mapping of
+        // connectivity -> status: the sidebar's online indicator updates the
+        // instant fedimint reports a peer up/down, with no per-guardian network
+        // round-trips gating the emission.
+        let db = self.db.clone();
+        let federation_id = client.federation_id();
+        let peers = Arc::new(peers);
+        let mapped_stream = status_stream.then(move |status_map| {
+            let db = db.clone();
+            let peers = peers.clone();
+            async move {
+                // A single local read returns every guardian's last-known version.
+                let cached_versions: BTreeMap<u16, Option<String>> = {
+                    let mut dbtx = db.begin_transaction_nc().await;
+                    dbtx.get_value(&FederationMetaKey { federation_id })
+                        .await
+                        .map(|meta| {
+                            meta.guardians
+                                .into_iter()
+                                .map(|g| (g.peer_id, g.version))
+                                .collect()
+                        })
+                        .unwrap_or_default()
+                };
 
-                    let version = if online {
-                        let was_online = prev_online.get(peer_id).copied().unwrap_or(false);
-                        let have_version =
-                            cached_versions.get(peer_id).is_some_and(|v| v.is_some());
-                        if was_online && have_version {
-                            cached_versions.get(peer_id).cloned().flatten()
-                        } else {
-                            let fetched =
-                                client.api().fedimintd_version((*peer_id).into()).await.ok();
-                            cached_versions.insert(*peer_id, fetched.clone());
-                            fetched
+                peers
+                    .iter()
+                    .map(|(peer_id, (name, url))| {
+                        let (online, connectivity) = match status_map.get(&(*peer_id).into()) {
+                            Some(FedimintPeerStatus::Connected(c)) => (true, (*c).into()),
+                            Some(FedimintPeerStatus::Disconnected) | None => {
+                                (false, PeerConnectivity::Unknown)
+                            }
+                        };
+                        PeerStatus {
+                            peer_id: *peer_id,
+                            name: name.clone(),
+                            online,
+                            connectivity,
+                            url: url.clone(),
+                            version: cached_versions.get(peer_id).cloned().flatten(),
                         }
-                    } else {
-                        None
-                    };
-
-                    prev_online.insert(*peer_id, online);
-
-                    peers_status.push(PeerStatus {
-                        peer_id: *peer_id,
-                        name: name.clone(),
-                        online,
-                        connectivity,
-                        url: url.clone(),
-                        version,
-                    });
-                }
-
-                Some((
-                    peers_status,
-                    (status_stream, client, peers, cached_versions, prev_online),
-                ))
-            },
-        );
+                    })
+                    .collect::<Vec<_>>()
+            }
+        });
 
         Ok(mapped_stream.boxed())
     }