Phase 6A/6B: android_api, notification, url_replace, auto_template, cloud_config_getter modules; new RPC handlers for Android API registration, ExtraApp CRUD, cloud config manager; get_app_status calls android_api for local version; renew_all fires RenewProgress notifications

Author: xz-dev

Cargo.lock

@@ -37,6 +37,7 @@ futures = "0.3"
 tokio-util = { version = "0.7", features = ["io"] }
 jsonl = "4.0"
 file-locker = "1.1"
+url = "2"
 
 [dev-dependencies]
 mockito = "1.7.1"

Cargo.toml

@@ -106,6 +106,15 @@ impl Database {
         self.extra_apps.delete::<ExtraAppRecord>(id)
     }
 
+    /// Find an ExtraApp record by matching its `app_id` map.
+    pub fn get_extra_app_by_app_id(
+        &self,
+        app_id: &std::collections::HashMap<String, Option<String>>,
+    ) -> Result<Option<ExtraAppRecord>> {
+        let all = self.extra_apps.load_all::<ExtraAppRecord>()?;
+        Ok(all.into_iter().find(|r| &r.app_id == app_id))
+    }
+
     // --- ExtraHub CRUD ---
 
     pub fn load_extra_hubs(&self) -> Result<Vec<ExtraHubRecord>> {

src/database/mod.rs

@@ -0,0 +1,104 @@
+use std::collections::HashMap;
+
+use jsonrpsee::core::client::ClientT;
+use jsonrpsee::http_client::HttpClientBuilder;
+use jsonrpsee::rpc_params;
+use once_cell::sync::OnceCell;
+use serde::{Deserialize, Serialize};
+
+use crate::database::models::app::AppRecord;
+
+/// Global Android API client, registered via `register_android_api` RPC.
+static ANDROID_API: OnceCell<AndroidApi> = OnceCell::new();
+
+pub fn set_android_api(url: String) {
+    let _ = ANDROID_API.set(AndroidApi { url });
+}
+
+pub fn get_android_api() -> Option<&'static AndroidApi> {
+    ANDROID_API.get()
+}
+
+/// Rust-side HTTP JSON-RPC client that calls back into the Kotlin
+/// KotlinHubRpcServer for Android-specific functionality.
+///
+/// Kotlin exposes `get_local_version` and `get_installed_apps` methods
+/// on the same Ktor HTTP server that handles hub provider calls.
+pub struct AndroidApi {
+    url: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+struct GetLocalVersionParams {
+    app_id: HashMap<String, Option<String>>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+struct GetInstalledAppsParams {
+    ignore_system: bool,
+}
+
+impl AndroidApi {
+    /// Query Kotlin for the locally-installed version of an app.
+    ///
+    /// Calls `get_local_version({app_id})` on the Kotlin Ktor server.
+    /// Returns `None` if the app is not installed or the call fails.
+    pub async fn get_local_version(
+        &self,
+        app_id: &HashMap<String, Option<String>>,
+    ) -> Option<String> {
+        let client = HttpClientBuilder::default().build(&self.url).ok()?;
+        let params = rpc_params!(GetLocalVersionParams {
+            app_id: app_id.clone(),
+        });
+        client
+            .request::<Option<String>, _>("get_local_version", params)
+            .await
+            .unwrap_or(None)
+    }
+
+    /// Query Kotlin for all installed Android apps and Magisk modules.
+    ///
+    /// Calls `get_installed_apps({ignore_system})` on the Kotlin Ktor server.
+    /// Returns an empty list if the call fails.
+    pub async fn get_installed_apps(&self, ignore_system: bool) -> Vec<AppRecord> {
+        let client = match HttpClientBuilder::default().build(&self.url) {
+            Ok(c) => c,
+            Err(_) => return vec![],
+        };
+        let params = rpc_params!(GetInstalledAppsParams { ignore_system });
+        client
+            .request::<Vec<AppRecord>, _>("get_installed_apps", params)
+            .await
+            .unwrap_or_default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_local_version_params_serialization() {
+        let app_id: HashMap<String, Option<String>> = HashMap::from([(
+            "android_app_package".to_string(),
+            Some("com.example.app".to_string()),
+        )]);
+        let params = GetLocalVersionParams {
+            app_id: app_id.clone(),
+        };
+        let json = serde_json::to_string(&params).unwrap();
+        assert!(json.contains("android_app_package"));
+        assert!(json.contains("com.example.app"));
+    }
+
+    #[test]
+    fn test_get_installed_apps_params_serialization() {
+        let params = GetInstalledAppsParams {
+            ignore_system: true,
+        };
+        let json = serde_json::to_string(&params).unwrap();
+        assert!(json.contains("ignore_system"));
+        assert!(json.contains("true"));
+    }
+}

src/manager/android_api.rs

@@ -2,8 +2,10 @@ use std::collections::HashMap;
 use std::sync::Arc;
 use tokio::sync::{RwLock, Semaphore};
 
+use super::android_api;
 use super::app_status::AppStatus;
 use super::data_getter::DataGetter;
+use super::notification::{notify_if_registered, ManagerEvent};
 use super::updater::get_release_status;
 use super::version_map::VersionMap;
 use crate::database::get_db;
@@ -90,24 +92,40 @@ impl AppManager {
     }
 
     /// Return the current AppStatus for an app.
+    ///
+    /// Queries Kotlin for the locally-installed version via `AndroidApi.get_local_version()`
+    /// if a callback URL has been registered; otherwise local_version is `None`.
     pub async fn get_app_status(&self, record_id: &str) -> AppStatus {
         let app = match self.apps.read().await.get(record_id).cloned() {
             Some(a) => a,
             None => return AppStatus::AppInactive,
         };
+
+        // Query local version from Android via registered callback
+        let local_version: Option<String> = match android_api::get_android_api() {
+            Some(api) => api.get_local_version(&app.app_id).await,
+            None => None,
+        };
+
         let mut maps = self.version_maps.write().await;
         let vm = maps.entry(record_id.to_string()).or_insert_with(|| {
             VersionMap::new(
                 app.invalid_version_number_field_regex.clone(),
                 app.include_version_number_field_regex.clone(),
             )
         });
-        get_release_status(vm, None, app.ignore_version_number.as_deref(), true)
+        get_release_status(
+            vm,
+            local_version.as_deref(),
+            app.ignore_version_number.as_deref(),
+            true,
+        )
     }
 
     /// Refresh version data for all saved apps.
     ///
     /// Uses a semaphore (max 10 concurrent hub requests) matching Kotlin's logic.
+    /// Fires `RenewProgress` notifications to Kotlin UI as each app completes.
     pub async fn renew_all(
         &self,
         hubs: &[crate::database::models::hub::HubRecord],
@@ -169,6 +187,12 @@ impl AppManager {
                             )
                         });
                         vm.add_single_release(&hub.uuid, release.clone());
+                        // Notify progress after batch result
+                        let done = completed.fetch_add(1, std::sync::atomic::Ordering::SeqCst) + 1;
+                        if let Some(ref f) = cb {
+                            f(done, total);
+                        }
+                        notify_if_registered(ManagerEvent::RenewProgress { done, total }).await;
                     } else {
                         need_full.push(app.clone());
                     }
@@ -199,6 +223,7 @@ impl AppManager {
                     if let Some(ref f) = cb {
                         f(done, total);
                     }
+                    notify_if_registered(ManagerEvent::RenewProgress { done, total }).await;
                 }
             });
             handles.push(handle);