@mendix/native 10.1.2 → 10.1.4

package/androidlib/build.gradle

@@ -0,0 +1,2 @@
+configurations.maybeCreate("default")
+artifacts.add("default", file("mendixnative-release.aar"))

package/androidlib/mendix.gradle

@@ -0,0 +1,438 @@
+import groovy.json.JsonSlurper
+
+def LOG_PREFIX = ":Mendix: "
+
+def rootDir = buildscript.sourceFile.toString().split("node_modules")[0]
+def cliBinPath = "${rootDir}/node_modules/.bin/react-native${System.properties['os.name'].toLowerCase().contains('windows') ? ".cmd" : ""}"
+
+def generatedFilePackage = "com.mendix.nativetemplate"
+def mainActivityObserverFileName = "MendixActivityObserver.java"
+def mainActivityObserverTemplate = """package $generatedFilePackage;
+
+import android.content.Context;
+
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleObserver;
+import androidx.lifecycle.OnLifecycleEvent;
+{{imports}}
+
+public class MendixActivityObserver implements LifecycleObserver {
+    private final Context context;
+
+    public MendixActivityObserver(Context activity) {
+        this.context = activity;
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
+    void onCreate() {
+        {{onCreate}}
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
+    void onResume() {
+        {{onResume}}
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_START)
+    void onStart() {
+      {{onStart}}
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
+    void onPause() {
+        {{onPause}}
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
+    void onStop() {
+        {{onStop}}
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
+    void onDestroy() {
+        {{onDestroy}}
+    }
+}
+"""
+def mendixPackageListFileName = "MendixPackageList.java"
+def mendixPackageListTemplate = """package $generatedFilePackage;
+
+import android.app.Application;
+import android.content.Context;
+import android.content.res.Resources;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.shell.MainPackageConfig;
+import com.facebook.react.shell.MainReactPackage;
+import java.util.Arrays;
+import java.util.ArrayList;
+
+{{imports}}
+
+public class MendixPackageList {
+  private Application application;
+  
+  public MendixPackageList(Application application) {
+    this.application = application;
+  }
+
+  private Resources getResources() {
+    return this.getApplication().getResources();
+  }
+
+  private Application getApplication() {
+    return this.application;
+  }
+
+  private Context getApplicationContext() {
+    return this.getApplication().getApplicationContext();
+  }
+
+  public ArrayList<ReactPackage> getPackages() {
+    return new ArrayList<>(Arrays.<ReactPackage>asList(
+      {{packageClassInstances}}
+    ));
+  }
+}
+"""
+
+class MendixModules {
+    private static String LINE_ENDING_CHAR = "\n"
+
+    private String cliBinPath
+    private String rootDir
+    private String logPrefix
+    private Logger logger
+    private ArrayList<HashMap<String, String>> reactNativeModules
+    private Map dependenciesConfig = [:]
+    private File capabilitiesConfigFile
+    private File projectCapabilitiesFile
+    private File nodeModulesDependenciesConfigFile
+
+    MendixModules(File capabilitiesConfigFile, File nodeModulesDependenciesConfigFile, File projectCapabilitiesFile, String cliBinPath, String rootDir, Logger logger, String logPrefix) {
+        this.logger = logger
+        this.rootDir = rootDir
+        this.cliBinPath = cliBinPath
+        this.logPrefix = logPrefix
+        this.capabilitiesConfigFile = capabilitiesConfigFile
+        this.nodeModulesDependenciesConfigFile = nodeModulesDependenciesConfigFile
+        this.projectCapabilitiesFile = projectCapabilitiesFile
+
+        def (nativeModules) = this.getReactNativeConfig()
+        this.reactNativeModules = nativeModules
+        parseDependenciesConfig()
+    }
+
+    void printDependencies() {
+        this.reactNativeModules.each {
+            logDebug(it["name"])
+        }
+    }
+
+    void parseDependenciesConfig() {
+        def dependenciesConfig = [:]
+        def capabilitiesConfig = [:]
+
+        try {
+            capabilitiesConfig = new JsonSlurper().parse(this.capabilitiesConfigFile)
+            def projectCapabilities = new JsonSlurper().parse(this.projectCapabilitiesFile)
+            capabilitiesConfig.retainAll { capabilityConfig ->
+                projectCapabilities.find { enabledCapability ->
+                    enabledCapability.key == capabilityConfig.key && enabledCapability.value == true
+                } && capabilityConfig.value["android"] != null
+            }
+        } catch (ignored) {
+            this.logLifecycle("Failed parsing the capabilities file. Error?")
+        }
+
+        if (this.nodeModulesDependenciesConfigFile.exists()) {
+            try {
+                dependenciesConfig = new JsonSlurper().parse(this.nodeModulesDependenciesConfigFile)
+                (dependenciesConfig as Map).retainAll { dependencyConfig ->
+                    this.reactNativeModules.find { nativeModule ->
+                        nativeModule.get("name") == dependencyConfig.key
+                    } && dependencyConfig.value["android"] != null
+                }
+            } catch (ignored) {
+                this.logLifecycle("Failed parsing the configuration for unlinked node_modules. Error?")
+            }
+        }
+
+        this.dependenciesConfig = capabilitiesConfig + dependenciesConfig
+        printDependencies()
+    }
+
+    void generateMainActivityObserver(File outDir, String fileName, String template) {
+        def activityImports = []
+        def activityOnCreateEntries = []
+        def activityOnStartEntries = []
+        def activityOnResumeEntries = []
+        def activityOnPauseEntries = []
+        def activityOnStopEntries = []
+        def activityOnDestroyEntries = []
+
+        dependenciesConfig.each {
+            def mainActivityDelegateEntry = it.value["android"]["MainActivity"]
+            if (!mainActivityDelegateEntry)
+                return
+
+            def imports = mainActivityDelegateEntry.get("imports")
+            if (imports)
+                activityImports.addAll(imports)
+
+            def onCreateEntries = mainActivityDelegateEntry.get("onCreate")
+            if (onCreateEntries)
+                activityOnCreateEntries.addAll(onCreateEntries)
+
+            def onStartEntries = mainActivityDelegateEntry.get("onStart")
+            if (onStartEntries)
+                activityOnStartEntries.addAll(onStartEntries)
+
+            def onResumeEntries = mainActivityDelegateEntry.get("onResume")
+            if (onResumeEntries)
+                activityOnResumeEntries.addAll(onResumeEntries)
+
+            def onPauseEntries = mainActivityDelegateEntry.get("onPause")
+            if (onPauseEntries)
+                activityOnPauseEntries.addAll(onPauseEntries)
+
+            def onStopEntries = mainActivityDelegateEntry.get("onStop")
+            if (onStopEntries)
+                activityOnStopEntries.addAll(onStopEntries)
+
+            def onDestroyEntries = mainActivityDelegateEntry.get("onDestroy")
+            if (onDestroyEntries)
+                activityOnDestroyEntries.addAll(onDestroyEntries)
+        }
+
+        String CODE_PADDING = "${LINE_ENDING_CHAR}        "
+        String generatedFileContents = template
+                .replace("{{imports}}", activityImports.join(LINE_ENDING_CHAR))
+                .replace("{{onCreate}}", activityOnCreateEntries.join(CODE_PADDING))
+                .replace("{{onStart}}", activityOnStartEntries.join(CODE_PADDING))
+                .replace("{{onResume}}", activityOnResumeEntries.join(CODE_PADDING))
+                .replace("{{onPause}}", activityOnPauseEntries.join(CODE_PADDING))
+                .replace("{{onStop}}", activityOnStopEntries.join(CODE_PADDING))
+                .replace("{{onDestroy}}", activityOnDestroyEntries.join(CODE_PADDING))
+
+        outDir.mkdirs()
+        new FileTreeBuilder(outDir).file(fileName).newWriter().withWriter {
+            w ->
+                w << generatedFileContents
+        }
+    }
+
+    void generateMendixPackageList(File outDir, String fileName, String template) {
+        String CODE_PADDING = "${LINE_ENDING_CHAR}      "
+        def imports = []
+        def entries = []
+        def entrySeparator = "," + CODE_PADDING
+        dependenciesConfig.each {
+            def packageListEntry = it.value["android"]["packageListEntries"]
+            if (packageListEntry) {
+                def importsEntry = packageListEntry["imports"]
+                def packageClassInstances = packageListEntry["packageClassInstances"]
+                if (importsEntry)
+                    imports.addAll(importsEntry)
+                if (packageClassInstances)
+                    entries.addAll(packageClassInstances)
+            }
+        }
+
+        String generatedFileContents = template.replace("{{imports}}", imports.join(CODE_PADDING)).replace("{{packageClassInstances}}", entries.join(entrySeparator))
+
+        outDir.mkdirs()
+        new FileTreeBuilder(outDir).file(fileName).newWriter().withWriter {
+            w ->
+                w << generatedFileContents
+        }
+    }
+
+    void addClassPaths(Project project) {
+        project.buildscript {
+            dependencies {
+                dependenciesConfig.each {
+                    def gradle = (it.value as Object)["android"]["gradle"]
+                    if (!gradle) {
+                        return
+                    }
+                    def customClassPaths = gradle.get("classpaths") as ArrayList<String>
+                    customClassPaths.each { customClassPath ->
+                        this.logLifecycle("Adding classPath ${customClassPath}")
+                        classpath(customClassPath)
+                    }
+                }
+            }
+        }
+    }
+
+    void addExtraDependencies(Project project) {
+        project.dependencies {
+            dependenciesConfig.each {
+                def dependencies = it.value["android"]["externalDependencies"] as ArrayList<String>
+                dependencies.each { dependency ->
+                    this.logLifecycle("Registering extra library ${dependency}")
+                    implementation(dependency)
+                }
+            }
+        }
+    }
+
+    void addAndroidPlugins(Project project) {
+        dependenciesConfig.each {
+            def gradleConfig = it.value["android"]["gradle"]
+            if (!gradleConfig)
+                return
+
+            def dependencies = gradleConfig["plugins"] as ArrayList<String>
+            if (!dependencies)
+                return
+
+            dependencies.each { plugin ->
+                this.logLifecycle("Adding plugin ${plugin}")
+                project.getPluginManager().apply(plugin)
+            }
+        }
+    }
+
+    void logDebug(String message) {
+        this.logger.debug("${this.logPrefix}${message}")
+    }
+
+    void logLifecycle(String message) {
+        this.logger.lifecycle("${this.logPrefix}${message}")
+    }
+
+    void logError(String message) {
+        this.logger.error("${this.logPrefix}${message}")
+    }
+
+    /**
+     * Runs a specified command using Runtime exec() in a specified directory.
+     * Throws when the command result is empty.
+     */
+    String getCommandOutput(String[] command, File directory) {
+        try {
+            def output = ""
+            def cmdProcess = Runtime.getRuntime().exec(command, null, directory)
+            def bufferedReader = new BufferedReader(new InputStreamReader(cmdProcess.getInputStream()))
+            def buff = ""
+            def readBuffer = new StringBuffer()
+            while ((buff = bufferedReader.readLine()) != null) {
+                readBuffer.append(buff)
+            }
+            output = readBuffer.toString()
+            if (!output) {
+                this.logger.error("${logPrefix}Unexpected empty result of running '${command}' command.")
+                def bufferedErrorReader = new BufferedReader(new InputStreamReader(cmdProcess.getErrorStream()))
+                def errBuff = ""
+                def readErrorBuffer = new StringBuffer()
+                while ((errBuff = bufferedErrorReader.readLine()) != null) {
+                    readErrorBuffer.append(errBuff)
+                }
+                throw new Exception(readErrorBuffer.toString())
+            }
+            return output
+        } catch (Exception exception) {
+            this.logError("Running '${command}' command failed.")
+            throw exception
+        }
+    }
+
+    /**
+     * Runs a process to call the React Native CLI Config command and parses the output
+     */
+    ArrayList<HashMap<String, String>> getReactNativeConfig() {
+        if (this.reactNativeModules != null) return this.reactNativeModules
+
+        ArrayList<HashMap<String, String>> reactNativeModules = new ArrayList<HashMap<String, String>>()
+
+        String[] reactNativeConfigCommand = [this.cliBinPath, "config"]
+        def reactNativeConfigOutput = this.getCommandOutput(reactNativeConfigCommand, new File(this.rootDir))
+
+        def json
+        try {
+            json = new JsonSlurper().parseText(reactNativeConfigOutput)
+        } catch (Exception exception) {
+            throw new Exception("Calling `${reactNativeConfigCommand}` finished with an exception. Error message: ${exception.toString()}. Output: ${reactNativeConfigOutput}");
+        }
+        def dependencies = json["dependencies"]
+        def project = json["project"]["android"]
+
+        if (project == null) {
+            throw new Exception("React Native CLI failed to determine Android project configuration. This is likely due to misconfiguration. Config output:\n${json.toMapString()}")
+        }
+
+        dependencies.each { name, value ->
+            def platformsConfig = value["platforms"];
+            def androidConfig = platformsConfig["android"]
+
+            if (androidConfig != null && androidConfig["sourceDir"] != null) {
+                this.logger.info("${logPrefix}Automatically adding native module '${name}'")
+
+                HashMap reactNativeModuleConfig = new HashMap<String, String>()
+                reactNativeModuleConfig.put("name", name)
+                reactNativeModuleConfig.put("nameCleansed", name.replaceAll('^@([\\w-]+)/', '$1_'))
+                reactNativeModuleConfig.put("androidSourceDir", androidConfig["sourceDir"])
+                reactNativeModuleConfig.put("packageInstance", androidConfig["packageInstance"])
+                reactNativeModuleConfig.put("packageImportPath", androidConfig["packageImportPath"])
+                this.logger.trace("${logPrefix}'${name}': ${reactNativeModuleConfig.toMapString()}")
+
+                reactNativeModules.add(reactNativeModuleConfig)
+            } else {
+                this.logger.info("${logPrefix}Skipping native module '${name}'")
+            }
+        }
+
+        return [reactNativeModules, json["project"]["android"]["packageName"]];
+    }
+}
+
+def generatedSrcDir = new File(buildDir, "generated/mendix/src/main/java")
+def generatedCodeDir = new File(generatedSrcDir, generatedFilePackage.replace('.', '/'))
+
+def capabilitiesConfig = new File("${rootDir}capabilities-setup-config.json")
+def unlinkedDependenciesConfigFile = new File("${rootDir}unlinked-dependency-config.json")
+def capabilitiesFile = new File("${rootDir}capabilities.android.json")
+def mendixModules = new MendixModules(capabilitiesConfig, unlinkedDependenciesConfigFile, capabilitiesFile, cliBinPath, rootDir, logger, LOG_PREFIX)
+
+def logLifecycle = { String message -> logger.lifecycle("${LOG_PREFIX}${message}") }
+
+
+ext.applyMendixGradle = { Project project ->
+    logLifecycle("Registering extra dependencies")
+    mendixModules.addExtraDependencies(project)
+
+    logLifecycle("Registering plugins")
+    mendixModules.addAndroidPlugins(project)
+    task generateMendixDependencies {
+        doLast {
+            logLifecycle("Executing Mendix Module Generator")
+            logLifecycle("App root: ${rootDir}")
+            logLifecycle("CLI path: ${cliBinPath}")
+
+            logLifecycle("Generating ${mainActivityObserverFileName}")
+            mendixModules.generateMainActivityObserver(generatedCodeDir, mainActivityObserverFileName, mainActivityObserverTemplate)
+
+            logLifecycle("Generating ${mendixPackageListFileName}")
+            mendixModules.generateMendixPackageList(generatedCodeDir, mendixPackageListFileName, mendixPackageListTemplate)
+        }
+    }
+
+    preBuild.dependsOn generateMendixDependencies
+
+    android {
+        sourceSets {
+            main {
+                java {
+                    srcDirs += generatedSrcDir
+                }
+            }
+        }
+    }
+}
+
+ext.applyMendixClassPaths = { Project project ->
+    logLifecycle("Registering class paths")
+    mendixModules.addClassPaths(project)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mendix/native",
-  "version": "10.1.2",
+  "version": "10.1.4",
   "copyright": "© Mendix Technology BV. All rights reserved.",
   "files": [
     "androidlib/",