Prune commentary and stale Rust port notes

app-rust/src/shell/jcall.rs

@@ -1,46 +1,3 @@
-//! Thin wrappers around the five `Env` calls this crate makes constantly
-//! (a class name, a method name and a signature, all as plain `&str`).
-//!
-//! `jni` 0.22 wants a class or method *name* as `AsRef<JNIStr>` (its own
-//! modified-UTF-8 type; `JNIString::new` is the runtime conversion, used
-//! here uniformly rather than switching to the compile-time `jni_str!`
-//! literal macro call by call -- these are a handful of short, one-off
-//! lookups, not a hot loop, so the difference is not worth two code paths
-//! for the same thing) and a *signature* as a parsed `MethodSignature`/
-//! `FieldSignature`, which is why those go through
-//! `RuntimeMethodSignature`/`RuntimeFieldSignature::from_str` instead: the
-//! parsed form is what lets these calls skip re-validating the signature
-//! against the arguments on every call, which is the whole reason `jni`
-//! moved to it.
-//!
-//! **The classloader gotcha, found by testing (2026-09-05).** A class
-//! lookup by name (`find_class`, `new_object`, `call_static_method`,
-//! `get_static_field` -- anything that resolves a *class*, as opposed to
-//! `call_method` on an object it already has, which needs no such lookup)
-//! defaults to `FindClass`'s ordinary search when it cannot find the
-//! calling thread a classloader through `Thread.getContextClassLoader()`.
-//! That default is fine on a thread the JVM itself started -- an
-//! `onCreate`/`onStartCommand` callback -- but every one of these calls
-//! from `android-shell`'s own background thread (the notification
-//! follow-loop, the share upload) is running on a thread *Rust* spawned
-//! and attached with `JavaVM::attach_current_thread`, which the platform
-//! never gave an app classloader. Framework classes
-//! (`android.app.Notification$Builder`, ...) still resolve, because they
-//! are reachable from the bootstrap loader `FindClass` falls back to --
-//! `androidx.core.app.NotificationManagerCompat` is not, since it is
-//! packaged inside this app's own APK. The failure was
-//! `Error::NoClassDefFound`, logged by `notify::show`'s `LogErrorAndDefault`
-//! as "failed to resolve Java class ... (class not found or linkage
-//! error)" -- on a real device this reads as "the notification silently
-//! never arrives," since the whole call is inside the follow loop and the
-//! ongoing foreground notification (built on the main thread, in
-//! `try_start`, before the background thread exists) posts fine either
-//! way. `remember_class_loader` caches the app's own `ClassLoader` the
-//! first time any entry point has a `Context` to ask, and every class
-//! lookup below goes through it explicitly via `LoaderContext::Loader`
-//! rather than the thread-dependent default -- so it is correct on the
-//! main thread and on this crate's own background threads alike.
-
 use jni::Env;
 use jni::errors::Result;
 use jni::objects::{JClass, JClassLoader, JObject, JValue, JValueOwned};
@@ -51,17 +8,10 @@ use std::sync::OnceLock;
 
 static CLASS_LOADER: OnceLock<Global<JClassLoader<'static>>> = OnceLock::new();
 
-/// Caches `context`'s own `ClassLoader`, the first time this is called.
-/// Cheap to call from every entry point that has a `Context` on hand
-/// (`MainActivity`'s and `NotificationService`'s all do): later calls are
-/// a `OnceLock::get` and nothing else.
 pub fn remember_class_loader(env: &mut Env, context: &JObject) -> Result<()> {
     if CLASS_LOADER.get().is_some() {
         return Ok(());
     }
-    // context.getClass().getClassLoader() -- resolved via `call_method` on
-    // real objects throughout, so this needs no class-name lookup of its
-    // own and has nothing to bootstrap.
     let class_obj = call_method(env, context, "getClass", "()Ljava/lang/Class;", &[])?.l()?;
     let loader_obj = call_method(
         env,
@@ -99,9 +49,6 @@ pub fn find_class<'local>(env: &mut Env<'local>, name: &str) -> Result<JClass<'l
     resolve_class(env, name)
 }
 
-/// A new Java string as a plain `JObject` -- what every call site here
-/// wants it as (`JValue::Object` takes `&JObject`, not `&JString`, and
-/// `JString: Into<JObject>` is the documented way across).
 pub fn jstr_obj<'local>(env: &mut Env<'local>, text: impl AsRef<str>) -> Result<JObject<'local>> {
     Ok(env.new_string(text)?.into())
 }