@mendix/native 1.0.0

package/LICENSE.md

@@ -0,0 +1,19 @@
+Copyright (c) Mendix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/android/build.gradle

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

package/android/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) {
+        try {
+            def output = ""
+            def cmdProcess = Runtime.getRuntime().exec(command)
+            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)
+
+        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/ios/mendixnative.xcframework/Info.plist

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>HeadersPath</key>
+			<string>Headers</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>libMendixNative.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+		<dict>
+			<key>HeadersPath</key>
+			<string>Headers</string>
+			<key>LibraryIdentifier</key>
+			<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>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>

package/ios/mendixnative.xcframework/ios-arm64/Headers/AppMenuProtocol.h

@@ -0,0 +1,10 @@
+//
+//  Copyright (c) Mendix, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@protocol AppMenuProtocol
+@required
+-(void) show:(BOOL)devMode;
+@end

package/ios/mendixnative.xcframework/ios-arm64/Headers/AppPreferences.h

@@ -0,0 +1,18 @@
+//
+//  Copyright (c) Mendix, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@interface AppPreferences : NSObject
++ (NSString *) getAppUrl;
++ (void) setAppUrl:(NSString *)url;
++ (BOOL) devModeEnabled;
++ (void) devMode:(BOOL)enable;
++ (BOOL) remoteDebuggingEnabled;
++ (void) remoteDebugging:(BOOL)enable;
++ (void) setRemoteDebuggingPackagerPort:(NSInteger)port;
++ (int) getRemoteDebuggingPackagerPort;
++ (BOOL) isElementInspectorEnabled;
++ (void) setElementInspector:(BOOL)enable;
+@end

package/ios/mendixnative.xcframework/ios-arm64/Headers/AppUrl.h

@@ -0,0 +1,16 @@
+//
+//  Copyright (c) Mendix, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@interface AppUrl: NSObject
++ (int) defaultPackagerPort;
+
++ (NSURL *) forBundle:(NSString *)url port:(int)port isDebuggingRemotely:(BOOL)isDebuggingRemotely isDevModeEnabled:(BOOL)isDevModeEnabled;
++ (NSURL *) forRuntime:(NSString *)url;
++ (NSURL *) forValidation:(NSString*)url;
++ (NSURL *) forRuntimeInfo:(NSString*)url;
++ (NSURL *) forPackagerStatus:(NSString*)url port:(int)port;
++ (BOOL) isValid:(NSString*)url;
+@end

package/ios/mendixnative.xcframework/ios-arm64/Headers/DevAppMenuUIAlertController.h

@@ -0,0 +1,7 @@
+//
+//  Copyright (c) Mendix, Inc. All rights reserved.
+//
+#import <UIKit/UIKit.h>
+
+@interface DevAppMenuUIAlertController : UIAlertController
+@end

package/ios/mendixnative.xcframework/ios-arm64/Headers/JSBundleFileProviderProtocol.h

@@ -0,0 +1,9 @@
+//
+//  Copyright (c) Mendix, Inc. All rights reserved.
+//
+
+@protocol JSBundleFileProviderProtocol <NSObject>
+
++ (nullable NSURL *)getBundleUrl;
+
+@end

package/ios/mendixnative.xcframework/ios-arm64/Headers/MendixApp.h

@@ -0,0 +1,33 @@
+//
+//  Copyright (c) Mendix, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import "AppMenuProtocol.h"
+#import "SplashScreenPresenterProtocol.h"
+#import "WarningsFilter.h"
+
+@interface MendixApp : NSObject
+@property NSURL * _Nonnull bundleUrl;
+@property NSURL  * _Nonnull runtimeUrl;
+@property WarningsFilter warningsFilter;
+@property NSString * _Nullable identifier;
+@property BOOL isDeveloperApp;
+@property BOOL clearDataAtLaunch;
+@property id<AppMenuProtocol> _Nullable appMenu;
+@property id<SplashScreenPresenterProtocol> _Nullable splashScreenPresenter;
+@property UIStoryboard * _Nullable reactLoading;
+@property BOOL enableThreeFingerGestures;
+
+-(id _Nonnull)init:(NSString * _Nullable)identifier bundleUrl:(NSURL * _Nonnull)bundleUrl runtimeUrl:(NSURL * _Nonnull)runtimeUrl warningsFilter:(WarningsFilter)warningsFilter isDeveloperApp:(BOOL)enableGestures clearDataAtLaunch:(BOOL)clearDataAtLaunch splashScreenPresenter:(id<SplashScreenPresenterProtocol> _Nonnull)splashScreenPresenter;
+
+-(id _Nonnull)init:(NSString * _Nullable)identifier bundleUrl:(NSURL * _Nonnull)bundleUrl runtimeUrl:(NSURL * _Nonnull)runtimeUrl warningsFilter:(WarningsFilter)warningsFilter isDeveloperApp:(BOOL)enableGestures clearDataAtLaunch:(BOOL)clearDataAtLaunch reactLoading:(UIStoryboard * _Nonnull)reactLoading;
+
+-(id _Nonnull)init:(NSString * _Nullable)identifier bundleUrl:(NSURL * _Nonnull)bundleUrl runtimeUrl:(NSURL * _Nonnull)runtimeUrl warningsFilter:(WarningsFilter)warningsFilter isDeveloperApp:(BOOL)enableGestures clearDataAtLaunch:(BOOL)clearDataAtLaunch splashScreenPresenter:(id<SplashScreenPresenterProtocol> _Nonnull)splashScreenPresenter enableThreeFingerGestures:(BOOL)enableThreeFingerGestures ;
+
+-(id _Nonnull)init:(NSString * _Nullable)identifier bundleUrl:(NSURL * _Nonnull)bundleUrl runtimeUrl:(NSURL * _Nonnull)runtimeUrl warningsFilter:(WarningsFilter)warningsFilter isDeveloperApp:(BOOL)enableGestures clearDataAtLaunch:(BOOL)clearDataAtLaunch reactLoading:(UIStoryboard * _Nonnull)reactLoading enableThreeFingerGestures:(BOOL)enableThreeFingerGestures;
+
+-(id _Nonnull)init:(NSString * _Nullable)identifier bundleUrl:(NSURL * _Nonnull)bundleUrl runtimeUrl:(NSURL * _Nonnull)runtimeUrl warningsFilter:(WarningsFilter)warningsFilter isDeveloperApp:(BOOL)enableGestures clearDataAtLaunch:(BOOL)clearDataAtLaunch;
+
+@end

package/ios/mendixnative.xcframework/ios-arm64/Headers/MendixBackwardsCompatUtility.h

@@ -0,0 +1,14 @@
+//
+//  Copyright (c) Mendix, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "UnsupportedFeatures.h"
+
+extern const UnsupportedFeatures *DEFAULT_UNSUPPORTED_FEATURES;
+
+@interface MendixBackwardsCompatUtility: NSObject
++ (NSDictionary<NSString *, UnsupportedFeatures *> *) versionDictionary;
++ (UnsupportedFeatures *) unsupportedFeatures;
++ (void) update:(NSString *)forVersion;
+@end

package/ios/mendixnative.xcframework/ios-arm64/Headers/MendixNative.h

@@ -0,0 +1,20 @@
+//
+//  Copyright (c) Mendix B.V., Inc. All rights reserved.
+//
+
+#import "AppMenuProtocol.h"
+#import "AppPreferences.h"
+#import "AppUrl.h"
+#import "MxConfiguration.h"
+#import "MendixApp.h"
+#import "NativeReloadHandler.h"
+#import "ReactNative.h"
+#import "WarningsFilter.h"
+#import "SplashScreenPresenterProtocol.h"
+#import "MendixReactWindow.h"
+#import "MendixBackwardsCompatUtility.h"
+#import "RuntimeInfoProvider.h"
+#import "NativeDownloadHandler.h"
+#import "DevAppMenuUIAlertController.h"
+#import "JSBundleFileProviderProtocol.h"
+#import "OtaJSBundleFileProvider.h"

package/ios/mendixnative.xcframework/ios-arm64/Headers/MendixReactWindow.h

@@ -0,0 +1,10 @@
+//
+//  Copyright (c) Mendix, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "UIKit/UIKit.h"
+
+@interface MendixReactWindow : UIWindow
+
+@end