Add option to not include native libraries in APK

Sometimes it is not desirable to include the libraries in the APK,
e.g. system and vendor apps could prefer having one set of libraries
installed on the device. If unbundled deployment is specified,
native libraries will not be included in the APK.

With unbundled deployment, optional arguments can be passed to
set the path to load the libraries on the device.

[ChangeLog][Android][Deployment Changes] Adds option for Unbundled
deployment, where native libraries are not packaged in the APK.

Task-number: QAA-771
Change-Id: Ica51ef83a24dad58c7586bf610a58abe21fc1100
Reviewed-by: Assam Boudjelthia <assam.boudjelthia@qt.io>

8 files changed, 206 insertions, 60 deletions

diff --git a/src/android/java/src/org/qtproject/qt/android/bindings/QtLoader.java b/src/android/java/src/org/qtproject/qt/android/bindings/QtLoader.java
index 81304e23f6..66ba029ace 100644
--- a/src/android/java/src/org/qtproject/qt/android/bindings/QtLoader.java
+++ b/src/android/java/src/org/qtproject/qt/android/bindings/QtLoader.java
@@ -76,7 +76,6 @@ public abstract class QtLoader {
 
     // These parameters matter in case of deploying application as system (embedded into firmware)
     public static final String SYSTEM_LIB_PATH = "/system/lib/";
-    public String[] SYSTEM_APP_PATHS = {"/system/priv-app/", "/system/app/"};
 
     public String APPLICATION_PARAMETERS = null; // use this variable to pass any parameters to your application,
     // the parameters must not contain any white spaces
@@ -255,33 +254,40 @@ public abstract class QtLoader {
 
             if (useLocalLibs == 1) {
                 ArrayList<String> libraryList = new ArrayList<>();
-
-                boolean apkDeployFromSystem = false;
-                String apkPath = m_context.getApplicationInfo().publicSourceDir;
-                File apkFile = new File(apkPath);
-                if (apkFile.exists()) {
-                    for (String systemAppPath : SYSTEM_APP_PATHS) {
-                        apkDeployFromSystem = apkFile.getAbsolutePath().startsWith(systemAppPath);
-                        if (apkDeployFromSystem)
-                            break;
-                    }
-                }
-
                 String libsDir = null;
                 String bundledLibsDir = null;
-                if (apkDeployFromSystem) {
-                    String systemLibsPrefix = SYSTEM_LIB_PATH;
-                    if (m_contextInfo.metaData.containsKey("android.app.system_libs_prefix")) {
-                        systemLibsPrefix = m_contextInfo.metaData.getString("android.app.system_libs_prefix");
+
+                id = resources.getIdentifier("bundle_local_qt_libs", "string", packageName);
+                final int bundleLocalLibs = Integer.parseInt(resources.getString(id));
+                if (bundleLocalLibs == 0) {
+                    String systemLibsPrefix;
+                    final String systemLibsKey = "android.app.system_libs_prefix";
+                    // First check if user has provided system libs prefix in AndroidManifest
+                    if (m_contextInfo.applicationInfo.metaData != null &&
+                            m_contextInfo.applicationInfo.metaData.containsKey(systemLibsKey)) {
+                        systemLibsPrefix = m_contextInfo.applicationInfo.metaData.getString(systemLibsKey);
                     } else {
-                        Log.e(QtApplication.QtTAG, "It looks like app deployed as system app. "
-                            + "It may be necessary to specify path to system lib directory using "
-                            + "android.app.system_libs_prefix metadata variable in your AndroidManifest.xml");
+                        // If not, check if it's provided by androiddeployqt in libs.xml
+                        id = resources.getIdentifier("system_libs_prefix","string",
+                                packageName);
+                        systemLibsPrefix = resources.getString(id);
+                    }
+                    if (systemLibsPrefix.isEmpty()) {
+                        systemLibsPrefix = SYSTEM_LIB_PATH;
+                        Log.e(QtApplication.QtTAG, "It looks like app deployed using Unbundled "
+                                + "deployment. It may be necessary to specify path to directory "
+                                + "where Qt libraries are installed using either "
+                                + "android.app.system_libs_prefix metadata variable in your "
+                                + "AndroidManifest.xml or QT_ANDROID_SYSTEM_LIBS_PATH in your "
+                                + "CMakeLists.txt");
                         Log.e(QtApplication.QtTAG, "Using " + SYSTEM_LIB_PATH + " as default path");
                     }
+
                     File systemLibraryDir = new File(systemLibsPrefix);
-                    if (systemLibraryDir.exists() && systemLibraryDir.isDirectory() && systemLibraryDir.list().length > 0) {
+                    if (systemLibraryDir.exists() && systemLibraryDir.isDirectory()
+                            && systemLibraryDir.list().length > 0) {
                         libsDir = systemLibsPrefix;
+                        bundledLibsDir = systemLibsPrefix;
                     } else {
                         Log.e(QtApplication.QtTAG,
                               "System library directory " + systemLibsPrefix
@@ -300,7 +306,7 @@ public abstract class QtLoader {
                     }
                 }
 
-                if (apkDeployFromSystem && libsDir == null)
+                if (libsDir == null)
                     throw new Exception("");
 
 
@@ -310,20 +316,17 @@ public abstract class QtLoader {
                         libraryList.add(libPrefix + lib + ".so");
                 }
 
-                id = resources.getIdentifier("bundle_local_qt_libs", "string", packageName);
-                final int bundleLocalLibs = Integer.parseInt(resources.getString(id));
-
-                if (bundleLocalLibs == 1) {
-                    id = resources.getIdentifier("load_local_libs", "array", packageName);
-                    ArrayList<String> localLibs = prefferedAbiLibs(resources.getStringArray(id));
-                    for (String libs : localLibs) {
-                        for (String lib : libs.split(":")) {
-                            if (!lib.isEmpty())
-                                libraryList.add(libsDir + lib);
-                        }
+                id = resources.getIdentifier("load_local_libs", "array", packageName);
+                ArrayList<String> localLibs = prefferedAbiLibs(resources.getStringArray(id));
+                for (String libs : localLibs) {
+                    for (String lib : libs.split(":")) {
+                        if (!lib.isEmpty())
+                            libraryList.add(libsDir + lib);
                     }
-                    if (bundledLibsDir != null)
-                        ENVIRONMENT_VARIABLES += "\tQT_BUNDLED_LIBS_PATH=" + bundledLibsDir;
+                }
+                if (bundledLibsDir != null) {
+                    ENVIRONMENT_VARIABLES += "\tQT_PLUGIN_PATH=" + bundledLibsDir;
+                    ENVIRONMENT_VARIABLES += "\tQML_PLUGIN_PATH=" + bundledLibsDir;
                 }
 
                 Bundle loaderParams = new Bundle();
diff --git a/src/android/templates/doc/src/android-manifest-file-configuration.qdoc b/src/android/templates/doc/src/android-manifest-file-configuration.qdoc
index f1ceee9205..c784040f45 100644
--- a/src/android/templates/doc/src/android-manifest-file-configuration.qdoc
+++ b/src/android/templates/doc/src/android-manifest-file-configuration.qdoc
@@ -145,7 +145,7 @@ The following is a list of such meta-data defined by Qt:
 
 \table
 \header
-    \li meta-data name
+    \li Meta-data Name
     \li Description
 \row
     \target android.app.lib_name
@@ -199,11 +199,23 @@ The following is a list of such meta-data defined by Qt:
         by the app.
         For more information, see
         \l {QNativeInterface::}{QAndroidApplication::hideSplashScreen()}.
+\endtable
+
+\section2 Application Specific Meta-data
+
+Some meta-data attributes are application-wide, and should be placed under
+the \c <application> section:
+
+\table
+\header
+    \li Meta-data Name
+    \li Description
 \row
     \target android.app.system_libs_prefix
     \li android.app.system_libs_prefix
     \li Specifies a custom system library path to use for library loading lookup.
-        This is necessary when running as a system app.
+        This is necessary when using Qt libraries installed outside an app's
+        default native (JNI) library directory.
         The default value is \c {/system/lib/}.
 \endtable
 
@@ -216,7 +228,6 @@ The main ones are:
     \li \l {android.app.lib_name}
     \li \l {android.app.background_running}
     \li \l {android.app.arguments}
-    \li \l {android.app.system_libs_prefix}
 \endlist
 
 \section2 Qt Permissions and Features
diff --git a/src/android/templates/res/values/libs.xml b/src/android/templates/res/values/libs.xml
index beb15ca1d8..fe63866f72 100644
--- a/src/android/templates/res/values/libs.xml
+++ b/src/android/templates/res/values/libs.xml
@@ -17,4 +17,5 @@
     <string name="static_init_classes"><!-- %%INSERT_INIT_CLASSES%% --></string>
     <string name="use_local_qt_libs"><!-- %%USE_LOCAL_QT_LIBS%% --></string>
     <string name="bundle_local_qt_libs"><!-- %%BUNDLE_LOCAL_QT_LIBS%% --></string>
+    <string name="system_libs_prefix"><!-- %%SYSTEM_LIBS_PREFIX%% --></string>
 </resources>
diff --git a/src/corelib/Qt6AndroidMacros.cmake b/src/corelib/Qt6AndroidMacros.cmake
index 6804b942c2..cf996ebb4c 100644
--- a/src/corelib/Qt6AndroidMacros.cmake
+++ b/src/corelib/Qt6AndroidMacros.cmake
@@ -214,6 +214,10 @@ function(qt6_android_generate_deployment_settings target)
     _qt_internal_add_android_deployment_multi_value_property(file_contents "android-extra-libs"
         ${target} "_qt_android_native_extra_libs" )
 
+    # Alternative path to Qt libraries on target device
+    _qt_internal_add_android_deployment_property(file_contents "android-system-libs-prefix"
+        ${target} "QT_ANDROID_SYSTEM_LIBS_PREFIX")
+
     # package source dir
     _qt_internal_add_android_deployment_property(file_contents "android-package-source-directory"
         ${target} "_qt_android_native_package_source_dir")
@@ -234,6 +238,10 @@ function(qt6_android_generate_deployment_settings target)
     _qt_internal_add_android_deployment_property(file_contents "android-target-sdk-version"
         ${target} "QT_ANDROID_TARGET_SDK_VERSION")
 
+    # should Qt shared libs be excluded from deployment
+    _qt_internal_add_android_deployment_property(file_contents "android-no-deploy-qt-libs"
+        ${target} "QT_ANDROID_NO_DEPLOY_QT_LIBS")
+
     # App binary
     string(APPEND file_contents
         "   \"application-binary\": \"${target_output_name}\",\n")
diff --git a/src/corelib/doc/src/cmake/cmake-properties.qdoc b/src/corelib/doc/src/cmake/cmake-properties.qdoc
index 9f2e2aed75..bbb948aec2 100644
--- a/src/corelib/doc/src/cmake/cmake-properties.qdoc
+++ b/src/corelib/doc/src/cmake/cmake-properties.qdoc
@@ -297,6 +297,45 @@ and overwritten by that command.
 */
 
 /*!
+\page cmake-target-property-QT_ANDROID_SYSTEM_LIBS_PREFIX.html
+\ingroup cmake-properties-qtcore
+\ingroup cmake-target-properties-qtcore
+
+\title QT_ANDROID_SYSTEM_LIBS_PREFIX
+\target cmake-target-property-QT_ANDROID_SYSTEM_LIBS_PREFIX
+
+\summary {Specifies the location of Qt libraries on the target device.}
+
+\preliminarycmakeproperty
+\cmakepropertyandroidonly
+
+This property can be set to provide a path to Qt libraries on the target device,
+when those libraries are installed outside app's native (JNI) library directory.
+*/
+
+/*!
+\page cmake-target-property-QT_ANDROID_NO_DEPLOY_QT_LIBS.html
+\ingroup cmake-properties-qtcore
+\ingroup cmake-target-properties-qtcore
+
+\title QT_ANDROID_NO_DEPLOY_QT_LIBS
+\target cmake-target-property-QT_ANDROID_NO_DEPLOY_QT_LIBS
+
+\summary {Whether Qt shared libraries are packaged in the APK on Android.}
+
+\preliminarycmakeproperty
+\cmakepropertyandroidonly
+
+This property can be set to not package Qt shared libraries inside the APK when
+deploying the target. Use
+\l{cmake-target-property-QT_ANDROID_SYSTEM_LIBS_PREFIX}{QT_ANDROID_SYSTEM_LIBS_PREFIX}
+to provide a path to where those libraries will be located on the target device
+instead.
+
+\note Only supported when deploying as an APK.
+*/
+
+/*!
 \page cmake-target-property-qt_no_entrypoint.html
 \ingroup cmake-properties-qtcore
 \ingroup cmake-target-properties-qtcore
diff --git a/src/corelib/kernel/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp
index ca6f55f476..9937e018f6 100644
--- a/src/corelib/kernel/qcoreapplication.cpp
+++ b/src/corelib/kernel/qcoreapplication.cpp
@@ -2733,9 +2733,6 @@ QStringList QCoreApplication::libraryPathsLocked()
             }
         };
         setPathsFromEnv(qEnvironmentVariable("QT_PLUGIN_PATH"));
-#ifdef Q_OS_ANDROID
-        setPathsFromEnv(qEnvironmentVariable("QT_BUNDLED_LIBS_PATH"));
-#endif
 #ifdef Q_OS_DARWIN
         // Check the main bundle's PlugIns directory as this is a standard location for Apple OSes.
         // Note that the QLibraryInfo::PluginsPath below will coincidentally be the same as this value
diff --git a/src/tools/androiddeployqt/doc/src/androiddeployqt.qdoc b/src/tools/androiddeployqt/doc/src/androiddeployqt.qdoc
index 04340257ce..8230d3a398 100644
--- a/src/tools/androiddeployqt/doc/src/androiddeployqt.qdoc
+++ b/src/tools/androiddeployqt/doc/src/androiddeployqt.qdoc
@@ -72,6 +72,32 @@
             \li \c{--deployment <mechanism>}
             \li Specify this to pick a different deployment mechanism than the
                 default.
+                \list
+                    \li \c Bundled: includes all the app's dependencies inside
+                        the APK.
+                    \li \c Unbundled: excludes native libraries from the APK.
+                        The libraries are expected to be present on the target
+                        device. The location can be provided either by setting
+                        the property
+                        \l{cmake-target-property-QT_ANDROID_SYSTEM_LIBS_PREFIX}{QT_ANDROID_SYSTEM_LIBS_PREFIX}
+                        in your CMake project file, or by defining the path as
+                        meta-data in
+                        \l {Qt Android Manifest File Configuration}{AndroidManifest.xml}:
+                        \badcode
+                        <application>
+                            <meta-data
+                                android:name="system_libs_prefix"
+                                android:value="path/to/libraries/"/>
+                        </application>
+                        \endcode
+                        If no path is provided, \c /system/lib/ is used as the
+                        default path.
+                        \note \c Unbundled deployment does not support
+                            incremental builds.
+                        \note \c Unbundled deployment not supported when
+                            deploying as AAB.
+                \endlist
+                Default is \c Bundled deployment.
         \row
             \li \c{--install}
             \li Specify this to install the finished package on the target device
diff --git a/src/tools/androiddeployqt/main.cpp b/src/tools/androiddeployqt/main.cpp
index 612683c974..dbb4bbd24e 100644
--- a/src/tools/androiddeployqt/main.cpp
+++ b/src/tools/androiddeployqt/main.cpp
@@ -101,7 +101,8 @@ struct Options
 
     enum DeploymentMechanism
     {
-        Bundled
+        Bundled,
+        Unbundled
     };
 
     enum TriState {
@@ -167,6 +168,7 @@ struct Options
 
     // Package information
     DeploymentMechanism deploymentMechanism;
+    QString systemLibsPath;
     QString packageName;
     QStringList extraLibs;
     QHash<QString, QStringList> archExtraLibs;
@@ -337,7 +339,6 @@ void deleteMissingFiles(const Options &options, const QDir &srcDir, const QDir &
     fflush(stdout);
 }
 
-
 Options parseOptions()
 {
     Options options;
@@ -383,6 +384,9 @@ Options parseOptions()
                 QString deploymentMechanism = arguments.at(++i);
                 if (deploymentMechanism.compare("bundled"_L1, Qt::CaseInsensitive) == 0) {
                     options.deploymentMechanism = Options::Bundled;
+                } else if (deploymentMechanism.compare("unbundled"_L1,
+                                                       Qt::CaseInsensitive) == 0) {
+                    options.deploymentMechanism = Options::Unbundled;
                 } else {
                     fprintf(stderr, "Unrecognized deployment mechanism: %s\n", qPrintable(deploymentMechanism));
                     options.helpRequested = true;
@@ -540,7 +544,9 @@ void printHelp()
                     "       directory will be used if nothing else is specified.\n"
                     "\n"
                     "    --deployment <mechanism>: Supported deployment mechanisms:\n"
-                    "       bundled (default): Include Qt files in stand-alone package.\n"
+                    "       bundled (default): Includes Qt files in stand-alone package.\n"
+                    "       unbundled: Assumes native libraries are present on the device\n"
+                    "       and does not include them in the APK.\n"
                     "\n"
                     "    --aab: Build an Android App Bundle.\n"
                     "\n"
@@ -796,6 +802,16 @@ QString packageNameFromAndroidManifest(const QString &androidManifestPath)
     return {};
 }
 
+bool parseCmakeBoolean(const QJsonValue &value)
+{
+    const QString stringValue = value.toString();
+    return (stringValue.compare(QString::fromUtf8("true"), Qt::CaseInsensitive)
+                 || stringValue.compare(QString::fromUtf8("on"), Qt::CaseInsensitive)
+                 || stringValue.compare(QString::fromUtf8("yes"), Qt::CaseInsensitive)
+                 || stringValue.compare(QString::fromUtf8("y"), Qt::CaseInsensitive)
+                 || stringValue.toInt() > 0);
+}
+
 bool readInputFile(Options *options)
 {
     QFile file(options->inputFileName);
@@ -1023,6 +1039,22 @@ bool readInputFile(Options *options)
     }
 
     {
+        const QJsonValue systemLibsPath =
+                jsonObject.value("android-system-libs-prefix"_L1);
+        if (!systemLibsPath.isUndefined())
+            options->systemLibsPath = systemLibsPath.toString();
+    }
+
+    {
+        const QJsonValue noDeploy = jsonObject.value("android-no-deploy-qt-libs"_L1);
+        if (!noDeploy.isUndefined()) {
+            bool useUnbundled = parseCmakeBoolean(noDeploy);
+            options->deploymentMechanism = useUnbundled ? Options::Unbundled :
+                                                          Options::Bundled;
+        }
+    }
+
+    {
         const QJsonValue stdcppPath = jsonObject.value("stdcpp-path"_L1);
         if (stdcppPath.isUndefined()) {
             fprintf(stderr, "No stdcpp-path defined in json file.\n");
@@ -1137,6 +1169,11 @@ bool readInputFile(Options *options)
     return true;
 }
 
+bool isDeployment(const Options *options, Options::DeploymentMechanism deployment)
+{
+    return options->deploymentMechanism == deployment;
+}
+
 bool copyFiles(const QDir &sourceDirectory, const QDir &destinationDirectory, const Options &options, bool forceOverwrite = false)
 {
     const QFileInfoList entries = sourceDirectory.entryInfoList(QDir::NoDotAndDotDot | QDir::Files | QDir::Dirs);
@@ -1249,8 +1286,16 @@ bool copyAndroidExtraLibs(Options *options)
     if (options->extraLibs.isEmpty())
         return true;
 
-    if (options->verbose)
-        fprintf(stdout, "Copying %zd external libraries to package.\n", size_t(options->extraLibs.size()));
+    if (options->verbose) {
+        switch (options->deploymentMechanism) {
+        case Options::Bundled:
+            fprintf(stdout, "Copying %zd external libraries to package.\n", size_t(options->extraLibs.size()));
+            break;
+        case Options::Unbundled:
+            fprintf(stdout, "Skip copying of external libraries.\n");
+            break;
+        };
+    }
 
     for (const QString &extraLib : options->extraLibs) {
         QFileInfo extraLibInfo(extraLib);
@@ -1274,8 +1319,10 @@ bool copyAndroidExtraLibs(Options *options)
                                 + u'/'
                                 + extraLibInfo.fileName());
 
-        if (!copyFileIfNewer(extraLib, destinationFile, *options))
+        if (isDeployment(options, Options::Bundled)
+                && !copyFileIfNewer(extraLib, destinationFile, *options)) {
             return false;
+        }
         options->archExtraLibs[options->currentArchitecture] += extraLib;
     }
 
@@ -1323,8 +1370,10 @@ bool copyAndroidExtraResources(Options *options)
             if (!resourceFile.endsWith(".so"_L1)) {
                 destinationFile = assetsDir + resourceFile;
             } else {
-                if (!checkArchitecture(*options, originFile))
+                if (isDeployment(options, Options::Unbundled)
+                                 || !checkArchitecture(*options, originFile)) {
                     continue;
+                }
                 destinationFile = libsDir + resourceFile;
                 options->archExtraPlugins[options->currentArchitecture] += resourceFile;
             }
@@ -1487,11 +1536,12 @@ bool updateLibsXml(Options *options)
     const QString initClasses = options->initClasses.join(u':');
     replacements[QStringLiteral("<!-- %%INSERT_INIT_CLASSES%% -->")] = initClasses;
 
-    // Bundle and use libs from the apk because currently we don't have a way avoid
-    // duplicating them.
-    replacements[QStringLiteral("<!-- %%BUNDLE_LOCAL_QT_LIBS%% -->")] = "1"_L1;
+    // Set BUNDLE_LOCAL_QT_LIBS based on the deployment used
+    replacements[QStringLiteral("<!-- %%BUNDLE_LOCAL_QT_LIBS%% -->")]
+            = isDeployment(options, Options::Unbundled) ? "0"_L1 : "1"_L1;
     replacements[QStringLiteral("<!-- %%USE_LOCAL_QT_LIBS%% -->")] = "1"_L1;
-
+    replacements[QStringLiteral("<!-- %%SYSTEM_LIBS_PREFIX%% -->")] =
+            isDeployment(options, Options::Unbundled) ? options->systemLibsPath : QStringLiteral("");
 
     if (!updateFile(fileName, replacements))
         return false;
@@ -1735,7 +1785,7 @@ bool readAndroidDependencyXml(Options *options,
                 } else if (reader.name() == "jar"_L1) {
                     int bundling = reader.attributes().value("bundling"_L1).toInt();
                     QString fileName = QDir::cleanPath(reader.attributes().value("file"_L1).toString());
-                    if (bundling == (options->deploymentMechanism == Options::Bundled)) {
+                    if (bundling) {
                         QtDependency dependency(fileName, absoluteFilePath(options, fileName));
                         if (!usedDependencies->contains(dependency.absolutePath)) {
                             options->qtDependencies[options->currentArchitecture].append(dependency);
@@ -2322,6 +2372,10 @@ bool copyQtFiles(Options *options)
         case Options::Bundled:
             fprintf(stdout, "Copying %zd dependencies from Qt into package.\n", size_t(options->qtDependencies[options->currentArchitecture].size()));
             break;
+        case Options::Unbundled:
+            fprintf(stdout, "Copying dependencies from Qt into the package build folder,"
+                            "skipping native libraries.\n");
+            break;
         };
     }
 
@@ -2336,8 +2390,8 @@ bool copyQtFiles(Options *options)
     for (const QtDependency &qtDependency : qAsConst(options->qtDependencies[options->currentArchitecture])) {
         QString sourceFileName = qtDependency.absolutePath;
         QString destinationFileName;
-
-        if (qtDependency.relativePath.endsWith(".so"_L1)) {
+        bool isSharedLibrary = qtDependency.relativePath.endsWith(".so"_L1);
+        if (isSharedLibrary) {
             QString garbledFileName;
             if (QDir::fromNativeSeparators(qtDependency.relativePath).startsWith("lib/"_L1)) {
                 garbledFileName = qtDependency.relativePath.mid(sizeof("lib/") - 1);
@@ -2371,13 +2425,12 @@ bool copyQtFiles(Options *options)
             continue;
         }
 
-        if (options->deploymentMechanism == Options::Bundled
+        if ((isDeployment(options, Options::Bundled) || !isSharedLibrary)
                 && !copyFileIfNewer(sourceFileName,
                                     options->outputDirectory + u'/' + destinationFileName,
                                     *options)) {
             return false;
         }
-
         options->bundledFiles[options->currentArchitecture] += qMakePair(destinationFileName, qtDependency.relativePath);
     }
 
@@ -2709,6 +2762,8 @@ bool copyPackage(const Options &options)
 
 bool copyStdCpp(Options *options)
 {
+    if (isDeployment(options, Options::Unbundled))
+        return true;
     if (options->verbose)
         fprintf(stdout, "Copying STL library\n");
 
@@ -3115,9 +3170,16 @@ int main(int argc, char *argv[])
             if (Q_UNLIKELY(options.timing))
                 fprintf(stdout, "[TIMING] %lld ns: Copied GNU STL\n", options.timer.nsecsElapsed());
         }
-
-        if (!containsApplicationBinary(&options))
+        // If Unbundled deployment is used, remove app lib as we don't want it packaged inside the APK
+        if (options.deploymentMechanism == Options::Unbundled) {
+            QString appLibPath = "%1/libs/%2/lib%3_%2.so"_L1.
+                    arg(options.outputDirectory,
+                        options.currentArchitecture,
+                        options.applicationBinary);
+            QFile::remove(appLibPath);
+        } else if (!containsApplicationBinary(&options)) {
             return CannotFindApplicationBinary;
+        }
 
         if (Q_UNLIKELY(options.timing))
             fprintf(stdout, "[TIMING] %lld ns: Checked for application binary\n", options.timer.nsecsElapsed());
@@ -3141,7 +3203,6 @@ int main(int argc, char *argv[])
         return 0;
     }
 
-
     if (options.build) {
         if (!copyAndroidSources(options))
             return CannotCopyAndroidSources;