js-port: full type marshalling for native interfaces

Extend native-interface support to every NativeInterface type (all
primitives, String, the primitive arrays byte[]/int[]/long[]/double[]/
float[]/boolean[]/char[]/short[], and String[]) in both directions.

- NativeInterfaceBridge: per-primitive call* + callString/callVoid/
  callObject, plus a typed callArray(iface, method, args, componentToken)
  for array returns.
- JavaScriptBuilder: <Iface>Impl return-type dispatch routes arrays to
  callArray with the element's component token (JAVA_INT.../
  java_lang_String) and boxes primitive args into the Object[].
- JavascriptNativeRegistry: the call* symbols are RUNTIME_IMPLEMENTED so
  the translator defers to the worker-side wrappers.
- parparvm_runtime.js: bindNative wrappers funnel through the single
  __cn1_native_interface_call__ host hook and coerce the resolved JS
  value to the declared Java type -- createJavaString (String/String[]),
  _LfromNumber (long/long[]), jvm.newArray(token) (typed arrays),
  int/short/byte/char/float/double normalisation. toHostTransferArg now
  unboxes argument values too (boxed Integer/Long/.../Boolean -> JS
  primitive, long {__l} -> number) so primitive/long/array arguments
  marshal correctly to the host.
- browser_bridge.js: one __cn1_native_interface_call__ handler dispatches
  to cn1_native_interfaces[iface][method](args..., callback).

Verified in the local initializr bundle: no "Missing javascript native
method" stubs remain, the bindNative wrappers/array builder are present,
and WebsiteThemeNativeImpl is reachable. PeerComponent returns route
through callObject (best-effort) pending dedicated peer wrapping.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: shai-almog

Ports/JavaScriptPort/src/main/java/com/codename1/impl/platform/js/NativeInterfaceBridge.java

@@ -12,19 +12,20 @@
  *
  * <p>The generated {@code <Interface>Impl} classes (emitted by the JavaScript
  * builder) delegate every interface method to one of the {@code call*} natives
- * below. Because this class lives in {@code com.codename1.impl.platform.js}, the
- * translator categorizes these natives as HOST_HOOK: the worker suspends and the
- * call is replayed on the <em>main thread</em> (via {@code browser_bridge.js}),
- * where the developer-authored JS stub runs with full DOM access and completes
- * the call through its callback. The worker resumes with the returned value.</p>
+ * below, picked by the method's return type. These natives are runtime-
+ * implemented in {@code parparvm_runtime.js}: the worker suspends, the call is
+ * replayed on the <em>main thread</em> (via {@code browser_bridge.js}) where the
+ * developer-authored JS stub runs with full DOM access and completes the call
+ * through its callback, and the worker resumes with the result coerced to the
+ * declared Java type.</p>
  *
