Refactor context and JavaObject handling, add ActivityThread

Refactored Context to use a new ActivityThread class for application context access and updated its API to use method-style accessors. Added a generic JavaObject.create<T>() proxy for dynamic Java object interaction, replacing the removed JavaObjectProxy. Improved SharedPreferences to use the new Context API and added error handling. Cleaned up and consolidated code for better maintainability and type safety.

Author: DerGoogler

ts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wxu",
-  "version": "0.0.92",
+  "version": "0.0.93",
   "type": "module",
   "description": "WXU TypeScript Package",
   "source": "src/index.ts",

ts/src/classes/Context.ts

@@ -1,21 +1,42 @@
 import { JavaObject } from "./JavaObject";
+import { ActivityThread } from "./android/app/ActivityThread";
+
+export interface ContextWrapper {
+  getApplicationContext(): any;
+}
+
+export interface ContextImpl extends ContextWrapper {
+  getPackageName(): string;
+  getDataDir(): any;
+  getCacheDir(): any;
+  getExternalCacheDir(): any;
+  getFilesDir(): any;
+  getSystemService(name: string): any;
+  getResources(): any;
+  getPackageManager(): any;
+  getContentResolver(): any;
+  getApplicationInfo(): any;
+  getAssets(): any;
+  getSharedPreferences(name: string, mode: number): any;
+}
 
 /**
  * Provides access to Android application context and common context-related operations.
  * Wraps the underlying JavaObject interactions for easier use in JavaScript/TypeScript.
  */
