@mendix/native 10.1.1 → 10.1.2

package/ios/mendixnative.xcframework/Info.plist

@@ -10,18 +10,15 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libMendixNative.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
@@ -29,15 +26,18 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libMendixNative.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/package.json

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

package/androidlib/build.gradle

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

package/androidlib/mendix.gradle

@@ -1,438 +0,0 @@
-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)
-}