Add Swift and Kotlin native interface support (#4684)

This is part of the work on #3274
With this change native interfaces can be written in Swift for iOS and in Kotlin for Android. This is only on the local version and isn't yet supported in the build servers.

Author: liannacasper

CodenameOne/src/com/codename1/system/package-info.java

@@ -2,7 +2,7 @@
 /// [support for making platform native API calls](https://www.codenameone.com/how-do-i---access-native-device-functionality-invoke-native-interfaces.html). Notice
 /// that when we say "native" we do not mean C/C++ always but rather the platforms "native" environment. So in the
 /// case of Android the Java code will be invoked with full access to the Android API's, in case of iOS an Objective-C
-/// message would be sent and so forth.
+/// or Swift message would be sent and so forth.
 ///
 /// Native interfaces are designed to only allow primitive types, Strings, arrays (single dimension only!) of primitives
 /// and PeerComponent values. Any other type of parameter/return type is prohibited. However, once in the native layer
@@ -59,9 +59,9 @@
 /// These sources should be placed under the appropriate folder in the native directory and are sent to the
 /// server for compilation.
 ///
-/// For Objective-C, one would need to define a class matching the name of the package and the class name
-/// combined where the "." elements are replaced by underscores. One would need to provide both a header and
-/// an "m" file following this convention e.g.:
+/// For iOS, one would need to define a class matching the name of the package and the class name
+/// combined where the "." elements are replaced by underscores. This class can be implemented in Objective-C
+/// (by providing both a header and an "m" file) or in Swift. Objective-C classes follow this convention e.g.:
 ///
 /// ```java
 /// @interface com_my_code_MyNative : NSObject {

CodenameOne/src/com/codename1/system/package.html

@@ -8,8 +8,8 @@
     <a href="https://www.codenameone.com/how-do-i---access-native-device-functionality-invoke-native-interfaces.html">
         support for making platform native API calls</a>. Notice
     that when we say "native" we do not mean C/C++ always but rather the platforms "native" environment. So in the
-    case of Android the Java code will be invoked with full access to the Android API's, in case of iOS an Objective-C
-    message would be sent and so forth.
+    case of Android the Java code will be invoked with full access to the Android API's, in case of iOS an Objective-C
+    or Swift message would be sent and so forth.
 </p>
 <p>
     Native interfaces are designed to only allow primitive types, Strings, arrays (single dimension only!) of primitives
@@ -66,9 +66,9 @@
     server for compilation.
 </p>
 <p>
-    For Objective-C, one would need to define a class matching the name of the package and the class name
-    combined where the "." elements are replaced by underscores. One would need to provide both a header and
-    an "m" file following this convention e.g.:
+    For iOS, one would need to define a class matching the name of the package and the class name
+    combined where the "." elements are replaced by underscores. This class can be implemented in Objective-C
+    (by providing both a header and an "m" file) or in Swift. Objective-C classes follow this convention e.g.:
 </p>
 <pre>
 @interface com_my_code_MyNative : NSObject {

docs/developer-guide/Advanced-Topics-Under-The-Hood.asciidoc

@@ -684,7 +684,7 @@ Sometimes you may wish to use an API that is unsupported by Codename One or inte
 
 ==== Introduction
 
-Notice that when we say "native" we do not mean C/C++ always but rather the platforms "native" environment. So in the case of Android the Java code will be invoked with full access to the Android API, in case of iOS an Objective-C message would be sent and so forth.
+Notice that when we say "native" we do not mean C/C++ always but rather the platforms "native" environment. So in the case of Android, Java or Kotlin code can be invoked with full access to the Android API. In case of iOS, Objective-C or Swift code can be invoked and so forth.
 
 TIP: You can still access C code under Android either by using JNI from the Android native code or by using a library
 
@@ -747,7 +747,7 @@ include::../demos/common/src/main/java/com/mycompany/myapp/MyNativeImplStub.java
 
 The stub implementation always returns `false`, `null` or `0` by default. The `isSupported` also defaults to `false` thus allowing us to implement a `NativeInterface` on some platforms and leave the rest out without really knowing anything about these platforms.
 
-We can implement the Android version using code similar to this:
+We can implement the Android version in Java or Kotlin. Here is the Java version:
 
 [source,java]
 ----
@@ -768,7 +768,27 @@ Codename One doesn't include the native platforms in its bundle e.g. the full An
 
 TIP: When implementing a non-trivial native interface, send a server build with the "Include Source" option checked. Implement the native interface in the native IDE then copy and paste the native code back into Codename One
 
-The implementation of this interface is nearly identical for Android, J2ME & Java SE.
+The implementation of this interface is nearly identical for Android (Java/Kotlin), J2ME & Java SE.
+
+===== Swift (iOS) and Kotlin (Android) options
+
+For iOS native interfaces you can implement the generated `...Impl` class in Objective-C _or_ Swift. +
+For Android native interfaces you can implement the generated `...Impl` class in Java _or_ Kotlin.
+
+[cols="1,3",options="header"]
+|===
+| Platform
+| Typical file locations for native interface implementations
+
+| Android (Java/Kotlin)
+| `android/src/main/java/com/mycompany/myapp/MyNativeImpl.java` +
+`android/src/main/java/com/mycompany/myapp/MyNativeImpl.kt`
+
+| iOS (Objective-C/Swift)
+| `ios/src/main/objectivec/com_mycompany_myapp_MyNativeImpl.h` +
+`ios/src/main/objectivec/com_mycompany_myapp_MyNativeImpl.m` +
+`ios/src/main/objectivec/com_mycompany_myapp_MyNativeImpl.swift`
+|===
 
 ===== Use the Android Main Thread (Native EDT)
 
@@ -834,9 +854,10 @@ android.sdkVersion=25
 Once those were defined the native code for the Android implementation became trivial to write and the library was easy as there were no jars to include.
 
 
-==== Objective-C (iOS)
+==== Objective-C and Swift (iOS)
 
-When generating the Objective-C code the "Generate Native Sources" tool produces two files: `com_mycompany_myapp_MyNativeImpl.h` & `com_mycompany_myapp_MyNativeImpl.m`.
+When generating the Objective-C code the "Generate Native Sources" tool produces two files by default: `com_mycompany_myapp_MyNativeImpl.h` & `com_mycompany_myapp_MyNativeImpl.m`.
+If you enable Swift stub generation in the Maven goal, it can also produce `com_mycompany_myapp_MyNativeImpl.swift`.
 
 The `.m` files are the Objective-C equivalent of `.c` files and `.h` files contain the header/include information. In this case the `com_mycompany_myapp_MyNativeImpl.h` contains:
 
@@ -863,6 +884,8 @@ Here is a simple implementation similar to above:
 include::../demos/ios/src/main/objectivec/com_mycompany_myapp_MyNativeImpl.m[tag=myNativeImplExample,indent=0]
 ----
 
+If you prefer Swift for iOS native interfaces, keep the same class naming convention (`com_mycompany_myapp_MyNativeImpl`) and annotate the class with `@objc(...)` so the runtime can discover it.
+
 ===== Using the iOS Main Thread (Native EDT)
 
 iOS has a native thread you should use for all calls just like Android. Check out the Native EDT on Android section above for reference.

docs/developer-guide/appendix_goal_generate_native_interfaces.adoc

@@ -17,6 +17,15 @@ After creating this (and possibly other) native interfaces in our project,  run
 mvn cn1:generate-native-interfaces
 ----
 
+By default this generates Java/Objective-C stubs. You can optionally include Swift and Kotlin stubs (both off by default):
+
+[source,bash]
+----
+mvn cn1:generate-native-interfaces \
+  -Dcn1.generateNativeInterfaces.swift=true \
+  -Dcn1.generateNativeInterfaces.kotlin=true
+----
+
 This will generate the following files (if they don't exist yet).
 
 javase::
@@ -26,9 +35,12 @@ ios::
 . `ios/src/main/objectivec/com_mycompany_myapp_MyNativeImpl.m`
 android::
 `android/src/main/java/com/mycompany/myapp/MyNativeImpl.java`
+android (optional Kotlin)::
+`android/src/main/java/com/mycompany/myapp/MyNativeImpl.kt`
 javascript::
 `javascript/src/main/javascript/com_mycompany_myapp_MyNativeImpl.js`
+ios (optional Swift)::
+`ios/src/main/objectivec/com_mycompany_myapp_MyNativeImpl.swift`
 
 Open and edit these files to implement your native interface methods as desired.
 
-

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

@@ -41,7 +41,9 @@
 import java.awt.image.ImageProducer;
 import java.awt.image.RGBImageFilter;
 import java.io.*;
+import java.lang.reflect.Method;
 
+import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.nio.channels.FileChannel;
@@ -3972,6 +3974,117 @@ static String xmlize(String s) {
     }
 
 
+    @Override
+    protected String registerNativeImplementationsAndCreateStubs(ClassLoader parentClassLoader, File stubDir, File... classesDirectory) throws MalformedURLException, IOException {
+        Class[] discoveredNativeInterfaces = findNativeInterfaces(parentClassLoader, classesDirectory);
+        String registerNativeFunctions = "";
+        if (discoveredNativeInterfaces != null && discoveredNativeInterfaces.length > 0) {
+            for (Class n : discoveredNativeInterfaces) {
+                registerNativeFunctions += "        NativeLookup.register(" + n.getName() + ".class, "
+                        + n.getName() + "Stub.class" + ");\n";
+            }
+        }
+
+        if (discoveredNativeInterfaces != null && discoveredNativeInterfaces.length > 0) {
+            for (Class currentNative : discoveredNativeInterfaces) {
+                File folder = new File(stubDir, currentNative.getPackage().getName().replace('.', File.separatorChar));
+                folder.mkdirs();
+                File javaFile = new File(folder, currentNative.getSimpleName() + "Stub.java");
+
+                String javaImplSourceFile = "package " + currentNative.getPackage().getName() + ";\n\n"
+                        + "import com.codename1.ui.PeerComponent;\n\n"
+                        + "public class " + currentNative.getSimpleName() + "Stub implements " + currentNative.getSimpleName() + "{\n"
+                        + "    private final Object impl = createImpl();\n\n"
+                        + "    private static Object createImpl() {\n"
+                        + "        try {\n"
+                        + "            return Class.forName(\"" + currentNative.getName() + getImplSuffix() + "\").newInstance();\n"
+                        + "        } catch (Throwable t) {\n"
+                        + "            throw new RuntimeException(\"Failed to instantiate native implementation for " + currentNative.getName() + "\", t);\n"
+                        + "        }\n"
+                        + "    }\n\n"
+                        + "    private Object __cn1Invoke(String methodName, Object[] args) {\n"
+                        + "        try {\n"
+                        + "            java.lang.reflect.Method[] methods = impl.getClass().getMethods();\n"
+                        + "            for (java.lang.reflect.Method method : methods) {\n"
+                        + "                if (method.getName().equals(methodName) && method.getParameterTypes().length == args.length) {\n"
+                        + "                    return method.invoke(impl, args);\n"
+                        + "                }\n"
+                        + "            }\n"
+                        + "            throw new RuntimeException(methodName + \" with \" + args.length + \" args\");\n"
+                        + "        } catch (Throwable t) {\n"
+                        + "            throw new RuntimeException(\"Failed to invoke native method \" + methodName, t);\n"
+                        + "        }\n"
+                        + "    }\n\n";
+
+                for (Method m : currentNative.getMethods()) {
+                    String name = m.getName();
+                    if (name.equals("hashCode") || name.equals("equals") || name.equals("toString")) {
+                        continue;
+                    }
+
+                    Class returnType = m.getReturnType();
+
+                    javaImplSourceFile += "    public " + returnType.getSimpleName() + " " + name + "(";
+                    Class[] params = m.getParameterTypes();
+                    String args = "";
+                    if (params != null && params.length > 0) {
+                        for (int iter = 0; iter < params.length; iter++) {
+                            if (iter > 0) {
+                                javaImplSourceFile += ", ";
+                                args += ", ";
+                            }
+                            javaImplSourceFile += params[iter].getSimpleName() + " param" + iter;
+                            if (params[iter].getName().equals("com.codename1.ui.PeerComponent")) {
+                                args += convertPeerComponentToNative("param" + iter);
+                            } else {
+                                args += "param" + iter;
+                            }
+                        }
+                    }
+                    javaImplSourceFile += ") {\n";
+                    String invocationExpression = "__cn1Invoke(\"" + name + "\", new Object[]{" + args + "})";
+                    if (Void.class == returnType || Void.TYPE == returnType) {
+                        javaImplSourceFile += "        " + invocationExpression + ";\n    }\n\n";
+                    } else {
+                        if (returnType.getName().equals("com.codename1.ui.PeerComponent")) {
+                            javaImplSourceFile += "        return " + generatePeerComponentCreationCode(invocationExpression) + ";\n    }\n\n";
+                        } else if (returnType.isPrimitive()) {
+                            if (returnType == Boolean.TYPE) {
+                                javaImplSourceFile += "        return ((Boolean)" + invocationExpression + ").booleanValue();\n    }\n\n";
+                            } else if (returnType == Integer.TYPE) {
+                                javaImplSourceFile += "        return ((Integer)" + invocationExpression + ").intValue();\n    }\n\n";
+                            } else if (returnType == Long.TYPE) {
+                                javaImplSourceFile += "        return ((Long)" + invocationExpression + ").longValue();\n    }\n\n";
+                            } else if (returnType == Byte.TYPE) {
+                                javaImplSourceFile += "        return ((Byte)" + invocationExpression + ").byteValue();\n    }\n\n";
+                            } else if (returnType == Short.TYPE) {
+                                javaImplSourceFile += "        return ((Short)" + invocationExpression + ").shortValue();\n    }\n\n";
+                            } else if (returnType == Character.TYPE) {
+                                javaImplSourceFile += "        return ((Character)" + invocationExpression + ").charValue();\n    }\n\n";
+                            } else if (returnType == Float.TYPE) {
+                                javaImplSourceFile += "        return ((Float)" + invocationExpression + ").floatValue();\n    }\n\n";
+                            } else if (returnType == Double.TYPE) {
+                                javaImplSourceFile += "        return ((Double)" + invocationExpression + ").doubleValue();\n    }\n\n";
+                            } else {
+                                javaImplSourceFile += "        return (" + returnType.getSimpleName() + ")" + invocationExpression + ";\n    }\n\n";
+                            }
+                        } else {
+                            javaImplSourceFile += "        return (" + returnType.getSimpleName() + ")" + invocationExpression + ";\n    }\n\n";
+                        }
+                    }
+                }
+
+                javaImplSourceFile += "}\n";
+
+                try (FileOutputStream out = new FileOutputStream(javaFile)) {
+                    out.write(javaImplSourceFile.getBytes(StandardCharsets.UTF_8));
+                }
+            }
+        }
+
+        return registerNativeFunctions;
+    }
+
     @Override
     protected String generatePeerComponentCreationCode(String methodCallString) {
         return "PeerComponent.create(" + methodCallString + ")";