- * <p>This preserves the existing JS native-interface impl format
- * ({@code cn1_native_interfaces["<pkg>_<Iface>"]["<method>_<paramTypes>"](args..., callback)})
- * so existing stubs work unchanged.</p>
+ * <p>Supported types mirror {@code NativeInterface}: all primitives, {@code String},
+ * primitive arrays plus {@code String[]} (via {@link #callArray}), and
+ * {@code com.codename1.ui.PeerComponent} (routed through {@link #callObject}).</p>
  *
  * <p>{@code iface} is the interface class name with dots replaced by underscores
- * (the {@code cn1_native_interfaces} registry key) and {@code method} is the
- * trailing-underscore method key (e.g. {@code "isDarkMode_"}). {@code args}
+ * (the {@code cn1_native_interfaces} registry key), {@code method} is the
+ * trailing-underscore method key (e.g. {@code "isDarkMode_"}), and {@code args}
  * holds the (boxed) Java arguments, or an empty array for a no-arg method.</p>
  */
 public final class NativeInterfaceBridge {
@@ -33,23 +34,33 @@ private NativeInterfaceBridge() {
 
     public static native boolean callBoolean(String iface, String method, Object[] args);
 
-    public static native int callInt(String iface, String method, Object[] args);
+    public static native byte callByte(String iface, String method, Object[] args);
 
-    public static native long callLong(String iface, String method, Object[] args);
+    public static native short callShort(String iface, String method, Object[] args);
 
-    public static native double callDouble(String iface, String method, Object[] args);
+    public static native int callInt(String iface, String method, Object[] args);
 
-    public static native float callFloat(String iface, String method, Object[] args);
+    public static native char callChar(String iface, String method, Object[] args);
 
-    public static native byte callByte(String iface, String method, Object[] args);
+    public static native long callLong(String iface, String method, Object[] args);
 
-    public static native short callShort(String iface, String method, Object[] args);
+    public static native float callFloat(String iface, String method, Object[] args);
 
-    public static native char callChar(String iface, String method, Object[] args);
+    public static native double callDouble(String iface, String method, Object[] args);
 
     public static native String callString(String iface, String method, Object[] args);
 
     public static native Object callObject(String iface, String method, Object[] args);
 
     public static native void callVoid(String iface, String method, Object[] args);
+
+    /**
+     * Array-returning call. {@code componentToken} identifies the element type so
+     * the runtime can build the correctly-typed Java array: {@code "JAVA_INT"},
+     * {@code "JAVA_BYTE"}, {@code "JAVA_LONG"}, {@code "JAVA_DOUBLE"},
+     * {@code "JAVA_FLOAT"}, {@code "JAVA_BOOLEAN"}, {@code "JAVA_CHAR"},
+     * {@code "JAVA_SHORT"} or {@code "java_lang_String"}. The caller casts the
+     * result to the concrete array type.
+     */
+    public static native Object callArray(String iface, String method, Object[] args, String componentToken);
 }

maven/codenameone-maven-plugin/src/main/java/com/codename1/builders/JavaScriptBuilder.java

@@ -632,7 +632,15 @@ private void appendNativeInterfaceImplMethod(StringBuilder sb, Method m) {
             sb.append("        return ").append(call).append("callChar(").append(invokeArgs).append(");\n");
         } else if (ret == String.class) {
             sb.append("        return ").append(call).append("callString(").append(invokeArgs).append(");\n");
+        } else if (ret.isArray()) {
+            // Primitive arrays + String[]: callArray builds the correctly-typed
+            // Java array from the JS array the host returns (componentToken picks
+            // the element type).
+            sb.append("        return (").append(ret.getCanonicalName()).append(") ")
+                    .append(call).append("callArray(").append(invokeArgs)
+                    .append(", \"").append(arrayComponentToken(ret.getComponentType())).append("\");\n");
         } else {
+            // PeerComponent / other reference types -- best effort passthrough.
             sb.append("        return (").append(ret.getCanonicalName()).append(") ")
                     .append(call).append("callObject(").append(invokeArgs).append(");\n");
         }
@@ -664,6 +672,20 @@ private static String nativeInterfaceMethodKey(Method m) {
         return key.toString();
     }
 
+    // Runtime newArray() component-class token for an array's element type.
+    private static String arrayComponentToken(Class<?> component) {
+        if (component == int.class) return "JAVA_INT";
+        if (component == long.class) return "JAVA_LONG";
+        if (component == double.class) return "JAVA_DOUBLE";
+        if (component == float.class) return "JAVA_FLOAT";
+        if (component == boolean.class) return "JAVA_BOOLEAN";
+        if (component == byte.class) return "JAVA_BYTE";
+        if (component == short.class) return "JAVA_SHORT";
+        if (component == char.class) return "JAVA_CHAR";
+        if (component == String.class) return "java_lang_String";
+        return component.getName().replace('.', '_');
+    }
+
     private static String xmlvmTypeName(Class<?> type) {
         if (type.isArray()) {
             return xmlvmTypeName(type.getComponentType()) + "_1ARRAY";

vm/ByteCodeTranslator/src/com/codename1/tools/translator/JavascriptNativeRegistry.java

@@ -117,7 +117,23 @@ enum NativeCategory {
             "cn1_java_util_TimeZone_getTimezoneRawOffset_java_lang_String_R_int",
             "cn1_java_util_TimeZone_isTimezoneDST_java_lang_String_long_R_boolean",
             "cn1_com_codename1_impl_platform_js_VMHost_getLastEventCode_R_int",
-            "cn1_com_codename1_impl_platform_js_VMHost_pollEventCode_R_int"
+            "cn1_com_codename1_impl_platform_js_VMHost_pollEventCode_R_int",
+            // NativeInterface bridge: runtime-implemented in parparvm_runtime.js
+            // (bindNative). Each forwards to the main thread via the
+            // __cn1_native_interface_call__ host hook and coerces the result to
+            // the declared Java type (createJavaString / _LfromNumber / newArray).
+            "cn1_com_codename1_impl_platform_js_NativeInterfaceBridge_callBoolean_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_boolean",
+            "cn1_com_codename1_impl_platform_js_NativeInterfaceBridge_callByte_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_byte",
+            "cn1_com_codename1_impl_platform_js_NativeInterfaceBridge_callShort_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_short",
+            "cn1_com_codename1_impl_platform_js_NativeInterfaceBridge_callInt_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_int",
+            "cn1_com_codename1_impl_platform_js_NativeInterfaceBridge_callChar_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_char",
+            "cn1_com_codename1_impl_platform_js_NativeInterfaceBridge_callLong_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_long",
+            "cn1_com_codename1_impl_platform_js_NativeInterfaceBridge_callFloat_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_float",
+            "cn1_com_codename1_impl_platform_js_NativeInterfaceBridge_callDouble_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_double",
+            "cn1_com_codename1_impl_platform_js_NativeInterfaceBridge_callString_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_java_lang_String",
+            "cn1_com_codename1_impl_platform_js_NativeInterfaceBridge_callObject_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_java_lang_Object",
+            "cn1_com_codename1_impl_platform_js_NativeInterfaceBridge_callArray_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_java_lang_String_R_java_lang_Object",
+            "cn1_com_codename1_impl_platform_js_NativeInterfaceBridge_callVoid_java_lang_String_java_lang_String_java_lang_Object_1ARRAY"
     ));
 
     private static final Set<String> HOST_HOOK_PREFIXES = new HashSet<String>(Arrays.asList(

vm/ByteCodeTranslator/src/javascript/browser_bridge.js

@@ -214,31 +214,13 @@
     });
   }
 
-  // One handler per NativeInterfaceBridge.call* native symbol (the suffix encodes
-  // the bridge method + its (String, String, Object[]) signature and return type;
-  // void has no _R_). Dispatch is identical across return types -- the worker side
-  // coerces the resolved value to the declared Java type.
-  var __cn1NativeInterfaceBridgeSymbols = [
-    'callBoolean_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_boolean',
-    'callInt_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_int',
-    'callLong_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_long',
-    'callDouble_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_double',
-    'callFloat_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_float',
-    'callByte_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_byte',
-    'callShort_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_short',
-    'callChar_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_char',
-    'callString_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_java_lang_String',
-    'callObject_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_R_java_lang_Object',
-    'callVoid_java_lang_String_java_lang_String_java_lang_Object_1ARRAY'
-  ];
-  for (var __cn1NiIdx = 0; __cn1NiIdx < __cn1NativeInterfaceBridgeSymbols.length; __cn1NiIdx++) {
-    (function(suffix) {
-      var symbol = 'cn1_com_codename1_impl_platform_js_NativeInterfaceBridge_' + suffix;
-      hostBridge.register(symbol, function(iface, method, args) {
-        return cn1InvokeNativeInterface(iface, method, args);
-      });
-    })(__cn1NativeInterfaceBridgeSymbols[__cn1NiIdx]);
-  }
+  // Single host hook for every NativeInterfaceBridge.call* native. The worker-side
+  // bindNative wrappers (parparvm_runtime.js) funnel here with (iface, method, args)
+  // and coerce the resolved value to the declared Java return type, so dispatch is
+  // uniform on this side.
+  hostBridge.register('__cn1_native_interface_call__', function(iface, method, args) {
+    return cn1InvokeNativeInterface(iface, method, args);
+  });
 
   var hostRefNextId = 1;
   var hostRefById = {};

vm/ByteCodeTranslator/src/javascript/parparvm_runtime.js

@@ -2400,6 +2400,23 @@ const jvm = {
     if (value.__class === "java_lang_String") {
       return this.toNativeString(value);
     }
+    // 64-bit long ({__l:1,l,h}) -> JS number for the host.
+    if (value.__l === 1) {
+      return _LtoNumber(value);
+    }
+    // Boxed primitives -> their JS value. NativeInterface args arrive boxed in an
+    // Object[] (Integer.valueOf(...) etc.); the host wants the plain value.
+    switch (value.__class) {
+      case "java_lang_Integer": return value.cn1_java_lang_Integer_value | 0;
+      case "java_lang_Short": return value.cn1_java_lang_Short_value | 0;
+      case "java_lang_Byte": return value.cn1_java_lang_Byte_value | 0;
+      case "java_lang_Character": return value.cn1_java_lang_Character_value | 0;
+      case "java_lang_Boolean": return !!value.cn1_java_lang_Boolean_value;
+      case "java_lang_Double": return Number(value.cn1_java_lang_Double_value);
+      case "java_lang_Float": return Number(value.cn1_java_lang_Float_value);
+      case "java_lang_Long": return _LtoNum(value.cn1_java_lang_Long_value);
+      default: break;
+    }
     if (value.__cn1HostRef != null) {
       return value.__cn1HostClass
         ? { __cn1HostRef: value.__cn1HostRef, __cn1HostClass: value.__cn1HostClass }
@@ -5159,6 +5176,83 @@ bindNative(["cn1_com_codename1_impl_platform_js_VMHost_pollEventCode_R_int",
   return event && event.code != null ? (event.code | 0) : -1;
 });
 
+// ---- NativeInterface bridge -----------------------------------------------------
+// The generated <Iface>Impl methods call these NativeInterfaceBridge.call*
+// natives. Each forwards the (iface, method, args) tuple to the MAIN thread via
+// the shared __cn1_native_interface_call__ host hook (browser_bridge.js runs the
+// developer's JS stub with DOM access and resolves through its callback), then
+// coerces the JS result to the declared Java return type. Args were already
+// unboxed by toHostTransferArg (boxed primitives / Java String / long).
+const __NI_PREFIX = "cn1_com_codename1_impl_platform_js_NativeInterfaceBridge_";
+const __NI_SIG = "java_lang_String_java_lang_String_java_lang_Object_1ARRAY";
+function* __cn1NativeInterfaceCall(iface, method, args) {
+  return yield jvm.invokeHostNative("__cn1_native_interface_call__", [iface, method, args]);
+}
+function __cn1NativeInterfaceArray(v, token) {
+  if (v == null) {
+    return null;
+  }
+  const len = v.length | 0;
+  const arr = jvm.newArray(len, token, 1);
+  for (let i = 0; i < len; i++) {
+    const e = v[i];
+    switch (token) {
+      case "java_lang_String": arr[i] = (e == null ? null : createJavaString(e)); break;
+      case "JAVA_LONG": arr[i] = _LfromNumber(Number(e || 0)); break;
+      case "JAVA_BOOLEAN": arr[i] = !!e; break;
+      case "JAVA_CHAR": arr[i] = (e | 0) & 0xffff; break;
+      case "JAVA_BYTE": arr[i] = ((e | 0) << 24) >> 24; break;
+      case "JAVA_SHORT": arr[i] = ((e | 0) << 16) >> 16; break;
+      case "JAVA_INT": arr[i] = e | 0; break;
+      case "JAVA_FLOAT": arr[i] = Math.fround(Number(e || 0)); break;
+      case "JAVA_DOUBLE": arr[i] = Number(e || 0); break;
+      default: arr[i] = e;
+    }
+  }
+  return arr;
+}
+bindNative([__NI_PREFIX + "callBoolean_" + __NI_SIG + "_R_boolean"], function*(iface, method, args) {
+  return !!(yield* __cn1NativeInterfaceCall(iface, method, args));
+});
+bindNative([__NI_PREFIX + "callByte_" + __NI_SIG + "_R_byte"], function*(iface, method, args) {
+  const v = yield* __cn1NativeInterfaceCall(iface, method, args); return ((v | 0) << 24) >> 24;
+});
+bindNative([__NI_PREFIX + "callShort_" + __NI_SIG + "_R_short"], function*(iface, method, args) {
+  const v = yield* __cn1NativeInterfaceCall(iface, method, args); return ((v | 0) << 16) >> 16;
+});
+bindNative([__NI_PREFIX + "callInt_" + __NI_SIG + "_R_int"], function*(iface, method, args) {
+  return (yield* __cn1NativeInterfaceCall(iface, method, args)) | 0;
+});
+bindNative([__NI_PREFIX + "callChar_" + __NI_SIG + "_R_char"], function*(iface, method, args) {
+  return ((yield* __cn1NativeInterfaceCall(iface, method, args)) | 0) & 0xffff;
+});
+bindNative([__NI_PREFIX + "callLong_" + __NI_SIG + "_R_long"], function*(iface, method, args) {
+  return _LfromNumber(Number((yield* __cn1NativeInterfaceCall(iface, method, args)) || 0));
+});
+bindNative([__NI_PREFIX + "callFloat_" + __NI_SIG + "_R_float"], function*(iface, method, args) {
+  return Math.fround(Number((yield* __cn1NativeInterfaceCall(iface, method, args)) || 0));
+});
+bindNative([__NI_PREFIX + "callDouble_" + __NI_SIG + "_R_double"], function*(iface, method, args) {
+  return Number((yield* __cn1NativeInterfaceCall(iface, method, args)) || 0);
+});
+bindNative([__NI_PREFIX + "callString_" + __NI_SIG + "_R_java_lang_String"], function*(iface, method, args) {
+  const v = yield* __cn1NativeInterfaceCall(iface, method, args);
+  return v == null ? null : createJavaString(v);
+});
+bindNative([__NI_PREFIX + "callObject_" + __NI_SIG + "_R_java_lang_Object"], function*(iface, method, args) {
+  const v = yield* __cn1NativeInterfaceCall(iface, method, args);
+  return (typeof v === "string") ? createJavaString(v) : (v == null ? null : v);
+});
+bindNative([__NI_PREFIX + "callVoid_" + __NI_SIG], function*(iface, method, args) {
+  yield* __cn1NativeInterfaceCall(iface, method, args);
+  return null;
+});
+bindNative([__NI_PREFIX + "callArray_java_lang_String_java_lang_String_java_lang_Object_1ARRAY_java_lang_String_R_java_lang_Object"],
+        function*(iface, method, args, token) {
+  const v = yield* __cn1NativeInterfaceCall(iface, method, args);
+  return __cn1NativeInterfaceArray(v, jvm.toNativeString(token));
+});
+
 // Worker liveness heartbeat (diag-only). If the worker wedges in a synchronous
 // green-thread step this timer CANNOT fire (single-threaded) and the heartbeat
 // STOPS; if the worker is merely parked/starved (idle, a host callback not