-export class Context {
+export class Context implements ContextImpl {
   private static _instance: Context;
-  private _context: JavaObject;
+  private _context: ContextImpl;
 
   private constructor() {
-    // Initialize the base context using ActivityThread
-    const ActivityThread = new JavaObject("android.app.ActivityThread");
-    const thread = ActivityThread.call("currentActivityThread");
-    const context = JavaObject.callMethod(thread!!, "getApplication", []);
-    this._context = JavaObject.fromObjId(
-      JavaObject.callMethod(context!!, "getApplicationContext", [])
-    );
+    const aThread = new ActivityThread();
+    // ContextWrapper is basiclly `Context`
+    const application = aThread.currentActivityThread().getApplication();
+    this._context = application.getApplicationContext() as ContextImpl;
+  }
+
+  public getApplicationContext() {
+    return this;
   }
 
   /**
@@ -28,101 +49,92 @@ export class Context {
     return Context._instance;
   }
 
-  /**
-   * Gets the underlying JavaObject representing the Android context
-   */
-  public get native(): JavaObject {
-    return this._context;
+  public getSharedPreferences(name: string, mode: number) {
+    return this._context.getSharedPreferences(name, mode);
   }
 
   /**
    * Gets the application's package name
    */
-  public get packageName(): string {
-    return this._context.call("getPackageName", []) as string;
+  public getPackageName(): string {
+    return this._context.getPackageName();
   }
 
   /**
    * Gets the application's data directory
    */
-  public get dataDir(): string {
-    return this._context.call("getDataDir", []) as string;
+  public getDataDir(): string {
+    return this._context.getDataDir();
   }
 
   /**
    * Gets the application's cache directory
    */
-  public get cacheDir(): string {
-    return this._context.call("getCacheDir", []) as string;
+  public getCacheDir(): string {
+    return this._context.getCacheDir();
   }
 
   /**
    * Gets the application's external cache directory (if available)
    */
-  public get externalCacheDir(): string | null | undefined {
-    return this._context.call("getExternalCacheDir", []);
+  public getExternalCacheDir(): string | null | undefined {
+    return this._context.getExternalCacheDir();
   }
 
   /**
    * Gets the application's files directory
    */
-  public get filesDir(): string {
-    return this._context.call("getFilesDir", []) as string;
+  public getFilesDir(): string {
+    return this._context.getFilesDir();
   }
 
   /**
    * Gets the system service with the given name
    * @param serviceName The name of the system service (e.g., "window", "power")
    */
-  public getSystemService(serviceName: string): JavaObject | null {
-    const serviceId = this._context.call("getSystemService", [serviceName]);
-    return serviceId ? JavaObject.fromObjId(serviceId) : null;
+  public getSystemService(serviceName: string) {
+    return this._context.getSystemService(serviceName);
   }
 
   /**
    * Gets the resources object for the application
    */
-  public get resources(): JavaObject | null {
-    const resourcesId = this._context.call("getResources", []);
-    return resourcesId ? JavaObject.fromObjId(resourcesId) : null;
+  public getResources() {
+    return this._context.getResources();
   }
 
   /**
    * Gets the package manager
    */
-  public get packageManager(): JavaObject | null {
-    const pmId = this._context.call("getPackageManager", []);
-    return pmId ? JavaObject.fromObjId(pmId) : null;
+  public getPackageManager() {
+    return this._context.getPackageManager();
   }
 
   /**
    * Gets the content resolver
    */
-  public get contentResolver(): JavaObject | null {
-    const crId = this._context.call("getContentResolver", []);
-    return crId ? JavaObject.fromObjId(crId) : null;
+  public getContentResolver() {
+    return this._context.getContentResolver();
   }
 
   /**
    * Gets the application info
    */
-  public get applicationInfo(): JavaObject | null {
-    const aiId = this._context.call("getApplicationInfo", []);
-    return aiId ? JavaObject.fromObjId(aiId) : null;
+  public getApplicationInfo() {
+    return this._context.getApplicationInfo();
   }
 
   /**
    * Gets the assets manager
    */
-  public get assets(): JavaObject | null {
-    const assetsId = this._context.call("getAssets", []);
-    return assetsId ? JavaObject.fromObjId(assetsId) : null;
+  public getAssets() {
+    return this._context.getAssets();
   }
 
   /**
    * Releases the underlying context resources
    */
   public release(): void {
-    this._context.release();
+    (this._context as unknown as JavaObject).release();
   }
 }

ts/src/classes/JavaObject.ts

@@ -56,20 +56,15 @@ export class JavaObject {
 
   static {
     if (typeof window["global"] === "undefined") {
-      throw new Error(
-        "JavaObject requires a global context with 'wx:reflect' module."
-      );
+      throw new Error("JavaObject requires a global context with 'wx:reflect' module.");
     }
 
     this.reflect = window.global.require("wx:reflect");
     this.proxyHandlers = new Map();
     this.nextProxyId = 0;
   }
 
-  public constructor(
-    className: string | null,
-    args: Array<string | boolean | number> = []
-  ) {
+  public constructor(className: string | null, args: Array<string | boolean | number> = []) {
     if (typeof className === "undefined") {
       throw new TypeError("Class name must be a non-empty string or null.");
     }
@@ -80,10 +75,7 @@ export class JavaObject {
     }
   }
 
-  public call(
-    method: string,
-    args: Array<string | boolean | number> = []
-  ): string | null | undefined {
+  public call(method: string, args: Array<string | boolean | number> = []): string | null | undefined {
     if (typeof method !== "string" || method.length === 0) {
       throw new TypeError("Method name must be a non-empty string.");
     }
@@ -119,44 +111,26 @@ export class JavaObject {
     return this.reflect?.getClass(name);
   }
 
-  public static newInstance(
-    classId: string,
-    args: Array<string | boolean | number> | null
-  ): string | null | undefined {
+  public static newInstance(classId: string, args: Array<string | boolean | number> | null): string | null | undefined {
     const jsonArgs = args == null ? "null" : JSON.stringify(args);
     return this.reflect?.newInstance(classId, jsonArgs);
   }
 
-  public static callMethod(
-    objId: string,
-    method: string,
-    args: Array<string | boolean | number> | null
-  ): string | null | undefined {
+  public static callMethod(objId: string, method: string, args: Array<string | boolean | number> | null): string | null | undefined {
     const jsonArgs = args == null ? "[]" : JSON.stringify(args);
     return this.reflect?.callMethod(objId, method, jsonArgs);
   }
 
-  public static callStaticMethod(
-    objId: string,
-    method: string,
-    args: Array<string | boolean | number> | null
-  ): string | null | undefined {
+  public static callStaticMethod(objId: string, method: string, args: Array<string | boolean | number> | null): string | null | undefined {
     const jsonArgs = args == null ? "[]" : JSON.stringify(args);
     return this.reflect?.callStaticMethod(objId, method, jsonArgs);
   }
 
-  public static getField(
-    objId: string,
-    field: string
-  ): string | null | undefined {
+  public static getField(objId: string, field: string): string | null | undefined {
     return this.reflect?.getField(objId, field);
   }
 
-  public static setField(
-    objId: string,
-    field: string,
-    value: string | boolean | number | null
-  ): void {
+  public static setField(objId: string, field: string, value: string | boolean | number | null): void {
     this.reflect?.setField(objId, field, String(value));
   }
 
@@ -199,10 +173,7 @@ export class JavaObject {
       }
     }
 
-    const proxyId = this.reflect?.createProxy(
-      interfaceName,
-      JSON.stringify(methodsMap)
-    );
+    const proxyId = this.reflect?.createProxy(interfaceName, JSON.stringify(methodsMap));
 
     const proxy = JavaObject.fromObjId(proxyId);
 
@@ -213,4 +184,69 @@ export class JavaObject {
 
     return proxy;
   }
+
+  public static create<T>(className: string | JavaObject | null, args: any[] = []): T {
+    let javaObj: JavaObject;
+
+    if (className instanceof JavaObject) {
+      javaObj = className;
+    } else if (className) {
+      javaObj = new JavaObject(className, args);
+    } else {
+      throw new TypeError("Must provide a class name or a JavaObject instance");
+    }
+
+    const autoWrap = (value: any) => {
+      if (value == null) {
+        return value;
+      }
+
+      if (typeof value === "string") {
+        let objId = value;
+
+        if (value.startsWith("ptr:")) {
+          objId = value.slice(4);
+        }
+
+        if (objId.includes("wx_reflect_obj") || objId.match(/^[a-zA-Z0-9_]+$/)) {
+          try {
+            return this.create(JavaObject.fromObjId(objId));
+          } catch (error) {
+            console.error(`Error wrapping Java object ${objId}:`, error);
+            return value;
+          }
+        }
+      }
+
+      return value;
+    };
+
+    return new Proxy(javaObj, {
+      get(target, prop: string, receiver) {
+        if (prop === "release" || prop === "objId" || prop === "classId") {
+          return Reflect.get(target, prop, receiver);
+        }
+
+        return (...args: any[]) => {
+          try {
+            const result = JavaObject.callMethod(target.objId, prop, args);
+            return autoWrap(result);
+          } catch (error) {
+            console.error(`Error calling method ${prop}:`, error);
+            throw error;
+          }
+        };
+      },
+
+      set(target, prop: string, value) {
+        try {
+          JavaObject.setField(target.objId, prop, value);
+          return true;
+        } catch (error) {
+          console.error(`Error setting field ${prop}:`, error);
+          return false;
+        }
+      },
+    }) as T;
+  }
 }