main.cpp

Go to the documentation of this file.

// Copyright (C) 2026 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
#include <QCoreApplication>
#include <QCommandLineParser>
#include <QCommandLineOption>
#include <QDebug>
#include <QDir>
#include <QDirIterator>
#include <QFile>
#include <QFileInfo>
#include <QHash>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QProcess>
#include <QStandardPaths>
#include <QString>
#include <QStringList>
#include <QSet>
#include <QElapsedTimer>
#include <QRegularExpression>
 
#include "../shared/depfile_shared.h"
 
using namespace Qt::StringLiterals;
 
// Global list of all source files that contribute to the HAP
// Used to generate dependency file for CMake DEPFILE support
static QStringList dependenciesForDepfile;
 
struct Options
{
    QString inputFile;
    QString outputDirectory;
    QString hvigorPath;
    QString applicationBinary;
    QStringList projectLibraries;  // Project-built libraries from CMake
    QString harmonyOsPackageSourceDirectory;
    QString harmonyOsAppName;
    QString harmonyOsAppBundleName;
    QString sdkRoot;
    QString ndkRoot;
    QStringList qmlRootPaths;
    QStringList qmlImportPaths;
    QStringList pluginsImportPaths; // Build-tree plugin search paths (processed before qtPluginsDirectory)
    QStringList targetArchs;
 
    // Qt installation directories (following androiddeployqt pattern)
    QString qtLibsDirectory;     // Target Qt libs
    QString qtPluginsDirectory;  // Target Qt plugins
    QString qtQmlDirectory;      // Target Qt QML modules
    QString qtLibExecsDirectory; // Host Qt tools (qmlimportscanner, etc.)
    QString qtHostDirectory;     // Host Qt installation
    QStringList extraLibsDirs;   // Extra library search paths (e.g. HARMONYOS_DEPS_ROOT/lib)
 
    bool verbose = false;
    bool releaseMode = false;
    bool installApk = false;     // Keep name for consistency with androiddeployqt
    bool buildPackage = true;
 
    QString depFilePath;     // Path to write dependency file
    QString depFileBase;     // Base directory for relative paths in depfile
 
    // HarmonyOS permissions injected via qt_add_harmonyos_permission
    QJsonArray permissions;
 
    // App-level metadata from the QT_HARMONYOS_APP_* target properties.
    // Empty/zero means "user did not set this", so harmonydeployqt leaves the
    // template default in place.
    QString harmonyOsAppVendor;
    int harmonyOsAppVersionCode = 0;
    QString harmonyOsAppVersionName;
    QString harmonyOsAppLabel;
    QString harmonyOsAppIcon;
 
    // SDK versions from the QT_HARMONYOS_*_SDK_VERSION target properties.
    // Substituted into entry/build-profile.json5. Empty means "leave template
    // default".
    QString harmonyOsCompatibleSdkVersion;
    QString harmonyOsTargetSdkVersion;
    QString harmonyOsCompileSdkVersion;
 
    // Additional plugin .so files from QT_HARMONYOS_EXTRA_PLUGINS.
    QStringList extraPlugins;
 
    // Module-level metadata from the QT_HARMONYOS_MODULE_* and
    // QT_HARMONYOS_ABILITY_* target properties.
    QString harmonyOsModuleDescription;
    QStringList harmonyOsModuleDeviceTypes;
    QString harmonyOsAbilityOrientation;
 
    // Test bundle mode
    bool testBundleMode = false;
    QString testBinariesDirectory;   // Directory to scan for libtst_*.so
    QStringList testExcludeList;     // Filenames to exclude from test bundle
 
    // HAP signing material from --signing-* CLI flags (empty = use env vars).
    QString signingCertPath;
    QString signingProfile;
    QString signingStoreFile;
    QString signingKeyAlias;
    QString signingKeyPassword;
    QString signingStorePassword;
    QString signingPlainKeyPassword;
    QString signingPlainStorePassword;
    QString signingAlg;
 
    QElapsedTimer timer;
};
 
static void printHelp()
{
    fprintf(stdout, "Usage: harmonydeployqt [options]\n\n"
                    "Options:\n"
                    "  --input <file>              JSON configuration file (required)\n"
                    "  --output <dir>              Output directory for generated project\n"
                    "  --hvigor <path>             Path to hvigorw for building HAP (or set QT_HARMONYOS_HVIGOR)\n"
                    "  --install                   Install HAP to connected device via hdc\n"
                    "  --release                   Build release configuration (default: debug)\n"
                    "  --verbose                   Enable verbose output\n"
                    "  --no-build                  Skip building the HAP\n"
                    "  --test-bundle               Enable test bundle mode (bundles all test binaries into one HAP)\n"
                    "  --depfile <path>            Write dependency file for build system\n"
                    "  --depfile-base <dir>        Base directory for relative paths in depfile\n"
                    "  --signing-cert-path <p>     .cer file (or QT_HARMONYOS_SIGNING_CERT_PATH)\n"
                    "  --signing-profile <p>       .p7b profile (or QT_HARMONYOS_SIGNING_PROFILE)\n"
                    "  --signing-store-file <p>    .p12 keystore (or QT_HARMONYOS_SIGNING_STORE_FILE)\n"
                    "  --signing-key-alias <a>     Key alias (or QT_HARMONYOS_SIGNING_KEY_ALIAS)\n"
                    "  --signing-key-password <s>  Encrypted key pwd (or QT_HARMONYOS_SIGNING_KEY_PASSWORD)\n"
                    "  --signing-store-password <s> Encrypted store pwd (or QT_HARMONYOS_SIGNING_STORE_PASSWORD)\n"
                    "  --signing-plain-key-password <s>\n"
                    "                              Plain key pwd (or QT_HARMONYOS_SIGNING_PLAIN_KEY_PASSWORD)\n"
                    "  --signing-plain-store-password <s>\n"
                    "                              Plain store pwd (or QT_HARMONYOS_SIGNING_PLAIN_STORE_PASSWORD)\n"
                    "  --signing-alg <alg>         Signature algorithm, default SHA256withECDSA\n"
                    "                              (or QT_HARMONYOS_SIGNING_ALG)\n"
                    "  --help                      Show this help\n\n"
                    "Signing: CLI flags above win per field over the matching env vars.\n"
                    "Both passwords must be given either hvigor-encrypted or in plain text.\n"
                    "If any signing input is set, all required values must be present,\n"
                    "otherwise harmonydeployqt fails. With none set the HAP is left unsigned.\n"
                    "With encrypted passwords, hvigor signs the HAP. With plain passwords, the\n"
                    "SDK's hap-sign-tool does, located via the SDK root or\n"
                    "QT_HARMONYOS_HAP_SIGN_TOOL and run with QT_HARMONYOS_JAVA, JAVA_HOME or\n"
                    "java from PATH.\n");
}
 
class QProcessExt : public QProcess
{
public:
    QProcessExt() {
        connect(this, &QProcess::readyReadStandardOutput, [this]() {
            QByteArray output = readAllStandardOutput();
            QString text = QString::fromUtf8(output);
            fprintf(stderr, "harmonydeployqt: external application output: %s\n", qPrintable(text));
        });
        connect(this, &QProcess::readyReadStandardError, [this]() {
            QByteArray error = readAllStandardError();
            QString text = QString::fromUtf8(error);
            fprintf(stderr, "harmonydeployqt: external application error: %s\n", qPrintable(text));
        });
    }
};
 
static bool parseCommandLine(const QStringList &arguments, Options *options)
{
    QCommandLineParser parser;
    parser.setApplicationDescription("Qt HarmonyOS Deployment Tool"_L1);
 
    QCommandLineOption inputOption("input"_L1, "JSON configuration file"_L1, "file"_L1);
    QCommandLineOption outputOption("output"_L1, "Output directory"_L1, "dir"_L1);
    QCommandLineOption hvigorOption("hvigor"_L1, "Path to hvigorw"_L1, "path"_L1);
    QCommandLineOption installOption("install"_L1, "Install to device"_L1);
    QCommandLineOption releaseOption("release"_L1, "Build release configuration"_L1);
    QCommandLineOption verboseOption("verbose"_L1, "Verbose output"_L1);
    QCommandLineOption noBuildOption("no-build"_L1, "Skip building"_L1);
    QCommandLineOption testBundleOption("test-bundle"_L1, "Enable test bundle mode"_L1);
    QCommandLineOption depfileOption("depfile"_L1, "Dependency file output"_L1, "path"_L1);
    QCommandLineOption depfileBaseOption("depfile-base"_L1, "Base directory for depfile paths"_L1, "dir"_L1);
    QCommandLineOption signingCertPathOption("signing-cert-path"_L1,
        "Path to the .cer file"_L1, "path"_L1);
    QCommandLineOption signingProfileOption("signing-profile"_L1,
        "Path to the .p7b profile"_L1, "path"_L1);
    QCommandLineOption signingStoreFileOption("signing-store-file"_L1,
        "Path to the .p12 keystore"_L1, "path"_L1);
    QCommandLineOption signingKeyAliasOption("signing-key-alias"_L1,
        "Key alias inside the keystore"_L1, "alias"_L1);
    QCommandLineOption signingKeyPasswordOption("signing-key-password"_L1,
        "Encrypted key password"_L1, "pwd"_L1);
    QCommandLineOption signingStorePasswordOption("signing-store-password"_L1,
        "Encrypted keystore password"_L1, "pwd"_L1);
    QCommandLineOption signingPlainKeyPasswordOption("signing-plain-key-password"_L1,
        "Plain text key password"_L1, "pwd"_L1);
    QCommandLineOption signingPlainStorePasswordOption("signing-plain-store-password"_L1,
        "Plain text keystore password"_L1, "pwd"_L1);
    QCommandLineOption signingAlgOption("signing-alg"_L1,
        "Signature algorithm (default SHA256withECDSA)"_L1, "alg"_L1);
    QCommandLineOption helpOption("help"_L1, "Show help"_L1);
 
    parser.addOption(inputOption);
    parser.addOption(outputOption);
    parser.addOption(hvigorOption);
    parser.addOption(installOption);
    parser.addOption(releaseOption);
    parser.addOption(verboseOption);
    parser.addOption(noBuildOption);
    parser.addOption(testBundleOption);
    parser.addOption(depfileOption);
    parser.addOption(depfileBaseOption);
    parser.addOption(signingCertPathOption);
    parser.addOption(signingProfileOption);
    parser.addOption(signingStoreFileOption);
    parser.addOption(signingKeyAliasOption);
    parser.addOption(signingKeyPasswordOption);
    parser.addOption(signingStorePasswordOption);
    parser.addOption(signingPlainKeyPasswordOption);
    parser.addOption(signingPlainStorePasswordOption);
    parser.addOption(signingAlgOption);
    parser.addOption(helpOption);
 
    if (!parser.parse(arguments)) {
        fprintf(stderr, "%s\n", qPrintable(parser.errorText()));
        return false;
    }
 
    if (parser.isSet(helpOption)) {
        printHelp();
        return false;
    }
 
    if (!parser.isSet(inputOption)) {
        fprintf(stderr, "Error: --input option is required\n");
        printHelp();
        return false;
    }
 
    options->inputFile = parser.value(inputOption);
    options->outputDirectory = parser.value(outputOption);
    options->hvigorPath = parser.value(hvigorOption);
    options->installApk = parser.isSet(installOption);
    options->releaseMode = parser.isSet(releaseOption);
    options->verbose = parser.isSet(verboseOption);
    options->buildPackage = !parser.isSet(noBuildOption);
    options->testBundleMode = parser.isSet(testBundleOption);
    options->depFilePath = parser.value(depfileOption);
    options->depFileBase = parser.value(depfileBaseOption);
    options->signingCertPath = parser.value(signingCertPathOption);
    options->signingProfile = parser.value(signingProfileOption);
    options->signingStoreFile = parser.value(signingStoreFileOption);
    options->signingKeyAlias = parser.value(signingKeyAliasOption);
    options->signingKeyPassword = parser.value(signingKeyPasswordOption);
    options->signingStorePassword = parser.value(signingStorePasswordOption);
    options->signingPlainKeyPassword = parser.value(signingPlainKeyPasswordOption);
    options->signingPlainStorePassword = parser.value(signingPlainStorePasswordOption);
    options->signingAlg = parser.value(signingAlgOption);
 
    return true;
}
 
// Returns the version of the SDK that hvigor builds with, in build-profile.json5
// format, for example "6.1.1(24)", or an empty string if it cannot be determined.
// hvigor uses DEVECO_SDK_HOME; without it, assume the SDK Qt was built with.
static QString sdkVersion(const QString &sdkRoot)
{
    QStringList candidates;
    const QString devEcoSdkHome = qEnvironmentVariable("DEVECO_SDK_HOME");
    if (!devEcoSdkHome.isEmpty())
        candidates << devEcoSdkHome + "/default/sdk-pkg.json"_L1;
    if (!sdkRoot.isEmpty())
        candidates << sdkRoot + "/../sdk-pkg.json"_L1;
    for (const QString &candidate : std::as_const(candidates)) {
        QFile file(candidate);
        if (!file.open(QIODevice::ReadOnly))
            continue;
        const QJsonObject data = QJsonDocument::fromJson(file.readAll())["data"_L1].toObject();
        const QString platformVersion = data["platformVersion"_L1].toString();
        const QString apiVersion = data["apiVersion"_L1].toVariant().toString();
        if (platformVersion.isEmpty() || apiVersion.isEmpty())
            return {};
        return platformVersion + u'(' + apiVersion + u')';
    }
    return {};
}
 
static bool readInputConfiguration(Options *options)
{
    QFile inputFile(options->inputFile);
    if (!inputFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
        fprintf(stderr, "Failed to open input file: %s\n", qPrintable(options->inputFile));
        return false;
    }
 
    QJsonParseError parseError;
    QJsonDocument doc = QJsonDocument::fromJson(inputFile.readAll(), &parseError);
    if (doc.isNull()) {
        fprintf(stderr, "Failed to parse JSON: %s\n", qPrintable(parseError.errorString()));
        return false;
    }
 
    QJsonObject obj = doc.object();
 
    options->applicationBinary = obj["application-binary"_L1].toString();
    options->harmonyOsPackageSourceDirectory = obj["harmonyos-package-source-directory"_L1].toString();
    options->harmonyOsAppName = obj["harmonyos-app-name"_L1].toString();
    options->harmonyOsAppBundleName = obj["harmonyos-app-bundle-name"_L1].toString();
    options->sdkRoot = obj["sdk-root"_L1].toString();
    options->ndkRoot = obj["ndk-root"_L1].toString();
    // qml-root-path may be a string (legacy) or an array (current).
    {
        const QJsonValue rootPathValue = obj["qml-root-path"_L1];
        if (rootPathValue.isArray()) {
            for (const QJsonValue &v : rootPathValue.toArray()) {
                const QString s = v.toString();
                if (!s.isEmpty())
                    options->qmlRootPaths.append(s);
            }
        } else {
            const QString s = rootPathValue.toString();
            if (!s.isEmpty())
                options->qmlRootPaths.append(s);
        }
    }
 
    // Qt installation directories
    options->qtLibsDirectory = obj["qtLibsDirectory"_L1].toString();
    options->qtPluginsDirectory = obj["qtPluginsDirectory"_L1].toString();
    options->qtQmlDirectory = obj["qtQmlDirectory"_L1].toString();
    options->qtLibExecsDirectory = obj["qtLibExecsDirectory"_L1].toString();
    options->qtHostDirectory = obj["qtHostDirectory"_L1].toString();
 
    QJsonArray extraLibsDirsArray = obj["extra-libs-dirs"_L1].toArray();
    for (const QJsonValue &value : extraLibsDirsArray)
        options->extraLibsDirs.append(value.toString());
 
    // Test bundle mode settings (JSON can override CLI flag)
    if (obj["test-bundle"_L1].toBool())
        options->testBundleMode = true;
    options->testBinariesDirectory = obj["test-binaries-directory"_L1].toString();
    QJsonArray excludeArray = obj["test-exclude-list"_L1].toArray();
    for (const QJsonValue &value : excludeArray)
        options->testExcludeList.append(value.toString());
 
    // Parse project libraries
    QJsonArray projectLibsArray = obj["project-libraries"_L1].toArray();
    for (const QJsonValue &value : projectLibsArray)
        options->projectLibraries.append(value.toString());
 
    // Parse QML import paths
    QJsonArray importPathsArray = obj["qml-import-paths"_L1].toArray();
    for (const QJsonValue &value : importPathsArray)
        options->qmlImportPaths.append(value.toString());
 
    // Parse plugins import paths
    QJsonArray pluginsImportPathsArray = obj["plugins-import-paths"_L1].toArray();
    for (const QJsonValue &value : pluginsImportPathsArray)
        options->pluginsImportPaths.append(value.toString());
 
    // Parse target architectures
    QJsonArray archArray = obj["harmonyos-target-arch"_L1].toArray();
    for (const QJsonValue &value : archArray)
        options->targetArchs.append(value.toString());
    if (options->targetArchs.isEmpty())
        options->targetArchs.append("arm64-v8a"_L1);
 
    // Parse HarmonyOS permissions injected via qt_add_harmonyos_permission
    options->permissions = obj["permissions"_L1].toArray();
 
    // App-level metadata injected via the QT_HARMONYOS_APP_* target properties.
    options->harmonyOsAppVendor = obj["harmonyos-app-vendor"_L1].toString();
    options->harmonyOsAppVersionCode = obj["harmonyos-app-version-code"_L1].toInt();
    options->harmonyOsAppVersionName = obj["harmonyos-app-version-name"_L1].toString();
    options->harmonyOsAppLabel = obj["harmonyos-app-label"_L1].toString();
    options->harmonyOsAppIcon = obj["harmonyos-app-icon"_L1].toString();
 
    // SDK versions for entry/build-profile.json5.
    options->harmonyOsCompatibleSdkVersion =
        obj["harmonyos-compatible-sdk-version"_L1].toString();
    options->harmonyOsTargetSdkVersion =
        obj["harmonyos-target-sdk-version"_L1].toString();
    options->harmonyOsCompileSdkVersion =
        obj["harmonyos-compile-sdk-version"_L1].toString();
    // DevEco Studio asks to add a targetSdkVersion matching the SDK when it is missing.
    // With an explicit compileSdkVersion the SDK version could exceed it.
    if (options->harmonyOsTargetSdkVersion.isEmpty()
        && options->harmonyOsCompileSdkVersion.isEmpty()) {
        options->harmonyOsTargetSdkVersion = sdkVersion(options->sdkRoot);
    }
 
    // Extra plugins (resolved file paths). Categories are derived from the
    // parent directory name of each path.
    {
        const QJsonArray extraPluginsArray =
            obj["harmonyos-extra-plugins"_L1].toArray();
        for (const QJsonValue &v : extraPluginsArray) {
            const QString s = v.toString();
            if (!s.isEmpty())
                options->extraPlugins.append(s);
        }
    }
 
    // Module-level metadata injected via the QT_HARMONYOS_MODULE_* and
    // QT_HARMONYOS_ABILITY_* target properties.
    options->harmonyOsModuleDescription = obj["harmonyos-module-description"_L1].toString();
    const QJsonArray deviceTypesArray = obj["harmonyos-module-device-types"_L1].toArray();
    for (const QJsonValue &value : deviceTypesArray)
        options->harmonyOsModuleDeviceTypes.append(value.toString());
    options->harmonyOsAbilityOrientation = obj["harmonyos-ability-orientation"_L1].toString();
 
    // Validate required fields
    if (!options->testBundleMode) {
        if (options->applicationBinary.isEmpty()) {
            fprintf(stderr, "Error: 'application-binary' not specified in JSON\n");
            return false;
        }
 
        // The settings file is generated at CMake generate time, so it names the
        // application binary long before the build produces it. Fail early with a
        // clear reason instead of copying the whole template first and then
        // tripping over the missing file in copyApplicationBinary().
        if (!QFile::exists(options->applicationBinary)) {
            fprintf(stderr, "Error: application binary does not exist: %s\n",
                    qPrintable(options->applicationBinary));
            fprintf(stderr, "       Build the project before running harmonydeployqt.\n");
            return false;
        }
    }
 
    // Set defaults for test bundle mode
    if (options->testBundleMode) {
        if (options->harmonyOsAppBundleName.isEmpty())
            options->harmonyOsAppBundleName = "org.qtproject.autotests"_L1;
        if (options->harmonyOsAppName.isEmpty())
            options->harmonyOsAppName = "QtAutoTests"_L1;
    }
 
    // Auto-detect template directory if not specified
    if (options->harmonyOsPackageSourceDirectory.isEmpty()) {
        // For test bundle mode, use qtLibsDirectory as starting point;
        // otherwise start from the application binary location
        QString searchPath;
        if (options->testBundleMode && !options->qtLibsDirectory.isEmpty()) {
            searchPath = QDir::cleanPath(options->qtLibsDirectory);
        } else if (!options->applicationBinary.isEmpty()) {
            QFileInfo appInfo(options->applicationBinary);
            searchPath = QDir::cleanPath(appInfo.absolutePath());
        }
 
        if (searchPath.isEmpty()) {
            fprintf(stderr, "Error: 'harmonyos-package-source-directory' not specified in JSON\n");
            fprintf(stderr, "       and could not auto-detect template location (no search path)\n");
            return false;
        }
 
        if (options->verbose)
            fprintf(stdout, "Searching for template starting from: %s\n", qPrintable(searchPath));
 
        // Walk up directory tree to find Qt installation using string manipulation
        for (int i = 0; i < 10; ++i) {
            // Check for installed template in share directory (matches CMakeLists.txt install path)
            QString templatePath = searchPath + "/share/qt6/src/harmonyos/templates"_L1;
            if (options->verbose) {
                fprintf(stdout, "  Checking: %s ... %s\n", qPrintable(templatePath),
                       QDir(templatePath).exists() ? "FOUND" : "not found");
            }
            if (QDir(templatePath).exists()) {
                options->harmonyOsPackageSourceDirectory = std::move(templatePath);
                break;
            }
 
            // Check for source tree location (development builds)
            templatePath = searchPath + "/src/harmonyos/templates"_L1;
            if (options->verbose) {
                fprintf(stdout, "  Checking: %s ... %s\n", qPrintable(templatePath),
                       QDir(templatePath).exists() ? "FOUND" : "not found");
            }
            if (QDir(templatePath).exists()) {
                options->harmonyOsPackageSourceDirectory = std::move(templatePath);
                break;
            }
 
            // Move up one directory by removing last path component
            const auto lastSlash = searchPath.lastIndexOf('/'_L1);
            if (lastSlash <= 0) {
                if (options->verbose)
                    fprintf(stdout, "  Reached root directory\n");
                break;
            }
            searchPath.resize(lastSlash);
        }
 
        if (options->harmonyOsPackageSourceDirectory.isEmpty()) {
            fprintf(stderr, "Error: 'harmonyos-package-source-directory' not specified in JSON\n");
            fprintf(stderr, "       and could not auto-detect template location\n");
            fprintf(stderr, "       Please specify the path to the HarmonyOS application template\n");
            return false;
        } else if (options->verbose) {
            fprintf(stdout, "Auto-detected template: %s\n", qPrintable(options->harmonyOsPackageSourceDirectory));
        }
    }
 
    if (options->harmonyOsAppName.isEmpty()) {
        fprintf(stderr, "Error: 'harmonyos-app-name' not specified in JSON\n");
        return false;
    }
 
    if (options->harmonyOsAppBundleName.isEmpty()) {
        fprintf(stderr, "Error: 'harmonyos-app-bundle-name' not specified in JSON\n");
        return false;
    }
 
    // Set default output directory if not specified
    if (options->outputDirectory.isEmpty()) {
        if (options->testBundleMode) {
            options->outputDirectory = QDir::currentPath() + "/harmonyos-tests-bundle"_L1;
        } else {
            QFileInfo appInfo(options->applicationBinary);
            options->outputDirectory = QDir::currentPath() + "/"_L1 +
                                      appInfo.completeBaseName() + "-harmonyos"_L1;
        }
    }
 
    if (options->verbose) {
        fprintf(stdout, "Configuration loaded:\n");
        if (options->testBundleMode) {
            fprintf(stdout, "  Mode: test bundle\n");
            fprintf(stdout, "  Test binaries directory: %s\n", qPrintable(options->testBinariesDirectory));
            if (!options->testExcludeList.isEmpty())
                fprintf(stdout, "  Exclude list: %s\n", qPrintable(options->testExcludeList.join(", "_L1)));
        } else {
            fprintf(stdout, "  Application binary: %s\n", qPrintable(options->applicationBinary));
        }
        fprintf(stdout, "  Template directory: %s\n", qPrintable(options->harmonyOsPackageSourceDirectory));
        fprintf(stdout, "  App name: %s\n", qPrintable(options->harmonyOsAppName));
        fprintf(stdout, "  Bundle name: %s\n", qPrintable(options->harmonyOsAppBundleName));
        fprintf(stdout, "  Output directory: %s\n", qPrintable(options->outputDirectory));
        fprintf(stdout, "  Target architectures: %s\n", qPrintable(options->targetArchs.join(", "_L1)));
    }
 
    return true;
}
 
static bool copyFileIfNewer(const QString &sourceFileName,
                            const QString &destinationFileName, bool verbose,
                            bool forceOverwrite = false)
{
    if (QFile::exists(destinationFileName)) {
        QFileInfo destinationFileInfo(destinationFileName);
        QFileInfo sourceFileInfo(sourceFileName);
 
        // Skip if destination is same or newer (unless forcing overwrite)
        if (!forceOverwrite &&
            sourceFileInfo.lastModified() <= destinationFileInfo.lastModified()) {
            if (verbose)
                fprintf(stdout, "  Skipping: %s (destination is up to date)\n",
                        qPrintable(sourceFileInfo.fileName()));
            return true;
        }
 
        // Remove old file before copying
        if (!QFile(destinationFileName).remove()) {
            fprintf(stderr, "Failed to remove old file: %s\n",
                    qPrintable(destinationFileName));
            return false;
        }
    }
 
    // Ensure destination directory exists
    QFileInfo destInfo(destinationFileName);
    if (!QDir().mkpath(destInfo.absolutePath())) {
        fprintf(stderr, "Failed to create directory for: %s\n", qPrintable(destinationFileName));
        return false;
    }
 
    if (verbose)
        fprintf(stdout, "  Copying: %s\n", qPrintable(QFileInfo(sourceFileName).fileName()));
 
    QFile sourceFile(sourceFileName);
    if (!sourceFile.copy(destinationFileName)) {
        fprintf(stderr, "Failed to copy file: %s to %s: %s\n", qPrintable(sourceFileName),
                qPrintable(destinationFileName), qPrintable(sourceFile.errorString()));
        return false;
    }
 
    return true;
}
 
// Write dependency file for CMake DEPFILE support
static bool writeDepfile(const Options &options, const QString &hapOutputPath)
{
    if (options.depFilePath.isEmpty())
        return true; // Not requested
 
    if (options.verbose)
        fprintf(stdout, "Writing dependency file: %s\n", qPrintable(options.depFilePath));
 
    // Calculate relative HAP path from depfile base directory
    QString relativeHapPath;
    if (!options.depFileBase.isEmpty() && !hapOutputPath.isEmpty())
        relativeHapPath = QDir(options.depFileBase).relativeFilePath(hapOutputPath);
    else
        relativeHapPath = hapOutputPath;
 
    // Open depfile for writing
    QFile depFile(options.depFilePath);
    if (!depFile.open(QIODevice::WriteOnly | QIODevice::Text)) {
        fprintf(stderr, "Failed to open depfile: %s\n", qPrintable(options.depFilePath));
        return false;
    }
 
    // Write Makefile-style dependency format: target: dep1 \ dep2 \ ...
    depFile.write(escapeAndEncodeDependencyPath(relativeHapPath));
    depFile.write(": ");
 
    for (const QString &dep : dependenciesForDepfile) {
        depFile.write(" \\\n    ");
        depFile.write(escapeAndEncodeDependencyPath(dep));
    }
 
    depFile.write("\n");
    depFile.close();
 
    if (options.verbose)
        fprintf(stdout, "Wrote %lld dependencies to depfile\n",
                static_cast<long long>(dependenciesForDepfile.size()));
 
    return true;
}
 
static bool copyRecursively(const QString &sourceDir, const QString &destDir, bool verbose,
                            const QString &topDest = {})
{
    QDir srcDir(sourceDir);
    if (!srcDir.exists()) {
        fprintf(stderr, "Source directory does not exist: %s\n", qPrintable(sourceDir));
        return false;
    }
 
    QDir destDirectory(destDir);
    if (!destDirectory.exists()) {
        if (!destDirectory.mkpath("."_L1)) {
            fprintf(stderr, "Failed to create destination directory: %s\n", qPrintable(destDir));
            return false;
        }
    }
 
    // Fixed top-level destination so the check below matches the output dir at any depth.
    const QFileInfo cleanDestInfo{ topDest.isEmpty()
                                   ? QDir::cleanPath(destDirectory.absolutePath())
                                   : topDest };
 
    const QFileInfoList entries = srcDir.entryInfoList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden);
    for (const QFileInfo &entry : entries) {
        QString destPath = destDir + "/"_L1 + entry.fileName();
 
        if (entry.isDir()) {
            // Skip the destination itself; otherwise the copy descends into its own output.
            const QFileInfo cleanSrcInfo{ QDir::cleanPath(entry.absoluteFilePath()) };
            if (cleanSrcInfo == cleanDestInfo) {
                if (verbose)
                    fprintf(stdout, "  Skipping %s (is the destination directory)\n",
                            qPrintable(cleanSrcInfo.filePath()));
                continue;
            }
            if (!copyRecursively(entry.filePath(), destPath, verbose, cleanDestInfo.filePath()))
                return false;
        } else {
            if (!copyFileIfNewer(entry.filePath(), destPath, verbose))
                return false;
        }
    }
    return true;
}
 
static bool copyTemplate(const Options &options)
{
    if (options.verbose) {
        fprintf(stdout, "Copying template from %s to %s\n",
               qPrintable(options.harmonyOsPackageSourceDirectory),
               qPrintable(options.outputDirectory));
    }
 
    // Check if template exists
    QDir templateDir(options.harmonyOsPackageSourceDirectory);
    if (!templateDir.exists()) {
        fprintf(stderr, "Template directory does not exist: %s\n",
               qPrintable(options.harmonyOsPackageSourceDirectory));
        return false;
    }
 
    // The module manifest is mandatory; without it hvigor cannot build the HAP and
    // customizeTemplate() would silently skip every substitution, producing a broken
    // package. Fail early with a targeted message instead.
    const QString moduleManifest =
            options.harmonyOsPackageSourceDirectory + "/entry/src/main/module.json5"_L1;
    if (!QFile::exists(moduleManifest)) {
        fprintf(stderr,
                "'%s' is not a valid HarmonyOS package template: missing "
                "entry/src/main/module.json5\n",
                qPrintable(options.harmonyOsPackageSourceDirectory));
        return false;
    }
 
    // Create output directory
    QDir outputDir(options.outputDirectory);
    if (outputDir.exists()) {
        if (options.verbose)
            fprintf(stdout, "Output directory already exists, will overwrite files\n");
    }
 
    // Copy entire template
    if (!copyRecursively(options.harmonyOsPackageSourceDirectory, options.outputDirectory, options.verbose))
        return false;
 
    // Force-overwrite the manifest files. customizeTemplate() does one-shot
    // sentinel/regex substitutions on these; if the destination is left over
    // from a previous deploy the sentinels are already gone and any change to
    // the CMake-supplied metadata would be silently ignored. The same applies
    // to build-profile.json5: injectSigningConfig() looks for the empty
    // template array and refuses to touch anything else.
    for (const char *relPath : { "AppScope/app.json5", "entry/src/main/module.json5",
                                 "build-profile.json5" }) {
        const QString src = options.harmonyOsPackageSourceDirectory
            + QLatin1Char('/') + QLatin1String(relPath);
        const QString dst = options.outputDirectory + QLatin1Char('/') + QLatin1String(relPath);
        if (QFile::exists(src) && !copyFileIfNewer(src, dst, options.verbose, true))
            return false;
    }
 
    if (options.verbose)
        fprintf(stdout, "Template copied successfully\n");
 
    return true;
}
 
// Hvigor's module.json5 schema rejects free-form reason strings: it requires
// either a "$string:<id>" resource reference or a parameterised token (one
// containing both '{' and '}').  Plain English literals supplied via
// qt_add_harmonyos_permission(... REASON "...") therefore have to be
// auto-promoted to a synthesized resource entry before substitution.
static bool reasonNeedsPromotion(const QString &reason)
{
    if (reason.startsWith("$string:"_L1))
        return false;
    if (reason.contains(QLatin1Char('{')) && reason.contains(QLatin1Char('}')))
        return false;
    return true;
}
 
// Synthesize a stable resource id from a permission name. The trailing
// dot-separated component is unique among ohos.permission.* permissions, so
// "ohos.permission.CAMERA" -> "qt_permission_reason_camera".
static QString synthesizePermissionReasonId(const QString &permissionName)
{
    const QString suffix = permissionName.section(QLatin1Char('.'), -1).toLower();
    return "qt_permission_reason_"_L1 + suffix;
}
 
// scalar. User-supplied metadata (vendor, label, etc.) is substituted into
// the OHOS manifest files verbatim, so embedded '"' or '\' would otherwise
// produce invalid JSON that hvigor rejects. Re-uses Qt's own JSON writer
// for the canonical escape: wrap in a single-element array, serialize, strip
// the surrounding `["` and `"]`.
static QString jsonStringEscape(const QString &s)
{
    QByteArray ba = QJsonDocument(QJsonArray{s}).toJson(QJsonDocument::Compact);
    return QString::fromUtf8(ba.sliced(2, ba.size() - 4));
}
 
// Returns true when value is one of the orientation strings the HarmonyOS
// module.json5 schema accepts. Anything else gets rejected with a warning and
// dropped, so a typo never reaches hvigor (which would fail with a less
// targeted schema error).
static bool isValidHarmonyOsAbilityOrientation(const QString &value)
{
    static const QStringList allowed = {
        "unspecified"_L1,
        "landscape"_L1,
        "portrait"_L1,
        "follow_recent"_L1,
        "landscape_inverted"_L1,
        "portrait_inverted"_L1,
        "auto_rotation"_L1,
        "auto_rotation_landscape"_L1,
        "auto_rotation_portrait"_L1,
        "auto_rotation_restricted"_L1,
        "auto_rotation_landscape_restricted"_L1,
        "auto_rotation_portrait_restricted"_L1,
        "locked"_L1,
        "follow_desktop"_L1,
    };
    return allowed.contains(value);
}
 
struct PromotedReason
{
    QString id;
    QString value;
};
 
static bool customizeTemplate(const Options &options)
{
    if (options.verbose)
        fprintf(stdout, "Customizing template files\n");
 
    // Customize QtAppConstants.ets
    QString qtAppConstantsPath = options.outputDirectory + "/entry/src/main/ets/common/QtAppConstants.ets"_L1;
    QFile qtAppConstantsFile(qtAppConstantsPath);
 
    if (qtAppConstantsFile.exists()) {
        if (!qtAppConstantsFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
            fprintf(stderr, "Failed to open QtAppConstants.ets for reading\n");
            return false;
        }
 
        QString content = QString::fromUtf8(qtAppConstantsFile.readAll());
        qtAppConstantsFile.close();
 
        // Replace APP_LIBRARY_NAME
        // In test bundle mode, use a placeholder — runtime override selects the actual test
        QString appLibName;
        if (options.testBundleMode) {
            appLibName = "libtst_placeholder.so"_L1;
        } else {
            QFileInfo appInfo(options.applicationBinary);
            appLibName = appInfo.fileName(); // Keep the full filename with lib prefix and .so extension
        }
 
        content.replace(QRegularExpression("APP_LIBRARY_NAME = '[^']*'"_L1),
                       "APP_LIBRARY_NAME = '"_L1 + appLibName + "'"_L1);
 
        if (!qtAppConstantsFile.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)) {
            fprintf(stderr, "Failed to open QtAppConstants.ets for writing\n");
            return false;
        }
 
        qtAppConstantsFile.write(content.toUtf8());
        qtAppConstantsFile.close();
 
        if (options.verbose)
            fprintf(stdout, "  Updated QtAppConstants.ets with app name: %s\n", qPrintable(appLibName));
    }
 
    // Resolve the icon value once -- it is consumed by both the app.json5
    // (app-level icon) and module.json5 (ability/launcher icon) customizations
    // below. $media: references pass through; literal filesystem paths get
    // copied into the AppScope *and* entry resource dirs and rewritten to a
    // $media:<basename> reference. OHOS restool restricts resource names to
    // [a-zA-Z0-9_]; sanitize the basename so files like "qt-logo.png" are
    // accepted (becomes "qt_logo.png" / $media:qt_logo).
    QString iconValue = options.harmonyOsAppIcon;
    if (!iconValue.isEmpty() && !iconValue.startsWith("$media:"_L1)) {
        QFileInfo iconInfo(iconValue);
        if (!iconInfo.exists() || !iconInfo.isFile()) {
            fprintf(stderr, "App icon does not exist: %s\n", qPrintable(iconValue));
            return false;
        }
        QString safeStem = iconInfo.completeBaseName();
        for (QChar &c : safeStem) {
            if (!c.isLetterOrNumber() && c != QLatin1Char('_'))
                c = QLatin1Char('_');
        }
        const QString destFileName = iconInfo.suffix().isEmpty()
                ? safeStem
                : safeStem + "."_L1 + iconInfo.suffix();
        const QStringList destDirs = {
            options.outputDirectory + "/AppScope/resources/base/media"_L1,
            options.outputDirectory + "/entry/src/main/resources/base/media"_L1,
        };
        for (const QString &destDir : destDirs) {
            QDir().mkpath(destDir);
            const QString destPath = destDir + "/"_L1 + destFileName;
            if (!copyFileIfNewer(iconValue, destPath, options.verbose)) {
                fprintf(stderr, "Failed to copy app icon to: %s\n", qPrintable(destPath));
                return false;
            }
        }
        iconValue = "$media:"_L1 + safeStem;
    }
 
    // Customize AppScope/app.json5. Use targeted text substitution rather
    // than parse-and-rewrite so JSON5 features in the template (comments,
    // trailing commas, single-quoted strings) survive the round trip --
    // QJsonDocument is a strict JSON parser and would reject those.
    QString appJsonPath = options.outputDirectory + "/AppScope/app.json5"_L1;
    QFile appJsonFile(appJsonPath);
 
    if (appJsonFile.exists()) {
        if (!appJsonFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
            fprintf(stderr, "Failed to open app.json5 for reading\n");
            return false;
        }
        QString content = QString::fromUtf8(appJsonFile.readAll());
        appJsonFile.close();
 
        auto replaceStringField =
                [&content](QLatin1StringView key, const QString &value) {
            if (value.isEmpty())
                return;
            content.replace(
                    QRegularExpression("\""_L1 + key + "\":\\s*\"[^\"]*\""_L1),
                    "\""_L1 + key + "\": \""_L1 + jsonStringEscape(value) + "\""_L1);
        };
 
        replaceStringField("bundleName"_L1, options.harmonyOsAppBundleName);
        replaceStringField("vendor"_L1, options.harmonyOsAppVendor);
        replaceStringField("versionName"_L1, options.harmonyOsAppVersionName);
        // The OHOS schema for app.label requires either "$string:<id>" or a
        // brace-substituted value -- a plain literal is rejected. So only
        // substitute the label field directly when the user supplied a
        // $string: reference. Literal labels are routed below to the
        // app_name/QAbility_label string resources, which app.json5 and
        // module.json5 already reference via $string:.
        if (options.harmonyOsAppLabel.startsWith("$string:"_L1))
            replaceStringField("label"_L1, options.harmonyOsAppLabel);
        replaceStringField("icon"_L1, iconValue);
 
        if (options.harmonyOsAppVersionCode > 0) {
            content.replace(
                    QRegularExpression("\"versionCode\":\\s*\\d+"_L1),
                    "\"versionCode\": "_L1 + QString::number(options.harmonyOsAppVersionCode));
        }
 
        if (!appJsonFile.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)) {
            fprintf(stderr, "Failed to open app.json5 for writing\n");
            return false;
        }
        appJsonFile.write(content.toUtf8());
        appJsonFile.close();
 
        if (options.verbose) {
            fprintf(stdout, "  Updated app.json5 (bundle: %s)\n",
                    qPrintable(options.harmonyOsAppBundleName));
        }
    }
 
    // Display label that lands in the app_name and QAbility_label string
    // resources. A literal LABEL wins; a "$string:..." LABEL was substituted
    // into app.json5 above and is therefore the user's own resource id, so we
    // fall back to the target name here.
    const QString displayLabel =
        (!options.harmonyOsAppLabel.isEmpty()
         && !options.harmonyOsAppLabel.startsWith("$string:"_L1))
            ? options.harmonyOsAppLabel
            : options.harmonyOsAppName;
 
    // Auto-promote plain-literal permission reasons to $string: references.
    // The literal values are appended to the entry/.../string.json files below
    // so the synthesized resource ids resolve correctly at HAP build time.
    QJsonArray transformedPermissions;
    QList<PromotedReason> promotedReasons;
    QSet<QString> seenPromotedIds;
    for (const QJsonValue &value : std::as_const(options.permissions)) {
        if (!value.isObject()) {
            transformedPermissions.append(value);
            continue;
        }
        QJsonObject entry = value.toObject();
        if (entry.contains("reason"_L1)) {
            const QString reason = entry["reason"_L1].toString();
            if (reasonNeedsPromotion(reason)) {
                const QString permName = entry["name"_L1].toString();
                const QString stringId = synthesizePermissionReasonId(permName);
                entry["reason"_L1] = QString("$string:"_L1 + stringId);
                if (!seenPromotedIds.contains(stringId)) {
                    promotedReasons.append({stringId, reason});
                    seenPromotedIds.insert(stringId);
                }
            }
        }
        transformedPermissions.append(entry);
    }
 
    // Customize entry module string resources: replace QAbility_label with the
    // app name, and append any synthesized permission-reason strings.
    // Update all locale variants: base, en_US, zh_CN
    QStringList locales = QStringList() << "base"_L1 << "en_US"_L1 << "zh_CN"_L1;
 
    for (const QString &locale : locales) {
        QString stringJsonPath = options.outputDirectory + "/entry/src/main/resources/"_L1 +
                                locale + "/element/string.json"_L1;
        QFile stringJsonFile(stringJsonPath);
 
        if (!stringJsonFile.exists())
            continue;
 
        if (!stringJsonFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
            fprintf(stderr, "Failed to open %s string.json for reading\n", qPrintable(locale));
            continue;
        }
 
        const QByteArray bytes = stringJsonFile.readAll();
        stringJsonFile.close();
 
        QJsonParseError parseErr;
        QJsonDocument doc = QJsonDocument::fromJson(bytes, &parseErr);
        if (parseErr.error != QJsonParseError::NoError || !doc.isObject()) {
            fprintf(stderr, "Failed to parse %s string.json: %s\n",
                    qPrintable(locale), qPrintable(parseErr.errorString()));
            continue;
        }
        QJsonObject root = doc.object();
        QJsonArray strings = root["string"_L1].toArray();
 
        // Replace QAbility_label value with app name and collect existing names
        QSet<QString> existingNames;
        for (qsizetype i = 0; i < strings.size(); ++i) {
            QJsonObject e = strings[i].toObject();
            const QString name = e["name"_L1].toString();
            existingNames.insert(name);
            if (name == "QAbility_label"_L1) {
                e["value"_L1] = displayLabel;
                strings[i] = e;
            }
        }
 
        // Append synthesized permission-reason strings (skip ids already present)
        for (const PromotedReason &p : std::as_const(promotedReasons)) {
            if (existingNames.contains(p.id))
                continue;
            QJsonObject e;
            e["name"_L1] = p.id;
            e["value"_L1] = p.value;
            strings.append(e);
            existingNames.insert(p.id);
        }
        root["string"_L1] = strings;
        doc.setObject(root);
 
        if (!stringJsonFile.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)) {
            fprintf(stderr, "Failed to open %s string.json for writing\n", qPrintable(locale));
            continue;
        }
 
        stringJsonFile.write(doc.toJson(QJsonDocument::Indented));
        stringJsonFile.close();
 
        if (options.verbose) {
            fprintf(stdout,
                    "  Updated %s string.json (label: %s, +%lld promoted permission reasons)\n",
                    qPrintable(locale), qPrintable(displayLabel),
                    static_cast<long long>(promotedReasons.size()));
        }
    }
 
    // Also update AppScope app_name for consistency
    QString appScopeStringPath = options.outputDirectory + "/AppScope/resources/base/element/string.json"_L1;
    QFile appScopeStringFile(appScopeStringPath);
 
    if (appScopeStringFile.exists()) {
        if (!appScopeStringFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
            fprintf(stderr, "Failed to open AppScope string.json for reading\n");
            return false;
        }
 
        QString content = QString::fromUtf8(appScopeStringFile.readAll());
        appScopeStringFile.close();
 
        // Replace app_name value
        QRegularExpression appNameRegex("(\"name\":\\s*\"app_name\"[^}]*\"value\":\\s*)\"[^\"]*\""_L1);
        content.replace(appNameRegex, "\\1\""_L1 + jsonStringEscape(displayLabel) + "\""_L1);
 
        if (!appScopeStringFile.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)) {
            fprintf(stderr, "Failed to open AppScope string.json for writing\n");
            return false;
        }
 
        appScopeStringFile.write(content.toUtf8());
        appScopeStringFile.close();
 
        if (options.verbose)
            fprintf(stdout, "  Updated AppScope string.json with app name: %s\n",
                   qPrintable(displayLabel));
    }
 
    // Customize module.json5
    // Note: We only update the description, not the module name which must remain "entry"
    QString moduleJsonPath = options.outputDirectory + "/entry/src/main/module.json5"_L1;
    QFile moduleJsonFile(moduleJsonPath);
 
    if (moduleJsonFile.exists()) {
        if (!moduleJsonFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
            fprintf(stderr, "Failed to open module.json5 for reading\n");
            return false;
        }
 
        QString content = QString::fromUtf8(moduleJsonFile.readAll());
        moduleJsonFile.close();
 
        // Substitute the module description sentinel. The user's value (if set
        // via QT_HARMONYOS_MODULE_DESCRIPTION) takes precedence;
        // otherwise fall back to the template's $string:module_desc reference,
        // which resolves via the entry/.../resources/.../string.json file.
        const QString descriptionSentinel = "%%INSERT_MODULE_DESCRIPTION%%"_L1;
        const QString descriptionValue = options.harmonyOsModuleDescription.isEmpty()
            ? "$string:module_desc"_L1
            : jsonStringEscape(options.harmonyOsModuleDescription);
        content.replace(descriptionSentinel, descriptionValue);
 
        // Substitute the deviceTypes sentinel.
        const QString deviceTypesSentinel = "/* %%INSERT_DEVICE_TYPES%% */"_L1;
        QStringList deviceTypes = options.harmonyOsModuleDeviceTypes;
        if (deviceTypes.isEmpty())
            deviceTypes = QStringList{ "phone"_L1, "tablet"_L1, "2in1"_L1 };
        QStringList quotedDeviceTypes;
        quotedDeviceTypes.reserve(deviceTypes.size());
        for (const QString &dt : std::as_const(deviceTypes))
            quotedDeviceTypes.append("\""_L1 + dt + "\""_L1);
        content.replace(deviceTypesSentinel, quotedDeviceTypes.join(", "_L1));
 
        // Substitute the ability-orientation sentinel. The template ships the
        // sentinel as a block comment so module.json5 stays valid JSON5 when
        // the user has not set an orientation; in that case the sentinel line
        // is dropped entirely. When set, replace it with the orientation field
        // (matching the surrounding 8-space indentation already in the
        // template). Unknown values are rejected with a warning rather than
        // forwarded to hvigor, which would fail with a less targeted error.
        const QString orientationSentinelLine =
                "        /* %%INSERT_ABILITY_ORIENTATION%% */\n"_L1;
        QString orientationReplacement;
        if (!options.harmonyOsAbilityOrientation.isEmpty()) {
            if (isValidHarmonyOsAbilityOrientation(options.harmonyOsAbilityOrientation)) {
                orientationReplacement = "        \"orientation\": \""_L1
                        + options.harmonyOsAbilityOrientation
                        + "\",\n"_L1;
            } else {
                fprintf(stderr,
                        "Warning: Ignoring unknown harmonyos-ability-orientation value '%s'\n",
                        qPrintable(options.harmonyOsAbilityOrientation));
            }
        }
        content.replace(orientationSentinelLine, orientationReplacement);
 
        // Override the ability/launcher icon so QT_HARMONYOS_APP_ICON
        // is reflected on the device home screen, not just in Settings. The
        // template ships "$media:layered_image" -- only replace that specific
        // value so user-customized icons in subsequent runs aren't clobbered.
        if (!iconValue.isEmpty()) {
            content.replace(
                    QRegularExpression("\"icon\":\\s*\"\\$media:layered_image\""_L1),
                    "\"icon\": \""_L1 + iconValue + "\""_L1);
        }
 
        // Build the requestPermissions array fragment from the (possibly
        // promoted) transformedPermissions computed above.  The sentinel
        // "/* %%INSERT_PERMISSIONS%% */" sits inside an empty [] so the
        // template stays valid JSON5 even without substitution.
        const QString sentinel = "/* %%INSERT_PERMISSIONS%% */"_L1;
        QString permissionsFragment;
        if (!transformedPermissions.isEmpty()) {
            QStringList entryStrings;
            entryStrings.reserve(transformedPermissions.size());
            for (const QJsonValue &value : std::as_const(transformedPermissions)) {
                if (!value.isObject())
                    continue;
                const QJsonObject entry = value.toObject();
 
                // Pretty-print the entry, then re-indent so it lines up with the
                // surrounding "requestPermissions" array (8-space base indent).
                const QByteArray pretty =
                    QJsonDocument(entry).toJson(QJsonDocument::Indented).trimmed();
                const QStringList lines = QString::fromUtf8(pretty).split(QLatin1Char('\n'));
                QStringList indented;
                indented.reserve(lines.size());
                for (const QString &line : lines)
                    indented.append("        "_L1 + line);
                entryStrings.append(indented.join(QLatin1Char('\n')));
            }
            if (!entryStrings.isEmpty()) {
                permissionsFragment = "\n"_L1 + entryStrings.join(",\n"_L1) + "\n    "_L1;
            }
        }
        content.replace(sentinel, permissionsFragment);
 
        if (!moduleJsonFile.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)) {
            fprintf(stderr, "Failed to open module.json5 for writing\n");
            return false;
        }
 
        moduleJsonFile.write(content.toUtf8());
        moduleJsonFile.close();
 
        if (options.verbose) {
            fprintf(stdout, "  Updated module.json5 description\n");
            fprintf(stdout, "  Injected %lld permissions into module.json5\n",
                    static_cast<long long>(transformedPermissions.size()));
        }
    }
 
    // Customize build-profile.json5 with the SDK version metadata. Only fields
    // that are set are substituted; others keep the template default.
    //
    //   * compatibleSdkVersion is an existing key with a default value -- we
    //     replace its value via the same regex pattern used in app.json5.
    //   * targetSdkVersion / compileSdkVersion don't appear in the template by
    //     default. They are added via comment-style sentinels that the JSON5
    //     parser ignores when not substituted.
    {
        const bool anySdkVersionSet =
            !options.harmonyOsCompatibleSdkVersion.isEmpty()
            || !options.harmonyOsTargetSdkVersion.isEmpty()
            || !options.harmonyOsCompileSdkVersion.isEmpty();
 
        const QString buildProfilePath =
            options.outputDirectory + "/build-profile.json5"_L1;
        QFile buildProfileFile(buildProfilePath);
        if (anySdkVersionSet && buildProfileFile.exists()) {
            if (!buildProfileFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
                fprintf(stderr, "Failed to open build-profile.json5 for reading\n");
                return false;
            }
            QString content = QString::fromUtf8(buildProfileFile.readAll());
            buildProfileFile.close();
 
            if (!options.harmonyOsCompatibleSdkVersion.isEmpty()) {
                content.replace(
                    QRegularExpression(
                        "\"compatibleSdkVersion\":\\s*\"[^\"]*\""_L1),
                    "\"compatibleSdkVersion\": \""_L1
                        + jsonStringEscape(options.harmonyOsCompatibleSdkVersion)
                        + "\""_L1);
            }
 
            const QString targetSentinel = "/* %%INSERT_TARGET_SDK_VERSION%% */"_L1;
            const QString targetReplacement =
                options.harmonyOsTargetSdkVersion.isEmpty()
                    ? QString()
                    : "\"targetSdkVersion\": \""_L1
                          + jsonStringEscape(options.harmonyOsTargetSdkVersion)
                          + "\","_L1;
            content.replace(targetSentinel, targetReplacement);
 
            const QString compileSentinel = "/* %%INSERT_COMPILE_SDK_VERSION%% */"_L1;
            const QString compileReplacement =
                options.harmonyOsCompileSdkVersion.isEmpty()
                    ? QString()
                    : "\"compileSdkVersion\": \""_L1
                          + jsonStringEscape(options.harmonyOsCompileSdkVersion)
                          + "\","_L1;
            content.replace(compileSentinel, compileReplacement);
 
            if (!buildProfileFile.open(
                    QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)) {
                fprintf(stderr, "Failed to open build-profile.json5 for writing\n");
                return false;
            }
            buildProfileFile.write(content.toUtf8());
            buildProfileFile.close();
 
            if (options.verbose) {
                fprintf(stdout,
                        "  Updated build-profile.json5 SDK versions"
                        " (compatible=%s, target=%s, compile=%s)\n",
                        qPrintable(options.harmonyOsCompatibleSdkVersion),
                        qPrintable(options.harmonyOsTargetSdkVersion),
                        qPrintable(options.harmonyOsCompileSdkVersion));
            }
        }
    }
 
    if (options.verbose)
        fprintf(stdout, "Template customization completed\n");
 
    return true;
}
 
static bool copyApplicationBinary(const Options &options)
{
    if (options.verbose)
        fprintf(stdout, "Copying application binary and dependencies\n");
 
    // For each target architecture, copy the application binary
    for (const QString &arch : options.targetArchs) {
        QString archLibPath = options.outputDirectory + "/entry/libs/"_L1 + arch;
        QDir archDir(archLibPath);
        if (!archDir.exists()) {
            if (!archDir.mkpath("."_L1)) {
                fprintf(stderr, "Failed to create architecture directory: %s\n", qPrintable(archLibPath));
                return false;
            }
        }
 
        // Copy application binary
        QFileInfo appInfo(options.applicationBinary);
        QString destPath = archLibPath + "/"_L1 + appInfo.fileName();
 
        if (!appInfo.fileName().startsWith("lib"_L1)) {
            // Ensure it has lib prefix
            destPath = archLibPath + "/lib"_L1 + appInfo.fileName();
        }
 
        if (!destPath.endsWith(".so"_L1)) {
            // Ensure it has .so extension
            destPath += ".so"_L1;
        }
 
        if (options.verbose) {
            fprintf(stdout, "  Copying application binary for %s: %s -> %s\n",
                   qPrintable(arch), qPrintable(options.applicationBinary), qPrintable(destPath));
        }
 
        if (!copyFileIfNewer(options.applicationBinary, destPath, options.verbose)) {
          fprintf(stderr, "Failed to copy application binary to: %s\n",
                  qPrintable(destPath));
          return false;
        }
 
        // Track as dependency for depfile
        if (!options.depFilePath.isEmpty())
            dependenciesForDepfile << options.applicationBinary;
    }
 
    if (options.verbose)
        fprintf(stdout, "Application binary copied successfully\n");
 
    return true;
}
 
static bool copyFileToArchitectures(const Options &options,
                                    const QString &sourcePath,
                                    const QString &relativeDestPath,
                                    bool trackInDepfile = true)
{
    for (const QString &arch : options.targetArchs) {
        QString destPath = "%1/entry/libs/%2/%3"_L1
            .arg(options.outputDirectory, arch, relativeDestPath);
 
        QDir().mkpath(QFileInfo(destPath).absolutePath());
 
        if (options.verbose)
            fprintf(stdout, "  Copying for %s: %s\n",
                   qPrintable(arch), qPrintable(QFileInfo(sourcePath).fileName()));
 
        if (!copyFileIfNewer(sourcePath, destPath, options.verbose)) {
            fprintf(stderr, "Failed to copy file: %s to %s\n",
                   qPrintable(sourcePath), qPrintable(destPath));
            return false;
        }
 
        // Track as dependency for depfile (only once, not per-arch)
        if (trackInDepfile && !options.depFilePath.isEmpty() && arch == options.targetArchs.first())
            dependenciesForDepfile << sourcePath;
    }
    return true;
}
 
static QString findStdCppLibrary(const Options &options, const QString &arch)
{
    // Map architecture to NDK triple
    QString ndkArch;
    if (arch == "arm64-v8a"_L1) {
        ndkArch = "aarch64-linux-ohos"_L1;
    } else if (arch == "armeabi-v7a"_L1) {
        ndkArch = "arm-linux-ohos"_L1;
    } else if (arch == "x86_64"_L1) {
        ndkArch = "x86_64-linux-ohos"_L1;
    } else if (arch == "x86"_L1) {
        ndkArch = "i686-linux-ohos"_L1;
    } else {
        return QString();
    }
 
    QString stdCppPath = options.ndkRoot + "/llvm/lib/"_L1 + ndkArch + "/c++/libc++_shared.so"_L1;
    if (QFile::exists(stdCppPath))
        return stdCppPath;
 
    stdCppPath = options.ndkRoot + "/llvm/lib/"_L1 + ndkArch + "/libc++_shared.so"_L1;
    if (QFile::exists(stdCppPath))
        return stdCppPath;
 
    return QString();
}
 
// Copy project-specific shared libraries (test helper libs, etc.) flat into
// entry/libs/<arch>/. These are non-Qt libs listed in "project-libraries" in
// the deployment settings JSON, collected from the target's LINK_LIBRARIES by
// Qt6HarmonyOSMacros.cmake.
static bool copyProjectLibraries(const Options &options)
{
    if (options.projectLibraries.isEmpty())
        return true;
 
    if (options.verbose)
        fprintf(stdout, "Copying project libraries\n");
 
    for (const QString &projectLib : options.projectLibraries) {
        QFileInfo libInfo(projectLib);
        if (!libInfo.exists()) {
            if (options.verbose)
                fprintf(stdout, "  Project library not found, skipping: %s\n",
                        qPrintable(projectLib));
            continue;
        }
 
        for (const QString &arch : options.targetArchs) {
            QString archLibPath = options.outputDirectory + "/entry/libs/"_L1 + arch;
            QString destPath = archLibPath + "/"_L1 + libInfo.fileName();
 
            if (options.verbose) {
                fprintf(stdout, "  Copying project library for %s: %s\n",
                       qPrintable(arch), qPrintable(libInfo.fileName()));
            }
 
            if (!copyFileIfNewer(projectLib, destPath, options.verbose)) {
                fprintf(stderr, "Failed to copy project library to: %s\n",
                        qPrintable(destPath));
                return false;
            }
 
            if (!options.depFilePath.isEmpty())
                dependenciesForDepfile << projectLib;
        }
    }
 
    if (options.verbose)
        fprintf(stdout, "Project libraries copied successfully\n");
 
    return true;
}
 
// Recursively scan dirPath for libtst_*.so test binaries and their co-located helper libs.
// Test binaries are appended to found; helper libs (lib*.so* in the same directory as a
// test binary) are appended to foundHelpers. helperNames guards against filename collisions
// across directories. excludeDirs is a list of absolute paths to skip during recursion.
static void scanTestBinariesDir(const QString &dirPath,
                                const QStringList &excludeList,
                                const QStringList &excludeDirs,
                                QStringList &found,
                                QStringList &foundHelpers,
                                QSet<QString> &helperNames)
{
    const QFileInfoList entries =
        QDir(dirPath).entryInfoList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
 
    bool hasTestBinary = false;
    for (const QFileInfo &entry : entries) {
        if (!entry.isDir()
            && entry.fileName().startsWith("libtst_"_L1)
            && entry.suffix() == "so"_L1
            && !excludeList.contains(entry.fileName())) {
            found.append(entry.filePath());
            hasTestBinary = true;
        }
    }
 
    // For each directory that contains a test binary, also collect co-located helper libs
    // (e.g. libqmetatype_lib1.so.0) so that $ORIGIN rpath lookups resolve on-device.
    if (hasTestBinary) {
        for (const QFileInfo &entry : entries) {
            if (!entry.isDir()
                && entry.fileName().startsWith("lib"_L1)
                && !entry.fileName().startsWith("libtst_"_L1)
                && entry.fileName().contains(".so"_L1)
                && !helperNames.contains(entry.fileName())) {
                foundHelpers.append(entry.filePath());
                helperNames.insert(entry.fileName());
            }
        }
    }
 
    for (const QFileInfo &entry : entries) {
        if (entry.isDir() && !excludeDirs.contains(entry.absoluteFilePath()))
            scanTestBinariesDir(entry.filePath(), excludeList, excludeDirs, found, foundHelpers, helperNames);
    }
}
 
static bool copyTestBinaries(const Options &options, QStringList &bundledBinaries)
{
    if (options.testBinariesDirectory.isEmpty()) {
        fprintf(stderr, "Error: 'test-binaries-directory' not specified for test bundle mode\n");
        return false;
    }
 
    if (!QDir(options.testBinariesDirectory).exists()) {
        fprintf(stderr, "Error: test-binaries-directory does not exist: %s\n",
                qPrintable(options.testBinariesDirectory));
        return false;
    }
 
    if (options.verbose)
        fprintf(stdout, "Scanning for test binaries in %s\n", qPrintable(options.testBinariesDirectory));
 
    QStringList found;
    QStringList foundHelpers;
    QSet<QString> helperNames;
    // Exclude the output directory to avoid scanning previously generated HAP bundle contents,
    // which would cause libentry.so (built by hvigor/CMake) to be picked up as a helper lib
    // and then conflict with the CMake-built version during the hvigor build.
    const QStringList excludeDirs = { QFileInfo(options.outputDirectory).absoluteFilePath() };
    scanTestBinariesDir(options.testBinariesDirectory, options.testExcludeList, excludeDirs,
                        found, foundHelpers, helperNames);
 
    if (found.isEmpty()) {
        fprintf(stderr, "Warning: No test binaries (libtst_*.so) found in %s\n",
                qPrintable(options.testBinariesDirectory));
        return true; // Not fatal
    }
 
    if (options.verbose) {
        fprintf(stdout, "Found %lld test binaries\n", static_cast<long long>(found.size()));
        if (!foundHelpers.isEmpty())
            fprintf(stdout, "Found %lld test helper libraries\n",
                    static_cast<long long>(foundHelpers.size()));
    }
 
    // Copy all test binaries AND helper libs flat to entry/libs/${arch}/
    for (const QString &arch : options.targetArchs) {
        QString archLibPath = options.outputDirectory + "/entry/libs/"_L1 + arch;
        QDir().mkpath(archLibPath);
 
        for (const QString &testBinary : found) {
            QFileInfo testInfo(testBinary);
            QString destPath = archLibPath + "/"_L1 + testInfo.fileName();
 
            if (options.verbose)
                fprintf(stdout, "  Copying test binary: %s\n", qPrintable(testInfo.fileName()));
 
            if (!copyFileIfNewer(testBinary, destPath, options.verbose)) {
                fprintf(stderr, "Failed to copy test binary: %s\n", qPrintable(testBinary));
                return false;
            }
        }
 
        for (const QString &helperLib : foundHelpers) {
            QFileInfo helperInfo(helperLib);
            QString destPath = archLibPath + "/"_L1 + helperInfo.fileName();
 
            if (options.verbose)
                fprintf(stdout, "  Copying test helper lib: %s\n", qPrintable(helperInfo.fileName()));
 
            if (!copyFileIfNewer(helperLib, destPath, options.verbose)) {
                fprintf(stderr, "Failed to copy test helper lib: %s\n", qPrintable(helperLib));
                return false;
            }
        }
    }
 
    // Build list of bundled binary filenames (no duplicates)
    for (const QString &testBinary : found) {
        QString fileName = QFileInfo(testBinary).fileName();
        if (!bundledBinaries.contains(fileName))
            bundledBinaries.append(fileName);
    }
 
    // Track for depfile
    if (!options.depFilePath.isEmpty()) {
        for (const QString &testBinary : found)
            dependenciesForDepfile << testBinary;
        for (const QString &helperLib : foundHelpers)
            dependenciesForDepfile << helperLib;
    }
 
    return true;
}
 
static bool writeTestBinariesList(const Options &options, const QStringList &bundledBinaries)
{
    QString binariesListPath = options.outputDirectory + "/binaries.txt"_L1;
 
    if (options.verbose)
        fprintf(stdout, "Writing test binaries list: %s\n", qPrintable(binariesListPath));
 
    QFile file(binariesListPath);
    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        fprintf(stderr, "Failed to open binaries.txt for writing: %s\n",
                qPrintable(binariesListPath));
        return false;
    }
 
    for (const QString &binary : bundledBinaries) {
        file.write(binary.toUtf8());
        file.write("\n");
    }
    file.close();
 
    if (options.verbose) {
        fprintf(stdout, "Wrote %lld test binary names to binaries.txt\n",
                static_cast<long long>(bundledBinaries.size()));
    }
 
    return true;
}
 
static QString readElfSoname(const Options &options, const QString &binaryPath);
 
static bool copyAllQtLibs(const Options &options)
{
    if (options.qtLibsDirectory.isEmpty())
        return true;
 
    if (!QDir(options.qtLibsDirectory).exists()) {
        if (options.verbose) {
            fprintf(stdout, "Qt libs directory not found, skipping: %s\n",
                    qPrintable(options.qtLibsDirectory));
        }
        return true;
    }
 
    if (options.verbose)
        fprintf(stdout, "Copying all Qt libraries from %s\n", qPrintable(options.qtLibsDirectory));
 
    QDir libsDir(options.qtLibsDirectory);
    const QFileInfoList entries = libsDir.entryInfoList({"*.so"_L1, "*.so.*"_L1}, QDir::Files);
 
    for (const QFileInfo &entry : entries) {
        for (const QString &arch : options.targetArchs) {
            QString destPath = options.outputDirectory + "/entry/libs/"_L1 + arch + "/"_L1 + entry.fileName();
            QDir().mkpath(QFileInfo(destPath).absolutePath());
            if (!copyFileIfNewer(entry.filePath(), destPath, options.verbose))
                return false;
        }
        if (!options.depFilePath.isEmpty())
            dependenciesForDepfile << entry.filePath();
    }
 
    // Also copy libc++_shared.so from NDK for each architecture
    for (const QString &arch : options.targetArchs) {
        QString stdCppPath = findStdCppLibrary(options, arch);
        if (!stdCppPath.isEmpty()) {
            QString destPath = options.outputDirectory + "/entry/libs/"_L1 + arch + "/libc++_shared.so"_L1;
            if (options.verbose)
                fprintf(stdout, "  Copying C++ standard library for %s\n", qPrintable(arch));
            if (!copyFileIfNewer(stdCppPath, destPath, options.verbose))
                return false;
            if (!options.depFilePath.isEmpty())
                dependenciesForDepfile << stdCppPath;
        }
    }
 
    // Copy all libraries from extra-libs-dirs (e.g. third-party deps like ICU, fontconfig)
    for (const QString &extraDir : options.extraLibsDirs) {
        QDir dir(extraDir);
        if (!dir.exists()) {
            if (options.verbose)
                fprintf(stdout, "Extra libs dir not found, skipping: %s\n", qPrintable(extraDir));
            continue;
        }
 
        if (options.verbose)
            fprintf(stdout, "Copying extra libraries from %s\n", qPrintable(extraDir));
 
        const QFileInfoList entries = dir.entryInfoList({"*.so"_L1, "*.so.*"_L1}, QDir::Files);
        for (const QFileInfo &entry : entries) {
            // Deploy using the library's SONAME if it differs from the on-disk filename,
            // so the dynamic linker can find it at runtime (e.g. libicudata.so.78,
            // not libicudata.so).
            const QString soname = readElfSoname(options, entry.filePath());
            const QString deployName = (!soname.isEmpty() && soname != entry.fileName())
                                           ? soname : entry.fileName();
            for (const QString &arch : options.targetArchs) {
                QString destPath = options.outputDirectory + "/entry/libs/"_L1 + arch + "/"_L1 + deployName;
                QDir().mkpath(QFileInfo(destPath).absolutePath());
                if (!copyFileIfNewer(entry.filePath(), destPath, options.verbose))
                    return false;
            }
            if (!options.depFilePath.isEmpty())
                dependenciesForDepfile << entry.filePath();
        }
    }
 
    return true;
}
 
static bool copyAllQtPlugins(const Options &options)
{
    // Copy all plugins from one plugins root directory.
    auto copyPluginsFromDir = [&options](const QString &pluginsRootPath) -> bool {
        QDir pluginsDir(pluginsRootPath);
        const QStringList categories = pluginsDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
 
        for (const QString &category : categories) {
            QDir categoryDir(pluginsDir.filePath(category));
            const QFileInfoList plugins = categoryDir.entryInfoList({"*.so"_L1}, QDir::Files);
 
            for (const QFileInfo &pluginInfo : plugins) {
                const QString &plugin = pluginInfo.fileName();
                const QString &pluginPath = pluginInfo.filePath();
 
                if (category == "platforms"_L1 && plugin == "libqohos.so"_L1) {
                    // Platform plugin goes flat to root libs directory
                    for (const QString &arch : options.targetArchs) {
                        QString destPath = options.outputDirectory + "/entry/libs/"_L1 + arch + "/libqohos.so"_L1;
                        QDir().mkpath(QFileInfo(destPath).absolutePath());
                        if (!copyFileIfNewer(pluginPath, destPath, options.verbose))
                            return false;
                    }
                } else {
                    // All other plugins go into their category subdirectory
                    QString relativeDestPath = category + "/"_L1 + plugin;
                    if (!copyFileToArchitectures(options, pluginPath, relativeDestPath, false))
                        return false;
                }
 
                if (!options.depFilePath.isEmpty())
                    dependenciesForDepfile << pluginPath;
            }
        }
        return true;
    };
 
    // Process plugins-import-paths first (typically CMAKE_BINARY_DIR/plugins,
    // i.e. the module's own build-tree plugin output).  Files written here
    // receive dest mtime = now, so the subsequent qtPluginsDirectory pass
    // skips any file that was already copied — this gives build-dir contents
    // unconditional priority over the installed Qt prefix without requiring a
    // force-overwrite flag.
    for (const QString &importPath : options.pluginsImportPaths) {
        if (!QDir(importPath).exists()) {
            if (options.verbose)
                fprintf(stdout, "Plugins import path not found, skipping: %s\n",
                        qPrintable(importPath));
            continue;
        }
        if (options.verbose)
            fprintf(stdout, "Copying Qt plugins from import path: %s\n",
                    qPrintable(importPath));
        if (!copyPluginsFromDir(importPath))
            return false;
    }
 
    // Process qtPluginsDirectory second (the installed Qt prefix).  Files
    // already present in dest (copied from plugins-import-paths above) are
    // skipped by copyFileIfNewer; plugins that exist only in the installed
    // prefix are copied normally.
    if (options.qtPluginsDirectory.isEmpty())
        return true;
 
    if (!QDir(options.qtPluginsDirectory).exists()) {
        if (options.verbose) {
            fprintf(stdout, "Qt plugins directory not found, skipping: %s\n",
                    qPrintable(options.qtPluginsDirectory));
        }
        return true;
    }
 
    if (options.verbose)
        fprintf(stdout, "Copying all Qt plugins from %s\n", qPrintable(options.qtPluginsDirectory));
 
    return copyPluginsFromDir(options.qtPluginsDirectory);
}
 
// Copy user-supplied extra plugins listed in QT_HARMONYOS_EXTRA_PLUGINS into
// entry/libs/<arch>/<category>/. The category is derived from the parent
// directory of each plugin source path (e.g. .../imageformats/libfoo.so ->
// "imageformats/libfoo.so"); plugins without a usable parent directory name
// are deployed flat under entry/libs/<arch>/.
static bool copyExtraPlugins(const Options &options)
{
    if (options.extraPlugins.isEmpty())
        return true;
 
    if (options.verbose)
        fprintf(stdout, "Copying extra plugins\n");
 
    for (const QString &pluginPath : options.extraPlugins) {
        const QFileInfo pluginInfo(pluginPath);
        if (!pluginInfo.exists() || !pluginInfo.isFile()) {
            fprintf(stderr, "Extra plugin does not exist: %s\n", qPrintable(pluginPath));
            return false;
        }
 
        const QString category = pluginInfo.absoluteDir().dirName();
        QString relativeDestPath;
        if (category.isEmpty() || category == "plugins"_L1)
            relativeDestPath = pluginInfo.fileName();
        else
            relativeDestPath = category + "/"_L1 + pluginInfo.fileName();
 
        if (options.verbose) {
            fprintf(stdout, "  Extra plugin: %s -> entry/libs/<arch>/%s\n",
                    qPrintable(pluginInfo.fileName()), qPrintable(relativeDestPath));
        }
 
        if (!copyFileToArchitectures(options, pluginInfo.filePath(), relativeDestPath))
            return false;
    }
 
    return true;
}
 
// .so files in the QML directory go flat to entry/libs/<arch>/; all other files
// preserve directory structure under resfile/qml/.
static bool copyQmlDir(const QString &srcDir, const QString &relPath,
                       const QString &qmlDestBase, const Options &options)
{
    const QFileInfoList entries =
        QDir(srcDir).entryInfoList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden);
 
    for (const QFileInfo &entry : entries) {
        const QString entryRelPath = relPath.isEmpty()
            ? entry.fileName()
            : relPath + "/"_L1 + entry.fileName();
 
        if (entry.isDir()) {
            if (!copyQmlDir(entry.filePath(), entryRelPath, qmlDestBase, options))
                return false;
        } else if (entry.suffix() == "so"_L1) {
            for (const QString &arch : options.targetArchs) {
                QString destPath = options.outputDirectory + "/entry/libs/"_L1
                                  + arch + "/"_L1 + entry.fileName();
                QDir().mkpath(QFileInfo(destPath).absolutePath());
                if (!copyFileIfNewer(entry.filePath(), destPath, options.verbose))
                    return false;
            }
            if (!options.depFilePath.isEmpty())
                dependenciesForDepfile << entry.filePath();
        } else {
            QString destPath = qmlDestBase + "/"_L1 + entryRelPath;
            QDir().mkpath(QFileInfo(destPath).absolutePath());
            if (!copyFileIfNewer(entry.filePath(), destPath, options.verbose))
                return false;
            if (!options.depFilePath.isEmpty())
                dependenciesForDepfile << entry.filePath();
        }
    }
    return true;
}
 
static QString hapQmlDir(const Options &options)
{
    return options.outputDirectory + "/entry/src/main/resources/resfile/qml"_L1;
}
 
static bool copyAllQmlModules(const Options &options)
{
    const QString qmlDestBase = hapQmlDir(options);
 
    // Process qml-import-paths first (typically CMAKE_BINARY_DIR/qml, i.e. the
    // module's own build-tree QML output).  Files written here receive dest
    // mtime = now, so the subsequent qtQmlDirectory pass skips any file that
    // was already copied — this gives build-dir contents unconditional priority
    // over the installed Qt prefix without requiring a force-overwrite flag.
    for (const QString &importPath : options.qmlImportPaths) {
        if (!QDir(importPath).exists()) {
            if (options.verbose)
                fprintf(stdout, "QML import path not found, skipping: %s\n",
                        qPrintable(importPath));
            continue;
        }
        if (options.verbose)
            fprintf(stdout, "Copying QML modules from import path: %s\n",
                    qPrintable(importPath));
        if (!copyQmlDir(importPath, QString(), qmlDestBase, options))
            return false;
    }
 
    // Process qtQmlDirectory second (the installed Qt prefix).  Files that are
    // already present in dest (copied from qml-import-paths above) are skipped
    // by copyFileIfNewer; files that exist only here — e.g. QtQml/QtQuick when
    // building qtlottie against an installed qtdeclarative — are copied normally.
    if (options.qtQmlDirectory.isEmpty())
        return true;
    if (!QDir(options.qtQmlDirectory).exists()) {
        if (options.verbose)
            fprintf(stdout, "QML directory not found, skipping: %s\n",
                    qPrintable(options.qtQmlDirectory));
        return true;
    }
    if (options.verbose)
        fprintf(stdout, "Copying all QML modules from %s\n",
                qPrintable(options.qtQmlDirectory));
    return copyQmlDir(options.qtQmlDirectory, QString(), qmlDestBase, options);
}
 
static bool readQmldirLines(const QString &qmldirPath, QStringList &lines)
{
    QFile qmldir(qmldirPath);
    if (!qmldir.open(QIODevice::ReadOnly | QIODevice::Text)) {
        fprintf(stderr, "Failed to open qmldir %s: %s\n",
                qPrintable(qmldirPath), qPrintable(qmldir.errorString()));
        return false;
    }
 
    lines = QString::fromUtf8(qmldir.readAll()).split(u'\n');
 
    return true;
}
 
// Deploy the plugins (*.so files) a qmldir declares to libs/<arch>.
static bool copyQmldirPlugins(const QString &qmldirPath, const Options &options)
{
    QStringList lines;
    if (!readQmldirLines(qmldirPath, lines))
        return false;
 
    static const QRegularExpression pluginLine(
        "^\\s*(?:optional\\s+)?plugin\\s+(?<name>\\S+)(?:\\s+(?<path>\\S+))?"_L1);
 
    const QDir moduleDir = QFileInfo(qmldirPath).absoluteDir();
 
    for (const QString &line : lines) {
        const QRegularExpressionMatch match = pluginLine.match(line);
        if (!match.hasMatch())
            continue;
 
        const QString pluginName = match.captured(u"name");
        const QString pluginFile = "lib"_L1 + pluginName + ".so"_L1;
        const QString optionalPluginPath = match.captured(u"path");
        const QString pluginSrc = moduleDir.filePath(
            optionalPluginPath.isEmpty() ? pluginFile : optionalPluginPath + "/"_L1 + pluginFile);
 
        if (!QFileInfo::exists(pluginSrc)) {
            if (options.verbose) {
                fprintf(stdout, "  qmldir %s declares plugin %s, but %s is missing\n",
                        qPrintable(qmldirPath), qPrintable(pluginName),
                        qPrintable(pluginSrc));
            }
            continue;
        }
 
        if (!copyFileToArchitectures(options, pluginSrc, pluginFile))
            return false;
    }
 
    return true;
}
 
static bool getQmldirModuleUri(const QString &qmldirPath, QString &uri)
{
    QStringList lines;
    if (!readQmldirLines(qmldirPath, lines))
        return false;
 
    static const QRegularExpression moduleLine("^\\s*module\\s+(?<uri>\\S+)"_L1);
    for (const QString &line : lines) {
        const QRegularExpressionMatch match = moduleLine.match(line);
        if (match.hasMatch()) {
            uri = match.captured(u"uri");
            return true;
        }
    }
 
    uri.clear();
 
    return true;
}
 
static QString findNearestEnclosingTestDir(const QString &startDir, const QSet<QString> &testDirs)
{
    for (QDir dir(startDir); ; ) {
        const QString path = dir.absolutePath();
 
        if (testDirs.contains(path))
            return path;
 
        if (!dir.cdUp())
            return QString();
    }
}
 
struct TestQmlModule
{
    QString qmldirPath;
    QString testDir;
};
 
static bool getTestQmlModuleDeployDir(const TestQmlModule &testModule, QString &deployDir)
{
    QString uri;
    if (!getQmldirModuleUri(testModule.qmldirPath, uri))
        return false;
 
    if (uri.isEmpty()) {
        deployDir = QDir(testModule.testDir).relativeFilePath(
            QFileInfo(testModule.qmldirPath).absolutePath());
    } else {
        deployDir = uri.replace(u'.', u'/');
    }
 
    return true;
}
 
static QList<TestQmlModule> findTestQmlModules(const Options &options)
{
    if (options.testBinariesDirectory.isEmpty())
        return {};
 
    QStringList testBinaries;
    QStringList unusedHelperLibs;
    QSet<QString> unusedHelperLibNames;
    const QStringList excludeDirs = { QFileInfo(options.outputDirectory).absoluteFilePath() };
    scanTestBinariesDir(options.testBinariesDirectory, options.testExcludeList, excludeDirs,
                        testBinaries, unusedHelperLibs, unusedHelperLibNames);
 
    QSet<QString> testDirs;
    for (const QString &testBinary : std::as_const(testBinaries))
        testDirs.insert(QFileInfo(testBinary).absoluteDir().absolutePath());
 
    QList<TestQmlModule> modules;
    QSet<QString> seenQmldirs;
    for (const QString &testDir : std::as_const(testDirs)) {
        QDirIterator it(testDir, { "qmldir"_L1 }, QDir::Files, QDirIterator::Subdirectories);
        while (it.hasNext()) {
            const QString qmldirPath = it.next();
            if (seenQmldirs.contains(qmldirPath))
                continue;
 
            const QString testDir =
                findNearestEnclosingTestDir(QFileInfo(qmldirPath).absolutePath(), testDirs);
            seenQmldirs.insert(qmldirPath);
            modules.append({ qmldirPath, testDir });
        }
    }
 
    return modules;
}
 
// Fail if two test QML modules in the bundle deploy to the same directory under
// resfile/qml, where one would overwrite the other.
static bool verifyUniqueTestQmlModuleDeployDirs(const QList<TestQmlModule> &modules)
{
    QHash<QString, QString> deployDirToQmldir;
    for (const TestQmlModule &module : modules) {
        QString deployDir;
        if (!getTestQmlModuleDeployDir(module, deployDir))
            return false;
 
        const auto existing = deployDirToQmldir.constFind(deployDir);
        if (existing != deployDirToQmldir.constEnd()) {
            fprintf(stderr,
                    "Error: two test QML modules deploy to the same directory \"%s\" "
                    "under resfile/qml:\n  %s\n  %s\n"
                    "They would overwrite one another; give one a different module URI.\n",
                    qPrintable(deployDir), qPrintable(*existing), qPrintable(module.qmldirPath));
            return false;
        }
        deployDirToQmldir.insert(deployDir, module.qmldirPath);
    }
 
    return true;
}
 
static bool copyTestQmlModuleFiles(const QString &moduleSrcDirPath,
                                   const QString &destModuleDirPath, const Options &options)
{
    static const QStringList qmlModuleFileNameFilters = {
        "qmldir"_L1,
        "*.qmltypes"_L1,
        "*.qml"_L1,
        "*.js"_L1,
        "*.mjs"_L1,
    };
 
    const QDir moduleSrcDir(moduleSrcDirPath);
    QDirIterator it(
        moduleSrcDirPath, qmlModuleFileNameFilters, QDir::Files, QDirIterator::Subdirectories);
    while (it.hasNext()) {
        const QString srcPath = it.next();
        const QString destPath =
            destModuleDirPath + "/"_L1 + moduleSrcDir.relativeFilePath(srcPath);
 
        QDir().mkpath(QFileInfo(destPath).absolutePath());
 
        if (!copyFileIfNewer(srcPath, destPath, options.verbose))
            return false;
 
        if (!options.depFilePath.isEmpty())
            dependenciesForDepfile << srcPath;
 
        if (it.fileName() == "qmldir"_L1 && !copyQmldirPlugins(srcPath, options))
            return false;
    }
 
    return true;
}
 
// Deploy each test's generated QML modules into resfile/qml
static bool copyTestQmlModules(const QList<TestQmlModule> &modules, const Options &options)
{
    for (const TestQmlModule &module : modules) {
        const QString moduleSrcDir = QFileInfo(module.qmldirPath).absolutePath();
 
        QString deployDir;
        if (!getTestQmlModuleDeployDir(module, deployDir))
            return false;
 
        const QString destModuleDir = hapQmlDir(options) + "/"_L1 + deployDir;
        if (!copyTestQmlModuleFiles(moduleSrcDir, destModuleDir, options))
            return false;
    }
 
    return true;
}
 
static QString findLlvmReadobj(const Options &options)
{
    // Look for llvm-readobj in the NDK and alternative path
    const QStringList searchPaths = {
        options.ndkRoot + "/llvm/bin"_L1,
        options.sdkRoot + "/command-line-tools/sdk/default/openharmony/native/llvm/bin"_L1
    };
 
    const QString llvmReadobj = QStandardPaths::findExecutable("llvm-readobj"_L1, searchPaths);
    if (!llvmReadobj.isEmpty())
        return llvmReadobj;
 
    return QString();
}
 
struct QtDependency
{
    QString relativePath;  // e.g., "lib/libQt6Core.so"
    QString absolutePath;  // Full path on filesystem
};
 
// Returns the SONAME embedded in the ELF dynamic section of the library, or an empty
// string if it cannot be determined. The SONAME may differ from the on-disk filename
// (e.g. libicudata.so has SONAME libicudata.so.78).
static QString readElfSoname(const Options &options, const QString &binaryPath)
{
    const QString llvmReadobj = findLlvmReadobj(options);
    if (llvmReadobj.isEmpty())
        return QString();
 
    QProcess process;
    process.start(llvmReadobj, {"--dynamic"_L1, binaryPath});
    if (!process.waitForStarted() || !process.waitForFinished(30000))
        return QString();
 
    const QString output = QString::fromUtf8(process.readAllStandardOutput());
    // Output line: "  0x...E SONAME   Library soname: [libfoo.so.1]"
    for (const auto &line : output.split('\n'_L1)) {
        if (!line.contains("SONAME"_L1))
            continue;
        const int lb = line.indexOf('['_L1);
        const int rb = line.indexOf(']'_L1, lb);
        if (lb >= 0 && rb > lb)
            return line.mid(lb + 1, rb - lb - 1);
    }
    return QString();
}
 
static QStringList readElfDependencies(const Options &options, const QString &binaryPath)
{
    QString llvmReadobj = findLlvmReadobj(options);
    if (llvmReadobj.isEmpty()) {
        fprintf(stderr, "Warning: llvm-readobj not found, cannot detect dependencies\n");
        return QStringList();
    }
 
    QProcess process;
    QStringList arguments;
    arguments << "--needed-libs"_L1 << binaryPath;
 
    process.start(llvmReadobj, arguments);
    if (!process.waitForStarted()) {
        fprintf(stderr, "Failed to start llvm-readobj\n");
        return QStringList();
    }
 
    if (!process.waitForFinished(30000)) { // 30 second timeout
        fprintf(stderr, "llvm-readobj timed out\n");
        process.kill();
        return QStringList();
    }
 
    if (process.exitCode() != 0) {
        fprintf(stderr, "llvm-readobj failed with exit code %d\n", process.exitCode());
        return QStringList();
    }
 
    QStringList dependencies;
    QString output = QString::fromUtf8(process.readAllStandardOutput());
    QStringList lines = output.split('\n'_L1);
 
    bool inNeededLibs = false;
    for (const QString &line : lines) {
        QString trimmed = line.trimmed();
 
        if (trimmed.startsWith("NeededLibraries"_L1)) {
            inNeededLibs = true;
            continue;
        }
 
        if (!inNeededLibs)
            continue;
 
        // Stop at next section
        if (trimmed.isEmpty() || trimmed.contains(':'_L1))
            break;
 
        // Extract library name
        if (trimmed.startsWith("lib"_L1))
            dependencies.append(trimmed);
    }
 
    return dependencies;
}
 
static QString findExtraDepLibrary(const Options &options, const QString &libName)
{
    for (const QString &dir : options.extraLibsDirs) {
        // Try exact name first (e.g. libicudata.so.78)
        QString libPath = dir + "/"_L1 + libName;
        if (QFile::exists(libPath))
            return libPath;
        // Fall back to unversioned name (e.g. libicudata.so) for libraries whose
        // SONAME carries a version suffix but the file on disk does not.
        int soIdx = libName.indexOf(".so."_L1);
        if (soIdx >= 0) {
            QString baseName = libName.left(soIdx + 3); // up to and including ".so"
            libPath = dir + "/"_L1 + baseName;
            if (QFile::exists(libPath))
                return libPath;
        }
    }
    return QString();
}
 
static bool isSystemLibrary(const QString &libName)
{
    // System libraries that should not be bundled
    return libName.startsWith("libc."_L1) ||
           libName.startsWith("libm."_L1) ||
           libName.startsWith("libdl."_L1) ||
           libName == "libEGL.so"_L1 ||
           libName == "libGLESv2.so"_L1 ||
           libName == "libGLESv3.so"_L1 ||
           libName.startsWith("libz."_L1) ||
           libName == "libc++_shared.so"_L1;
}
 
static QString findQtLibrary(const Options &options, const QString &libName)
{
    // Use qtLibsDirectory if provided (preferred method, from JSON config)
    if (!options.qtLibsDirectory.isEmpty()) {
        QString libPath = options.qtLibsDirectory + "/"_L1 + libName;
        if (QFile::exists(libPath))
            return libPath;
    }
 
    // Fallback: walk up from application binary to find Qt installation
    QFileInfo appInfo(options.applicationBinary);
    QDir dir(appInfo.absolutePath());
    for (int i = 0; i < 10; ++i) {
        // Check qtbase/lib (common for non-prefix builds)
        QString qtbaseLib = dir.absoluteFilePath("qtbase/lib"_L1);
        if (QDir(qtbaseLib).exists()) {
            QString libPath = qtbaseLib + "/"_L1 + libName;
            if (QFile::exists(libPath))
                return libPath;
        }
        // Check lib directory
        QString libDir = dir.absoluteFilePath("lib"_L1);
        if (QDir(libDir).exists()) {
            QString libPath = libDir + "/"_L1 + libName;
            if (QFile::exists(libPath))
                return libPath;
        }
        if (!dir.cdUp())
            break;
    }
 
    return QString();
}
 
static bool detectAndCopyDependencies(const Options &options, QSet<QString> &processedLibs)
{
    if (options.verbose)
        fprintf(stdout, "Detecting Qt library dependencies\n");
 
    // Start with the application binary
    QStringList toProcess;
    toProcess.append(options.applicationBinary);
 
    // Add project libraries to the ELF dependency analysis queue so their Qt
    // dependencies are also transitively scanned and deployed.
    for (const QString &projectLib : options.projectLibraries)
        toProcess.append(projectLib);
 
    QList<QtDependency> qtDependencies;
    QStringList detectedQtModules; // Track detected Qt module names
    bool needsStdCpp = false;
 
    while (!toProcess.isEmpty()) {
        QString currentLib = toProcess.takeFirst();
 
        if (processedLibs.contains(currentLib))
            continue;
 
        processedLibs.insert(currentLib);
 
        if (options.verbose)
            fprintf(stdout, "  Analyzing: %s\n", qPrintable(QFileInfo(currentLib).fileName()));
 
        QStringList deps = readElfDependencies(options, currentLib);
 
        for (const QString &dep : deps) {
            // Check if we need C++ standard library
            if (dep == "libc++_shared.so"_L1) {
                needsStdCpp = true;
                continue;
            }
 
            // Skip system libraries
            if (isSystemLibrary(dep))
                continue;
 
            // Only process Qt libraries, platform plugins, and third-party libs from extra dirs
            if (!dep.startsWith("libQt6"_L1) && !dep.startsWith("libqohos"_L1)) {
                // Check extra library search directories (e.g. HARMONYOS_DEPS_ROOT/lib)
                QString extraDepPath = findExtraDepLibrary(options, dep);
                if (extraDepPath.isEmpty())
                    continue;
                // Guard against duplicates without blocking recursive ELF scanning:
                // do NOT insert into processedLibs here — the while-loop dequeue does
                // that, which also ensures the library's own ELF deps get scanned.
                if (!processedLibs.contains(extraDepPath) && !toProcess.contains(extraDepPath)) {
                    if (options.verbose)
                        fprintf(stdout, "    Found extra dep: %s\n", qPrintable(dep));
                    QtDependency extraDep;
                    extraDep.relativePath = "lib/"_L1 + dep;
                    extraDep.absolutePath = extraDepPath;
                    qtDependencies.append(extraDep);
                    toProcess.append(extraDepPath);
                }
                continue;
            }
 
            // Extract module name from Qt library (e.g., libQt6Core.so -> Core)
            if (dep.startsWith("libQt6"_L1)) {
                QString moduleName = dep.mid(6); // Skip "libQt6"
                if (moduleName.endsWith(".so"_L1))
                    moduleName.chop(3);
                if (!moduleName.isEmpty() && !detectedQtModules.contains(moduleName))
                    detectedQtModules.append(moduleName);
            }
 
            QString depPath = findQtLibrary(options, dep);
            if (depPath.isEmpty()) {
                if (options.verbose)
                    fprintf(stdout, "    Warning: Could not find Qt library: %s\n", qPrintable(dep));
                continue;
            }
 
            if (processedLibs.contains(depPath))
                continue;
 
            if (options.verbose)
                fprintf(stdout, "    Found dependency: %s\n", qPrintable(dep));
 
            QtDependency qtDep;
            qtDep.relativePath = "lib/"_L1 + dep;
            qtDep.absolutePath = depPath;
            qtDependencies.append(std::move(qtDep));
 
            // Add to processing queue for recursive dependency detection
            toProcess.append(std::move(depPath));
        }
    }
 
    if (options.verbose) {
        fprintf(stdout, "Found %lld Qt library dependencies\n", static_cast<long long>(qtDependencies.size()));
        if (needsStdCpp)
            fprintf(stdout, "C++ standard library required\n");
    }
 
    // Copy C++ standard library if needed (per-arch, since source path is arch-specific)
    if (needsStdCpp) {
        for (const QString &arch : options.targetArchs) {
            QString archLibPath = options.outputDirectory + "/entry/libs/"_L1 + arch;
            QString stdCppPath = findStdCppLibrary(options, arch);
            if (stdCppPath.isEmpty()) {
                fprintf(stderr, "Warning: Could not find C++ standard library for %s\n", qPrintable(arch));
            } else {
                QString destPath = archLibPath + "/libc++_shared.so"_L1;
                if (options.verbose)
                    fprintf(stdout, "  Copying C++ standard library for %s\n", qPrintable(arch));
                if (!copyFileIfNewer(stdCppPath, destPath, options.verbose)) {
                    fprintf(stderr,
                            "Failed to copy C++ standard library to: %s\n",
                            qPrintable(destPath));
                    return false;
                }
 
                // Track as dependency for depfile
                if (!options.depFilePath.isEmpty())
                    dependenciesForDepfile << stdCppPath;
            }
        }
    }
 
    // Copy all detected Qt/extra libraries to all target architectures.
    // copyFileToArchitectures handles all arches internally; call it once per library.
    // Use dep.relativePath filename so the deployed name matches the ELF SONAME
    // (e.g. libicudata.so.78, not the unversioned on-disk name libicudata.so).
    for (const QtDependency &dep : qtDependencies) {
        QFileInfo libInfo(dep.relativePath);
        if (!copyFileToArchitectures(options, dep.absolutePath, libInfo.fileName(), false))
            return false;
 
        if (!options.depFilePath.isEmpty())
            dependenciesForDepfile << dep.absolutePath;
    }
 
    return true;
}
 
static QString findQtPluginsDirectory(const Options &options)
{
    // 1. Use qtPluginsDirectory if provided (from JSON config)
    if (!options.qtPluginsDirectory.isEmpty() &&
        QDir(options.qtPluginsDirectory).exists()) {
        return options.qtPluginsDirectory;
    }
 
    // 2. Fallback: walk up from application binary
    QFileInfo appInfo(options.applicationBinary);
    QDir dir(appInfo.absolutePath());
    for (int i = 0; i < 10; ++i) {
        // Check qtbase/plugins for modular builds
        QString candidate = dir.absoluteFilePath("qtbase/plugins"_L1);
        if (QDir(candidate).exists())
            return candidate;
 
        // Check plugins directory
        if (dir.exists("plugins"_L1))
            return dir.absoluteFilePath("plugins"_L1);
 
        if (!dir.cdUp())
            break;
    }
 
    return QString();
}
 
static bool copyPlatformPlugin(const Options &options,
                               const QString &qtPluginsPath,
                               QSet<QString> &processedLibs)
{
    // Copy libqohos.so to ROOT libs directory (not in platforms subdirectory)
    QString qohosPlugin = qtPluginsPath + "/platforms/libqohos.so"_L1;
    if (!QFile::exists(qohosPlugin)) {
        fprintf(stderr, "Warning: Platform plugin libqohos.so not found at: %s\n",
               qPrintable(qohosPlugin));
        return true; // Not fatal
    }
 
    // Detect dependencies of libqohos.so
    if (options.verbose)
        fprintf(stdout, "  Detecting platform plugin dependencies\n");
 
    QStringList pluginDeps = readElfDependencies(options, qohosPlugin);
    QList<QtDependency> additionalLibs;
 
    for (const QString &dep : pluginDeps) {
        // Only process Qt libraries we haven't already copied
        if (!dep.startsWith("libQt6"_L1))
            continue;
 
        QString depPath = findQtLibrary(options, dep);
        if (depPath.isEmpty()) {
            if (options.verbose)
                fprintf(stdout, "    Warning: Could not find plugin dependency: %s\n",
                       qPrintable(dep));
            continue;
        }
 
        if (processedLibs.contains(depPath))
            continue;
 
        if (options.verbose)
            fprintf(stdout, "    Found plugin dependency: %s\n", qPrintable(dep));
 
        processedLibs.insert(depPath);
        QtDependency qtDep;
        qtDep.relativePath = "lib/"_L1 + dep;
        qtDep.absolutePath = std::move(depPath);
        additionalLibs.append(std::move(qtDep));
    }
 
    // Copy additional Qt libraries needed by the plugin
    for (const QString &arch : options.targetArchs) {
        QString archLibPath = options.outputDirectory + "/entry/libs/"_L1 + arch;
 
        for (const QtDependency &dep : additionalLibs) {
            QString destPath = archLibPath + "/"_L1 + QFileInfo(dep.absolutePath).fileName();
 
            if (options.verbose) {
                fprintf(stdout, "  Copying plugin dependency for %s: %s\n",
                       qPrintable(arch), qPrintable(QFileInfo(dep.absolutePath).fileName()));
            }
 
            if (!copyFileIfNewer(dep.absolutePath, destPath, options.verbose)) {
                fprintf(stderr, "Failed to copy library: %s\n", qPrintable(destPath));
                return false;
            }
 
            // Track as dependency for depfile
            if (!options.depFilePath.isEmpty())
                dependenciesForDepfile << dep.absolutePath;
        }
    }
 
    // Now copy libqohos.so itself to root
    for (const QString &arch : options.targetArchs) {
        QString archLibPath = options.outputDirectory + "/entry/libs/"_L1 + arch;
        QString destPath = archLibPath + "/libqohos.so"_L1;
 
        if (options.verbose)
            fprintf(stdout, "  Copying platform plugin for %s: libqohos.so (to root)\n",
                   qPrintable(arch));
 
        if (!copyFileIfNewer(qohosPlugin, destPath, options.verbose)) {
            fprintf(stderr, "Failed to copy libqohos.so to: %s\n", qPrintable(destPath));
            return false;
        }
 
        // Track as dependency for depfile
        if (!options.depFilePath.isEmpty())
            dependenciesForDepfile << qohosPlugin;
    }
 
    return true;
}
 
static bool copyPlugins(const Options &options, QSet<QString> &processedLibs)
{
    if (options.verbose)
        fprintf(stdout, "Copying required Qt plugins\n");
 
    // Find Qt plugins directory
    QString qtPluginsPath = findQtPluginsDirectory(options);
    if (qtPluginsPath.isEmpty()) {
        fprintf(stderr, "Warning: Could not find Qt plugins directory\n");
        return true; // Not fatal
    }
 
    if (options.verbose)
        fprintf(stdout, "  Qt plugins directory: %s\n", qPrintable(qtPluginsPath));
 
    // Copy platform plugin (special case: goes to root, not platforms/)
    if (!copyPlatformPlugin(options, qtPluginsPath, processedLibs))
        return false;
 
    // Discover and copy all other plugins based on dependencies
    QDir pluginsDir(qtPluginsPath);
    QStringList pluginCategories = pluginsDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
 
    if (options.verbose)
        fprintf(stdout, "Scanning plugin categories: %s\n",
               qPrintable(pluginCategories.join(", "_L1)));
 
    for (const QString &category : pluginCategories) {
        // Skip platforms category - libqohos.so already handled specially above
        if (category == "platforms"_L1)
            continue;
 
        QDir categoryDir(pluginsDir.filePath(category));
        QStringList plugins = categoryDir.entryList({"*.so"_L1}, QDir::Files);
 
        if (plugins.isEmpty())
            continue;
 
        if (options.verbose)
            fprintf(stdout, "\nChecking %s plugins (%lld found):\n",
                   qPrintable(category), static_cast<long long>(plugins.size()));
 
        for (const QString &plugin : plugins) {
            QString pluginPath = categoryDir.filePath(plugin);
 
            // Read plugin's ELF dependencies
            QStringList deps = readElfDependencies(options, pluginPath);
 
            // Check if all Qt dependencies are satisfied
            bool allDepsSatisfied = true;
            QStringList unsatisfiedDeps;
 
            for (const QString &dep : deps) {
                // Skip system libraries
                if (isSystemLibrary(dep))
                    continue;
 
                // Check if Qt6 dependency is being included
                if (dep.startsWith("libQt6"_L1)) {
                    QString depPath = findQtLibrary(options, dep);
                    if (depPath.isEmpty() || !processedLibs.contains(depPath)) {
                        allDepsSatisfied = false;
                        unsatisfiedDeps.append(dep);
                    }
                }
            }
 
            if (allDepsSatisfied) {
                // Copy this plugin to entry/libs/{arch}/{category}/
                if (options.verbose)
                    fprintf(stdout, "  [✓] %s (dependencies satisfied)\n", qPrintable(plugin));
 
                QString relativeDestPath = "%1/%2"_L1.arg(category, plugin);
                if (!copyFileToArchitectures(options, pluginPath, relativeDestPath))
                    return false;
            } else {
                if (options.verbose) {
                    fprintf(stdout, "  [✗] %s (missing: %s)\n",
                           qPrintable(plugin), qPrintable(unsatisfiedDeps.join(", "_L1)));
                }
            }
        }
    }
 
    if (options.verbose)
        fprintf(stdout, "Plugin copying completed\n");
 
    return true;
}
 
struct QmlImportInfo
{
    QString name;                  // Module name (e.g., "QtQuick")
    QString path;                  // Absolute path to module directory
    QString type;                  // "module" or "plugin"
    QString plugin;                // Plugin name (e.g., "qtquick2plugin")
    bool pluginIsOptional = false; // Whether plugin is optional
    QString prefer; // Preferred location (e.g., ":/" means embedded in resources)
    QStringList components; // List of QML component file paths
    QStringList scripts;    // List of JavaScript file paths
};
 
static QList<QmlImportInfo> scanQmlImports(const Options &options, bool *ok = nullptr)
{
    if (ok)
        *ok = true;
 
    QList<QmlImportInfo> imports;
 
    if (options.qmlRootPaths.isEmpty()) {
        if (options.verbose)
            fprintf(stdout,
                    "No QML root path specified, skipping QML import scanning\n");
        return imports;
    }
 
    if (options.verbose)
        fprintf(stdout, "Scanning for QML imports\n");
 
    // 1. Use qtLibExecsDirectory if provided (preferred, from JSON config)
    QStringList searchPaths;
    if (!options.qtLibExecsDirectory.isEmpty())
        searchPaths.append(options.qtLibExecsDirectory);
 
    // 2. Try qtHostDirectory/bin as fallback
    if (!options.qtHostDirectory.isEmpty())
        searchPaths.append(options.qtHostDirectory + "/bin"_L1);
 
    QString qmlImportScannerPath =
        QStandardPaths::findExecutable("qmlimportscanner"_L1, searchPaths);
 
    // 3. Fallback: search from application binary path
    if (qmlImportScannerPath.isEmpty()) {
        QDir dir(QFileInfo(options.applicationBinary).absolutePath());
 
        for (int i = 0; i < 10; ++i) {
            qmlImportScannerPath = QStandardPaths::findExecutable(
                "qmlimportscanner"_L1,
                {dir.absoluteFilePath("libexec"_L1), dir.absoluteFilePath("bin"_L1)});
 
            if (!qmlImportScannerPath.isEmpty())
                break;
 
            if (!dir.cdUp())
                break;
        }
    }
 
    if (qmlImportScannerPath.isEmpty()) {
        fprintf(
            stderr,
            "Warning: qmlimportscanner not found, skipping QML import scanning\n");
        return imports;
    }
 
    if (options.verbose)
        fprintf(stdout, "  Using qmlimportscanner: %s\n",
                qPrintable(qmlImportScannerPath));
 
    // Build import paths argument
    QStringList importPaths;
 
    // Add QML import paths from config
    for (const QString &path : options.qmlImportPaths)
        if (QFile::exists(path))
            importPaths.append(path);
 
    // Add application build directory for locally-built QML modules
    // This is needed to find modules like "shared" that are built alongside the
    // app
    QFileInfo appBinary(options.applicationBinary);
    QString appBuildDir = appBinary.absolutePath();
    if (QDir(appBuildDir).exists())
        importPaths.append(appBuildDir);
 
    // Add Qt QML directory (target platform)
    if (!options.qtQmlDirectory.isEmpty() &&
        QDir(options.qtQmlDirectory).exists()) {
        importPaths.append(options.qtQmlDirectory);
    } else {
        // Fallback: search from application binary path
        QFileInfo appBinary(options.applicationBinary);
        QDir qtDir(appBinary.absolutePath());
        for (int i = 0; i < 10; ++i) {
            QString qmlDir = qtDir.absoluteFilePath("qml"_L1);
            if (QDir(qmlDir).exists()) {
                importPaths.append(qmlDir);
                break;
            }
            // Also check qtbase/../qml for modular builds
            qmlDir = qtDir.absoluteFilePath("qtbase/../qml"_L1);
            if (QDir(qmlDir).exists()) {
                importPaths.append(QDir::cleanPath(qmlDir));
                break;
            }
            if (!qtDir.cdUp())
                break;
        }
    }
 
    if (importPaths.isEmpty()) {
        fprintf(stderr, "Warning: No QML import paths found\n");
        return imports;
    }
 
    // Build qmlimportscanner command. qmlimportscanner accepts a -rootPath flag
    // per root, so emit them in order.
    QStringList arguments;
    for (const QString &rootPath : options.qmlRootPaths)
        arguments << "-rootPath"_L1 << rootPath;
 
    for (const QString &importPath : importPaths)
        arguments << "-importPath"_L1 << importPath;
 
    if (options.verbose) {
        fprintf(stdout, "  Root paths:\n");
        for (const QString &rootPath : options.qmlRootPaths)
            fprintf(stdout, "    %s\n", qPrintable(rootPath));
        fprintf(stdout, "  Import paths:\n");
        for (const QString &path : importPaths)
            fprintf(stdout, "    %s\n", qPrintable(path));
    }
 
    // Run qmlimportscanner
    QProcess process;
    process.start(qmlImportScannerPath, arguments);
 
    if (!process.waitForFinished(30000)) {
        process.kill();
        process.waitForFinished(2000);
        fprintf(stderr, "Error: qmlimportscanner timed out after 30 seconds\n");
        fprintf(stderr, "  Command: %s %s\n", qPrintable(qmlImportScannerPath),
                qPrintable(arguments.join(u' ')));
        const QByteArray errorOutput = process.readAllStandardError();
        if (!errorOutput.isEmpty())
            fprintf(stderr, "%s\n", errorOutput.constData());
        if (ok)
            *ok = false;
        return imports;
    }
 
    if (process.exitStatus() != QProcess::NormalExit) {
        fprintf(stderr, "Error: qmlimportscanner crashed\n");
        fprintf(stderr, "%s\n", process.readAllStandardError().constData());
        if (ok)
            *ok = false;
        return imports;
    }
 
    if (process.exitCode() != 0) {
        fprintf(stderr, "Error: qmlimportscanner failed with exit code %d\n",
                process.exitCode());
        fprintf(stderr, "%s\n", process.readAllStandardError().constData());
        if (ok)
            *ok = false;
        return imports;
    }
 
    // Parse JSON output
    QByteArray output = process.readAllStandardOutput();
    QJsonDocument doc = QJsonDocument::fromJson(output);
 
    if (!doc.isArray()) {
        fprintf(stderr, "Error: Invalid JSON output from qmlimportscanner\n");
        if (ok)
            *ok = false;
        return imports;
    }
 
    QJsonArray array = doc.array();
    for (const QJsonValue &value : array) {
        if (!value.isObject())
            continue;
 
        QJsonObject obj = value.toObject();
        QmlImportInfo info;
        info.name = obj["name"_L1].toString();
        info.path = obj["path"_L1].toString();
        info.type = obj["type"_L1].toString();
 
        if (obj.contains("plugin"_L1))
            info.plugin = obj["plugin"_L1].toString();
 
        if (obj.contains("pluginIsOptional"_L1))
            info.pluginIsOptional = obj["pluginIsOptional"_L1].toBool();
 
        if (obj.contains("prefer"_L1))
            info.prefer = obj["prefer"_L1].toString();
 
        // Parse components array
        if (obj.contains("components"_L1)) {
            QJsonArray componentsArray = obj["components"_L1].toArray();
            for (const QJsonValue &comp : componentsArray)
                info.components.append(comp.toString());
        }
 
        // Parse scripts array
        if (obj.contains("scripts"_L1)) {
            QJsonArray scriptsArray = obj["scripts"_L1].toArray();
            for (const QJsonValue &script : scriptsArray)
                info.scripts.append(script.toString());
        }
 
        // Skip if path is empty (unresolved import)
        if (info.path.isEmpty()) {
            if (options.verbose)
                fprintf(stdout, "  Warning: Could not resolve QML import: %s\n",
                        qPrintable(info.name));
            continue;
        }
 
        // Skip if type is not module
        if (info.type != "module"_L1)
            continue;
 
        if (options.verbose)
            fprintf(stdout, "  Found QML import: %s at %s\n", qPrintable(info.name),
                    qPrintable(info.path));
 
        imports.append(info);
    }
 
    return imports;
}
 
static bool copyQmlFiles(const Options &options)
{
    if (options.qmlRootPaths.isEmpty())
        return true; // Not an error, just no QML files to copy
 
    // Target directory: entry/src/main/resources/rawfile/qml/.
    //
    // Multiple roots are merged into the same destination. copyFileIfNewer
    // only overwrites when the source mtime is newer than the destination,
    // so in practice the *first* root to land a given file wins. User-set
    // QT_QML_ROOT_PATH values are emitted before auto-collected roots (see
    // _qt_internal_harmonyos_format_deployment_paths in Qt6HarmonyOSMacros.cmake),
    // giving explicit user settings precedence over auto-collected ones on
    // collision.
    const QString destDir =
        options.outputDirectory + "/entry/src/main/resources/rawfile/qml"_L1;
    if (!QDir().mkpath(destDir)) {
        fprintf(stderr, "Failed to create QML destination directory: %s\n",
                qPrintable(destDir));
        return false;
    }
 
    for (const QString &rootPath : options.qmlRootPaths) {
        if (options.verbose)
            fprintf(stdout, "Copying QML files from %s\n", qPrintable(rootPath));
 
        if (!copyRecursively(rootPath, destDir, options.verbose)) {
            fprintf(stderr, "Failed to copy QML files from %s\n", qPrintable(rootPath));
            return false;
        }
    }
 
    if (options.verbose)
        fprintf(stdout, "QML files copied successfully\n");
 
    return true;
}
 
static bool copyQmlImports(const Options &options,
                           const QList<QmlImportInfo> &imports,
                           QSet<QString> &processedLibs)
{
    if (imports.isEmpty())
        return true;
 
    if (options.verbose)
        fprintf(stdout, "Copying QML imports\n");
 
    // QML non-.so files go to resfile/qml/ (maintaining directory structure)
    // QML plugin .so files go to libs/arm64-v8a/ (flat, no subdirectory)
    QString qmlDestBase = hapQmlDir(options);
    QDir().mkpath(qmlDestBase);
 
    // Track QML plugins to scan for dependencies
    QStringList qmlPluginsToScan;
 
    for (const QmlImportInfo &import : imports) {
        if (options.verbose)
            fprintf(stdout, "  Copying QML module: %s\n", qPrintable(import.name));
 
        // Determine module subdirectory - preserve full path structure
        // e.g., QtQuick.Window should go to QtQuick/Window/, not just Window/
        QString relativePath;
 
        // Calculate relative path from Qt QML directory
        if (!options.qtQmlDirectory.isEmpty() && import.path.startsWith(options.qtQmlDirectory)) {
            // Qt module - use relative path from Qt QML dir
            relativePath = import.path.mid(options.qtQmlDirectory.length());
            if (relativePath.startsWith('/'_L1))
                relativePath = relativePath.mid(1);
        } else {
            // Application module or other - use module name converted to path
            // e.g., "QtQuick.Window" -> "QtQuick/Window"
            relativePath = import.name;
            relativePath.replace('.'_L1, '/'_L1);
        }
 
        QString destModuleDir = qmlDestBase + "/"_L1 + relativePath;
        QDir().mkpath(destModuleDir);
 
        // Copy qmldir file (required for module discovery)
        QString qmldirSrc = import.path + "/qmldir"_L1;
        QString qmldirDest = destModuleDir + "/qmldir"_L1;
        if (QFile::exists(qmldirSrc)) {
            if (copyFileIfNewer(qmldirSrc, qmldirDest, options.verbose)) {
                if (options.verbose)
                    fprintf(stdout, "    Copied qmldir\n");
 
                // Track as dependency for depfile
                if (!options.depFilePath.isEmpty())
                    dependenciesForDepfile << qmldirSrc;
            } else {
                fprintf(stderr, "Warning: Failed to copy qmldir for %s\n",
                        qPrintable(import.name));
            }
        }
 
        // Copy plugin library if not embedded in resources
        // Check "prefer" field - if it starts with ":/" then QML files are in
        // resources
        bool qmlFilesAreEmbedded = import.prefer.startsWith(":/"_L1);
 
        if (!import.plugin.isEmpty()) {
            // QML plugin .so files go to libs/arm64-v8a/ (flat, per HarmonyOS requirements)
            QString pluginFileName = "lib"_L1 + import.plugin + ".so"_L1;
            QString pluginSrc = import.path + "/"_L1 + pluginFileName;
 
            if (QFile::exists(pluginSrc)) {
                // Copy to libs directory for each architecture
                for (const QString &arch : options.targetArchs) {
                    QString pluginDest = options.outputDirectory + "/entry/libs/"_L1 + arch
                                        + "/"_L1 + pluginFileName;
 
                    if (copyFileIfNewer(pluginSrc, pluginDest, options.verbose)) {
                        if (options.verbose)
                            fprintf(stdout, "    Copied plugin to libs/%s: %s\n",
                                    qPrintable(arch), qPrintable(pluginFileName));
                        processedLibs.insert(pluginSrc);
 
                        // Add plugin to list for dependency scanning
                        if (!qmlPluginsToScan.contains(pluginSrc))
                            qmlPluginsToScan.append(pluginSrc);
 
                        // Track as dependency for depfile
                        if (!options.depFilePath.isEmpty())
                            dependenciesForDepfile << pluginSrc;
                    } else if (!import.pluginIsOptional) {
                        fprintf(stderr, "Warning: Failed to copy required plugin: %s\n",
                                qPrintable(pluginFileName));
                    }
                }
            } else if (!import.pluginIsOptional) {
                if (options.verbose)
                    fprintf(stdout, "    Warning: Required plugin not found: %s\n",
                            qPrintable(pluginFileName));
            }
        }
 
        // Copy QML component files (only if not embedded in resources)
        if (!qmlFilesAreEmbedded) {
            for (const QString &component : import.components) {
                QFileInfo compInfo(component);
                if (!compInfo.exists()) {
                    if (options.verbose)
                        fprintf(stdout, "    Warning: Component file not found: %s\n",
                                qPrintable(component));
                    continue;
                }
 
                QString relativePath = component.mid(import.path.length());
                if (relativePath.startsWith('/'_L1))
                    relativePath = relativePath.mid(1);
 
                QString destFile = destModuleDir + "/"_L1 + relativePath;
                QFileInfo destInfo(destFile);
                QDir().mkpath(destInfo.absolutePath());
 
                if (copyFileIfNewer(component, destFile, options.verbose)) {
                    if (options.verbose)
                        fprintf(stdout, "    Copied component: %s\n", qPrintable(compInfo.fileName()));
 
                    // Track as dependency for depfile
                    if (!options.depFilePath.isEmpty())
                        dependenciesForDepfile << component;
                }
            }
 
            // Copy JavaScript files
            for (const QString &script : import.scripts) {
                QFileInfo scriptInfo(script);
                if (!scriptInfo.exists())
                    continue;
 
                QString relativePath = script.mid(import.path.length());
                if (relativePath.startsWith('/'_L1))
                    relativePath = relativePath.mid(1);
 
                QString destFile = destModuleDir + "/"_L1 + relativePath;
                QFileInfo destInfo(destFile);
                QDir().mkpath(destInfo.absolutePath());
 
                if (copyFileIfNewer(script, destFile, options.verbose)) {
                    if (options.verbose)
                        fprintf(stdout, "    Copied script: %s\n", qPrintable(scriptInfo.fileName()));
 
                    // Track as dependency for depfile
                    if (!options.depFilePath.isEmpty())
                        dependenciesForDepfile << script;
                }
            }
        } else {
            if (options.verbose)
                fprintf(stdout, "    Skipping QML files (embedded in resources)\n");
        }
    }
 
    // Scan QML plugin dependencies and copy any missing Qt libraries
    if (!qmlPluginsToScan.isEmpty()) {
        if (options.verbose)
            fprintf(stdout, "Scanning QML plugin dependencies\n");
 
        QStringList toProcess = qmlPluginsToScan;
        while (!toProcess.isEmpty()) {
            QString pluginPath = toProcess.takeFirst();
 
            if (options.verbose)
                fprintf(stdout, "  Scanning plugin: %s\n", qPrintable(QFileInfo(pluginPath).fileName()));
 
            QStringList deps = readElfDependencies(options, pluginPath);
            for (const QString &dep : deps) {
                // Skip system libraries
                if (isSystemLibrary(dep))
                    continue;
 
                // Resolve the library path from Qt libs or extra-libs-dirs
                QString depPath;
                if (dep.startsWith("libQt6"_L1)) {
                    depPath = findQtLibrary(options, dep);
                    if (depPath.isEmpty()) {
                        if (options.verbose)
                            fprintf(stdout, "    Warning: Could not find Qt library: %s\n", qPrintable(dep));
                        continue;
                    }
                } else if (!options.extraLibsDirs.isEmpty()) {
                    depPath = findExtraDepLibrary(options, dep);
                    if (depPath.isEmpty())
                        continue;
                } else {
                    continue;
                }
 
                if (processedLibs.contains(depPath))
                    continue;
 
                if (options.verbose)
                    fprintf(stdout, "    Found dependency: %s\n", qPrintable(dep));
 
                // Copy the library
                for (const QString &arch : options.targetArchs) {
                    QString destPath = options.outputDirectory + "/entry/libs/"_L1 + arch + "/"_L1 + dep;
                    if (copyFileIfNewer(depPath, destPath, options.verbose)) {
                        if (options.verbose)
                            fprintf(stdout, "    Copied %s to libs/%s\n", qPrintable(dep), qPrintable(arch));
 
                        // Track as dependency for depfile
                        if (!options.depFilePath.isEmpty())
                            dependenciesForDepfile << depPath;
                    }
                }
 
                processedLibs.insert(depPath);
                // Recursively scan this dependency
                toProcess.append(depPath);
            }
        }
    }
 
    if (options.verbose)
        fprintf(stdout, "QML imports copied successfully\n");
 
    return true;
}
 
// Signing material resolved from the --signing-* flags and the matching
// QT_HARMONYOS_SIGNING_* environment variables.
struct SigningConfig
{
    bool enabled = false;
    // hvigor-encrypted passwords are left to hvigor's sign task, the only one that
    // can decrypt them.
    bool encryptedPasswords = false;
    QString certPath;
    QString profile;
    QString storeFile;
    QString keyAlias;
    QString keyPassword;
    QString storePassword;
    QString signAlg;
};
 
// Signing is all-or-nothing: setting any input commits to signing, so a missing
// one is an error rather than a silently unsigned HAP.
static bool resolveSigningConfig(const Options &options, SigningConfig *signing)
{
    struct Field
    {
        const char *envName;
        const char *cliFlag;
        QString cliValue;
        QString envValue;
 
        QString resolved() const
        {
            if (!cliValue.isEmpty())
                return cliValue;
            return envValue;
        }
        QString label() const
        {
            return QString::fromLatin1(cliFlag) + " / "_L1 + QString::fromLatin1(envName);
        }
    };
 
    Field required[] = {
        { "QT_HARMONYOS_SIGNING_CERT_PATH", "--signing-cert-path", options.signingCertPath,
          qEnvironmentVariable("QT_HARMONYOS_SIGNING_CERT_PATH") },
        { "QT_HARMONYOS_SIGNING_PROFILE", "--signing-profile", options.signingProfile,
          qEnvironmentVariable("QT_HARMONYOS_SIGNING_PROFILE") },
        { "QT_HARMONYOS_SIGNING_STORE_FILE", "--signing-store-file", options.signingStoreFile,
          qEnvironmentVariable("QT_HARMONYOS_SIGNING_STORE_FILE") },
        { "QT_HARMONYOS_SIGNING_KEY_ALIAS", "--signing-key-alias", options.signingKeyAlias,
          qEnvironmentVariable("QT_HARMONYOS_SIGNING_KEY_ALIAS") },
    };
 
    // Each password is required in exactly one of its two forms: encrypted, plain.
    Field passwords[][2] = {
        { { "QT_HARMONYOS_SIGNING_KEY_PASSWORD", "--signing-key-password",
            options.signingKeyPassword, qEnvironmentVariable("QT_HARMONYOS_SIGNING_KEY_PASSWORD") },
          { "QT_HARMONYOS_SIGNING_PLAIN_KEY_PASSWORD", "--signing-plain-key-password",
            options.signingPlainKeyPassword,
            qEnvironmentVariable("QT_HARMONYOS_SIGNING_PLAIN_KEY_PASSWORD") } },
        { { "QT_HARMONYOS_SIGNING_STORE_PASSWORD", "--signing-store-password",
            options.signingStorePassword,
            qEnvironmentVariable("QT_HARMONYOS_SIGNING_STORE_PASSWORD") },
          { "QT_HARMONYOS_SIGNING_PLAIN_STORE_PASSWORD", "--signing-plain-store-password",
            options.signingPlainStorePassword,
            qEnvironmentVariable("QT_HARMONYOS_SIGNING_PLAIN_STORE_PASSWORD") } },
    };
 
    QString signAlg = options.signingAlg.isEmpty()
            ? qEnvironmentVariable("QT_HARMONYOS_SIGNING_ALG")
            : options.signingAlg;
 
    bool anySet = !signAlg.isEmpty();
    for (const Field &f : required)
        anySet = anySet || !f.resolved().isEmpty();
    for (const auto &forms : passwords)
        anySet = anySet || !forms[0].resolved().isEmpty() || !forms[1].resolved().isEmpty();
    if (!anySet)
        return true;
 
    QStringList missing;
    for (const Field &f : required) {
        if (f.resolved().isEmpty())
            missing << f.label();
    }
    for (const auto &forms : passwords) {
        if (forms[0].resolved().isEmpty() && forms[1].resolved().isEmpty())
            missing << forms[0].label() + " or "_L1 + forms[1].label();
    }
    if (!missing.isEmpty()) {
        fprintf(stderr, "Error: HAP signing requested, but the following required input(s)\n"
                        "       are missing (neither CLI flag nor env var was supplied):\n");
        for (const QString &name : missing)
            fprintf(stderr, "         %s\n", qPrintable(name));
        return false;
    }
 
    for (const auto &forms : passwords) {
        if (!forms[0].resolved().isEmpty() && !forms[1].resolved().isEmpty()) {
            fprintf(stderr, "Error: both %s and %s are set; pass only one of them\n",
                    qPrintable(forms[0].label()), qPrintable(forms[1].label()));
            return false;
        }
    }
 
    const bool encryptedKeyPassword = !passwords[0][0].resolved().isEmpty();
    const bool encryptedStorePassword = !passwords[1][0].resolved().isEmpty();
    if (encryptedKeyPassword != encryptedStorePassword) {
        fprintf(stderr,
                "Error: the key password and the keystore password must both be\n"
                "       hvigor-encrypted or both plain text.\n");
        return false;
    }
 
    signing->enabled = true;
    signing->encryptedPasswords = encryptedKeyPassword;
    signing->certPath = required[0].resolved();
    signing->profile = required[1].resolved();
    signing->storeFile = required[2].resolved();
    signing->keyAlias = required[3].resolved();
    signing->keyPassword = passwords[0][encryptedKeyPassword ? 0 : 1].resolved();
    signing->storePassword = passwords[1][encryptedStorePassword ? 0 : 1].resolved();
    signing->signAlg = signAlg.isEmpty() ? "SHA256withECDSA"_L1 : signAlg;
 
    const std::pair<const char *, QString> files[] = {
        { required[0].cliFlag, signing->certPath },
        { required[1].cliFlag, signing->profile },
        { required[2].cliFlag, signing->storeFile },
    };
    for (const auto &file : files) {
        if (!QFile::exists(file.second)) {
            fprintf(stderr, "Error: signing input %s does not exist: %s\n", file.first,
                    qPrintable(file.second));
            return false;
        }
    }
 
    if (options.verbose) {
        fprintf(stdout, "HAP signing enabled\n");
        fprintf(stdout, "  certpath:  %s\n", qPrintable(signing->certPath));
        fprintf(stdout, "  profile:   %s\n", qPrintable(signing->profile));
        fprintf(stdout, "  storeFile: %s\n", qPrintable(signing->storeFile));
        fprintf(stdout, "  keyAlias:  %s\n", qPrintable(signing->keyAlias));
        fprintf(stdout, "  signAlg:   %s\n", qPrintable(signing->signAlg));
        fprintf(stdout, "  passwords: %s\n",
                signing->encryptedPasswords ? "hvigor-encrypted" : "plain text");
    }
    return true;
}
 
// build-profile.json5 ships with `"signingConfigs": []`; replace that literal
// with a populated block, so that hvigor signs the HAP with encrypted passwords.
// JSON5 input (trailing commas, // comments) precludes QJsonDocument, hence
// string surgery.
static bool injectSigningConfig(const Options &options, const SigningConfig &signing)
{
    if (!signing.enabled || !signing.encryptedPasswords)
        return true;
 
    const QString buildProfilePath = options.outputDirectory + "/build-profile.json5"_L1;
    QFile profileFile(buildProfilePath);
    if (!profileFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
        fprintf(stderr, "Error: cannot open %s for reading: %s\n",
                qPrintable(buildProfilePath), qPrintable(profileFile.errorString()));
        return false;
    }
    QByteArray content = profileFile.readAll();
    profileFile.close();
 
    // Anything other than the literal empty array means the user already edited
    // the file; refuse rather than risk corrupting it.
    static const QByteArray needle = "\"signingConfigs\": []";
    const int idx = content.indexOf(needle);
    if (idx < 0) {
        fprintf(stderr, "Error: '%s' not found in %s. The template may have been modified;\n"
                        "       cannot inject signing configuration safely.\n",
                needle.constData(), qPrintable(buildProfilePath));
        return false;
    }
 
    // Only backslash and double-quote need escaping; inputs are paths, aliases,
    // and hex blobs — no control characters.
    auto escapeJsonString = [](const QByteArray &in) {
        QByteArray out;
        out.reserve(in.size());
        for (char c : in) {
            if (c == '\\' || c == '"')
                out.append('\\');
            out.append(c);
        }
        return out;
    };
 
    QByteArray replacement;
    replacement.append("\"signingConfigs\": [\n");
    replacement.append("      {\n");
    replacement.append("        \"name\": \"default\",\n");
    replacement.append("        \"type\": \"HarmonyOS\",\n");
    replacement.append("        \"material\": {\n");
    auto appendField = [&](const char *key, const QString &value, bool last) {
        replacement.append("          \"");
        replacement.append(key);
        replacement.append("\": \"");
        replacement.append(escapeJsonString(value.toUtf8()));
        replacement.append('"');
        if (!last)
            replacement.append(',');
        replacement.append('\n');
    };
    appendField("certpath",      signing.certPath,      false);
    appendField("keyAlias",      signing.keyAlias,      false);
    appendField("keyPassword",   signing.keyPassword,   false);
    appendField("profile",       signing.profile,       false);
    appendField("signAlg",       signing.signAlg,       false);
    appendField("storeFile",     signing.storeFile,     false);
    appendField("storePassword", signing.storePassword, true);
    replacement.append("        }\n");
    replacement.append("      }\n");
    replacement.append("    ]");
 
    content.replace(idx, needle.size(), replacement);
 
    if (!profileFile.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)) {
        fprintf(stderr, "Error: cannot open %s for writing: %s\n",
                qPrintable(buildProfilePath), qPrintable(profileFile.errorString()));
        return false;
    }
    if (profileFile.write(content) != content.size()) {
        fprintf(stderr, "Error: failed to write full content to %s\n",
                qPrintable(buildProfilePath));
        profileFile.close();
        return false;
    }
    profileFile.close();
 
    if (options.verbose)
        fprintf(stdout, "Injected HAP signingConfig into %s\n", qPrintable(buildProfilePath));
    return true;
}
 
static QString findJavaExecutable()
{
    const QString envJava = qEnvironmentVariable("QT_HARMONYOS_JAVA");
    if (!envJava.isEmpty())
        return envJava;
 
    const QString javaHome = qEnvironmentVariable("JAVA_HOME");
    if (!javaHome.isEmpty()) {
        const QString fromHome =
                QStandardPaths::findExecutable("java"_L1, { javaHome + "/bin"_L1 });
        if (!fromHome.isEmpty())
            return fromHome;
    }
 
    return QStandardPaths::findExecutable("java"_L1);
}
 
static QString findHapSignTool(const Options &options)
{
    const QString envTool = qEnvironmentVariable("QT_HARMONYOS_HAP_SIGN_TOOL");
    if (!envTool.isEmpty())
        return envTool;
 
    if (options.sdkRoot.isEmpty())
        return QString();
 
    // OHOS_SDK_ROOT normally points at the openharmony directory; accept the
    // enclosing directories too, matching the other SDK lookups in this tool.
    const QStringList candidates = {
        options.sdkRoot + "/toolchains/lib/hap-sign-tool.jar"_L1,
        options.sdkRoot + "/openharmony/toolchains/lib/hap-sign-tool.jar"_L1,
        options.sdkRoot
                + "/command-line-tools/sdk/default/openharmony/toolchains/lib/hap-sign-tool.jar"_L1,
    };
    for (const QString &candidate : candidates) {
        if (QFile::exists(candidate))
            return candidate;
    }
    return QString();
}
 
// hap-sign-tool falls back to API level 9 when -compatibleVersion is omitted,
// which understates what the manifest declares. Recover the real level from the
// generated build-profile.json5, where it is written as "6.1.0(23)".
static QString compatibleApiVersion(const Options &options)
{
    QFile profileFile(options.outputDirectory + "/build-profile.json5"_L1);
    if (!profileFile.open(QIODevice::ReadOnly | QIODevice::Text))
        return QString();
    const QString content = QString::fromUtf8(profileFile.readAll());
 
    static const QRegularExpression keyRe("\"compatibleSdkVersion\"\\s*:\\s*([^,\\n}]+)"_L1);
    const QRegularExpressionMatch keyMatch = keyRe.match(content);
    if (!keyMatch.hasMatch())
        return QString();
 
    QString value = keyMatch.captured(1).trimmed();
    static const QRegularExpression apiRe("\\‍((\\d+)\\‍)"_L1);
    const QRegularExpressionMatch apiMatch = apiRe.match(value);
    if (apiMatch.hasMatch())
        return apiMatch.captured(1);
 
    value.remove(u'"');
    value = value.trimmed();
    bool ok = false;
    value.toInt(&ok);
    return ok ? value : QString();
}
 
// Sign the HAP that hvigor produced, using the SDK's hap-sign-tool. With
// encrypted passwords hvigor has signed it already, and only its path changes.
//
// hvigor's own sign task runs both passwords through a decryptor keyed on the
// contents of DevEco Studio's material directory, so it rejects plain passwords.
// hap-sign-tool takes the passwords as given, which is the form material from
// AGC, a CI secret store or Qt Creator's keychain comes in. See QTBUG-149206.
static bool signHap(const Options &options, const SigningConfig &signing, QString *hapPath)
{
    if (!signing.enabled)
        return true;
    if (hapPath->isEmpty()) {
        fprintf(stderr, "Warning: HAP signing is configured, but no HAP was built to sign\n");
        return true;
    }
 
    const QFileInfo unsignedInfo(*hapPath);
    QString baseName = unsignedInfo.completeBaseName();
    if (baseName.endsWith("-unsigned"_L1))
        baseName.chop(9);
    const QString signedPath = unsignedInfo.absolutePath() + "/"_L1 + baseName + "-signed.hap"_L1;
 
    if (signing.encryptedPasswords) {
        if (!QFile::exists(signedPath)) {
            fprintf(stderr, "Error: hvigor did not produce the signed HAP %s\n",
                    qPrintable(signedPath));
            return false;
        }
        *hapPath = signedPath;
        return true;
    }
 
    const QString signTool = findHapSignTool(options);
    if (signTool.isEmpty()) {
        fprintf(stderr,
                "Error: hap-sign-tool.jar not found. Set QT_HARMONYOS_HAP_SIGN_TOOL\n"
                "       to its path, or configure with OHOS_SDK_ROOT set to the SDK\n"
                "       that contains it.\n");
        return false;
    }
 
    const QString javaExecutable = findJavaExecutable();
    if (javaExecutable.isEmpty()) {
        fprintf(stderr,
                "Error: no java executable found for running hap-sign-tool.\n"
                "       Set QT_HARMONYOS_JAVA or JAVA_HOME, or add java to PATH.\n");
        return false;
    }
 
    // hap-sign-tool refuses to overwrite, and a leftover from an earlier build
    // would otherwise be mistaken for this build's output.
    if (QFile::exists(signedPath) && !QFile::remove(signedPath)) {
        fprintf(stderr, "Error: cannot remove stale %s\n", qPrintable(signedPath));
        return false;
    }
 
    QStringList arguments;
    arguments << "-jar"_L1 << signTool << "sign-app"_L1
              << "-mode"_L1 << "localSign"_L1
              << "-signAlg"_L1 << signing.signAlg << "-signCode"_L1 << "1"_L1
              << "-keyAlias"_L1 << signing.keyAlias << "-keystoreFile"_L1 << signing.storeFile
              << "-appCertFile"_L1 << signing.certPath << "-profileFile"_L1 << signing.profile
              << "-inFile"_L1 << *hapPath << "-outFile"_L1 << signedPath;
 
    const QString apiVersion = compatibleApiVersion(options);
    if (apiVersion.isEmpty()) {
        fprintf(stderr,
                "Warning: cannot determine compatibleSdkVersion from build-profile.json5;"
                " hap-sign-tool uses its default\n");
    } else {
        arguments << "-compatibleVersion"_L1 << apiVersion;
    }
 
    if (options.verbose) {
        fprintf(stdout, "Signing HAP with %s\n", qPrintable(signTool));
        fprintf(stdout, "  Running: %s %s -keyPwd <hidden> -keystorePwd <hidden>\n",
                qPrintable(javaExecutable), qPrintable(arguments.join(u' ')));
    }
 
    // hap-sign-tool only reads the passwords from argv (-pwdInputMode 1 prompts
    // on a console, which a build step does not have), so they are visible in a
    // process listing for the duration of the call.
    arguments << "-keyPwd"_L1 << signing.keyPassword << "-keystorePwd"_L1 << signing.storePassword;
 
    QProcessExt process;
    process.setProcessChannelMode(QProcess::MergedChannels);
    process.start(javaExecutable, arguments);
    if (!process.waitForStarted()) {
        fprintf(stderr, "Error: failed to start %s\n", qPrintable(javaExecutable));
        return false;
    }
    // The test bundle holds every Qt library, so code signing can take long.
    if (!process.waitForFinished(-1)) {
        fprintf(stderr, "Error: hap-sign-tool did not finish\n");
        process.kill();
        return false;
    }
    if (process.exitStatus() != QProcess::NormalExit || process.exitCode() != 0) {
        QFile::remove(signedPath);
        fprintf(stderr, "Error: hap-sign-tool failed with exit code %d\n", process.exitCode());
        return false;
    }
    if (!QFile::exists(signedPath)) {
        fprintf(stderr, "Error: hap-sign-tool reported success but %s was not created\n",
                qPrintable(signedPath));
        return false;
    }
 
    if (options.verbose)
        fprintf(stdout, "  Signed HAP: %s\n", qPrintable(signedPath));
 
    *hapPath = signedPath;
    return true;
}
 
static bool buildHap(const Options &options, QString *hapOutputPath = nullptr)
{
    if (!options.buildPackage) {
        if (options.verbose)
            fprintf(stdout, "Skipping HAP build (--no-build specified)\n");
        return true;
    }
 
    // Resolve hvigorw path: CLI option → env var → auto-detect in output directory
    QString hvigorPath = options.hvigorPath;
 
    if (hvigorPath.isEmpty()) {
        QByteArray envHvigor = qgetenv("QT_HARMONYOS_HVIGOR");
        if (!envHvigor.isEmpty())
            hvigorPath = QString::fromLocal8Bit(envHvigor);
    }
 
    if (hvigorPath.isEmpty()) {
        // Auto-detect hvigorw in the output directory (always present in the template)
        QString candidate = options.outputDirectory + "/hvigorw"_L1;
        if (QFile::exists(candidate))
            hvigorPath = std::move(candidate);
    }
 
    if (hvigorPath.isEmpty()) {
        fprintf(stderr, "Warning: No hvigor path specified, skipping build\n");
        fprintf(stderr, "Use --hvigor <path> or set QT_HARMONYOS_HVIGOR\n");
        return true; // Not fatal
    }
 
    if (options.verbose)
        fprintf(stdout, "Building HarmonyOS HAP package\n");
 
    // Check if hvigorw exists
    if (!QFile::exists(hvigorPath)) {
        fprintf(stderr, "Error: hvigorw not found at: %s\n", qPrintable(hvigorPath));
        return false;
    }
 
    // Determine build task and build mode. hvigor's assembleHap builds in debug
    // mode unless the mode is passed explicitly.
    QString buildTask = "assembleHap"_L1;
    QString buildMode = options.releaseMode ? "release"_L1 : "debug"_L1;
 
    if (options.verbose) {
        fprintf(stdout, "  Build mode: %s\n", qPrintable(buildMode));
        fprintf(stdout, "  Running: %s %s\n", qPrintable(hvigorPath), qPrintable(buildTask));
    }
 
    // Execute hvigorw
    QProcessExt process;
    process.setWorkingDirectory(options.outputDirectory);
    process.setProcessChannelMode(QProcess::MergedChannels);
 
    QStringList arguments;
    arguments << buildTask << "-p"_L1 << ("buildMode="_L1 + buildMode);
    // The hvigor daemon outlives the build and, on Windows, inherits our output
    // pipe; QProcess then never sees EOF and this call hangs. Build daemon-less.
    arguments << "--no-daemon"_L1;
 
    process.start(hvigorPath, arguments);
 
    if (!process.waitForStarted()) {
        fprintf(stderr, "Failed to start hvigorw\n");
        return false;
    }
 
    // Show output in real-time if verbose
    while (process.state() != QProcess::NotRunning) {
        if (!process.waitForReadyRead(1000)) {
            // Timeout is OK, just check if process is still running
            if (process.state() == QProcess::NotRunning)
                break;
            continue;
        }
 
        if (options.verbose) {
            QByteArray output = process.readAll();
            fprintf(stdout, "%s", output.constData());
            fflush(stdout);
        }
    }
 
    // Read any remaining output
    if (options.verbose) {
        QByteArray output = process.readAll();
        if (!output.isEmpty()) {
            fprintf(stdout, "%s", output.constData());
            fflush(stdout);
        }
    }
 
    if (process.exitCode() != 0) {
        fprintf(stderr, "hvigorw failed with exit code %d\n", process.exitCode());
        if (!options.verbose)
            fprintf(stderr, "Run with --verbose to see build output\n");
        return false;
    }
 
    if (options.verbose)
        fprintf(stdout, "HAP build completed successfully\n");
 
    // Try to locate the generated HAP file
    if (hapOutputPath) {
        QString hapSearchPath = options.outputDirectory + "/entry/build/default/outputs/default"_L1;
        QDir hapDir(hapSearchPath);
 
        if (hapDir.exists()) {
            QStringList hapFiles = hapDir.entryList(QStringList() << "*.hap"_L1, QDir::Files);
            // A signed HAP from an earlier build sorts before the unsigned one
            // hvigor just wrote, so pick the unsigned artifact explicitly.
            for (qsizetype i = 0; i < hapFiles.size(); ++i) {
                if (hapFiles.at(i).endsWith("-unsigned.hap"_L1)) {
                    hapFiles.move(i, 0);
                    break;
                }
            }
            if (!hapFiles.isEmpty()) {
                *hapOutputPath = hapDir.absoluteFilePath(hapFiles.first());
                if (options.verbose)
                    fprintf(stdout, "  Generated HAP: %s\n", qPrintable(*hapOutputPath));
            }
        }
    }
 
    return true;
}
 
static bool installToDevice(const Options &options, const QString &hapPath)
{
    if (!options.installApk)
        return true; // Not requested
 
    if (hapPath.isEmpty()) {
        fprintf(stderr, "Error: Cannot install - HAP file path not found\n");
        return false;
    }
 
    if (options.verbose)
        fprintf(stdout, "Installing HAP to device\n");
 
    // Check if hdc is available
    QString hdcPath = "hdc"_L1; // Assume it's in PATH
 
    // Try to find hdc in SDK
    if (!options.sdkRoot.isEmpty()) {
        QString sdkHdc = options.sdkRoot + "/command-line-tools/hdc"_L1;
        if (QFile::exists(sdkHdc))
            hdcPath = std::move(sdkHdc);
    }
 
    // Check for connected devices
    QProcessExt checkDevices;
    checkDevices.start(hdcPath, QStringList() << "list"_L1 << "targets"_L1);
    if (!checkDevices.waitForFinished(5000)) {
        fprintf(stderr, "Error: Failed to check for connected devices\n");
        return false;
    }
 
    QString devicesOutput = QString::fromUtf8(checkDevices.readAllStandardOutput());
    if (devicesOutput.trimmed().isEmpty() || devicesOutput.contains("empty"_L1)) {
        fprintf(stderr, "Error: No HarmonyOS devices connected\n");
        fprintf(stderr, "Connect a device and ensure USB debugging is enabled\n");
        return false;
    }
 
    if (options.verbose)
        fprintf(stdout, "  Connected devices:\n%s\n", qPrintable(devicesOutput));
 
    // Uninstall old version if exists
    if (options.verbose)
        fprintf(stdout, "  Uninstalling old version (if exists)\n");
 
    QProcessExt uninstall;
    uninstall.start(hdcPath, QStringList() << "uninstall"_L1 << options.harmonyOsAppBundleName);
    uninstall.waitForFinished(10000);
    // Don't check result - it's OK if app wasn't installed
 
    // Install new HAP
    if (options.verbose)
        fprintf(stdout, "  Installing: %s\n", qPrintable(hapPath));
 
    QProcessExt install;
    install.setProcessChannelMode(QProcess::MergedChannels);
    install.start(hdcPath, QStringList() << "install"_L1 << hapPath);
 
    if (!install.waitForFinished(60000)) { // 60 second timeout
        fprintf(stderr, "Error: Installation timed out\n");
        return false;
    }
 
    QString installOutput = QString::fromUtf8(install.readAll());
 
    if (install.exitCode() != 0) {
        fprintf(stderr, "Error: Installation failed\n");
        fprintf(stderr, "%s\n", qPrintable(installOutput));
        return false;
    }
 
    if (options.verbose)
        fprintf(stdout, "  Installation output:\n%s\n", qPrintable(installOutput));
 
    // Launch the app
    if (options.verbose)
        fprintf(stdout, "  Launching application\n");
 
    QProcessExt launch;
    QStringList launchArgs;
    launchArgs << "shell"_L1 << "aa"_L1 << "start"_L1
               << "-a"_L1 << "EntryAbility"_L1
               << "-b"_L1 << options.harmonyOsAppBundleName;
 
    launch.start(hdcPath, launchArgs);
    launch.waitForFinished(5000);
 
    if (launch.exitCode() != 0) {
        fprintf(stderr, "Warning: Failed to launch application\n");
        // Not fatal
    }
 
    fprintf(stdout, "Successfully installed and launched application on device\n");
 
    return true;
}
 
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
    QCoreApplication::setApplicationName("harmonydeployqt"_L1);
    QCoreApplication::setApplicationVersion("1.0"_L1);
 
    Options options;
    options.timer.start();
 
    if (!parseCommandLine(app.arguments(), &options))
        return 1;
 
    if (options.verbose) {
        fprintf(stdout, "Qt HarmonyOS Deployment Tool\n");
        fprintf(stdout, "==============================\n\n");
    }
 
    if (!readInputConfiguration(&options))
        return 1;
 
    // Resolve before anything is generated: bad signing input should not cost a
    // full HAP build to report.
    SigningConfig signing;
    if (!resolveSigningConfig(options, &signing))
        return 1;
 
    const QList<TestQmlModule> testQmlModules =
            options.testBundleMode ? findTestQmlModules(options) : QList<TestQmlModule>{};
 
    if (options.testBundleMode && !verifyUniqueTestQmlModuleDeployDirs(testQmlModules))
        return 1;
 
    if (options.verbose)
        fprintf(stdout, "\nDeployment process started...\n");
 
    QString hapOutputPath;
 
    // Phase 1: Copy template
    if (!copyTemplate(options)) {
        fprintf(stderr, "Failed to copy template\n");
        return 1;
    }
 
    // Phase 2: Customize template (in test bundle mode, APP_LIBRARY_NAME uses a placeholder)
    if (!customizeTemplate(options)) {
        fprintf(stderr, "Failed to customize template\n");
        return 1;
    }
 
    // Phase 3: Copy libraries / dependencies (mode-specific)
    QStringList bundledBinaries; // populated only in test bundle mode
    if (options.testBundleMode) {
        if (!copyTestBinaries(options, bundledBinaries)) {
            fprintf(stderr, "Failed to copy test binaries\n");
            return 1;
        }
        if (!copyAllQtLibs(options)) {
            fprintf(stderr, "Failed to copy Qt libraries\n");
            return 1;
        }
        if (!copyAllQtPlugins(options)) {
            fprintf(stderr, "Failed to copy Qt plugins\n");
            return 1;
        }
        if (!copyAllQmlModules(options)) {
            fprintf(stderr, "Failed to copy QML modules\n");
            return 1;
        }
        if (!copyTestQmlModules(testQmlModules, options)) {
            fprintf(stderr, "Failed to copy test QML modules\n");
            return 1;
        }
    } else {
        if (!copyApplicationBinary(options)) {
            fprintf(stderr, "Failed to copy application binary\n");
            return 1;
        }
        if (!copyProjectLibraries(options)) {
            fprintf(stderr, "Failed to copy project libraries\n");
            return 1;
        }
        QSet<QString> processedLibs;
        if (!detectAndCopyDependencies(options, processedLibs)) {
            fprintf(stderr, "Failed to detect and copy dependencies\n");
            return 1;
        }
        bool qmlScanOk = true;
        QList<QmlImportInfo> qmlImports = scanQmlImports(options, &qmlScanOk);
        if (!qmlScanOk) {
            fprintf(stderr, "Failed to scan QML imports\n");
            return 1;
        }
        if (!copyQmlFiles(options)) {
            fprintf(stderr, "Failed to copy QML files\n");
            return 1;
        }
        if (!copyQmlImports(options, qmlImports, processedLibs)) {
            fprintf(stderr, "Failed to copy QML imports\n");
            return 1;
        }
        if (!copyPlugins(options, processedLibs)) {
            fprintf(stderr, "Failed to copy plugins\n");
            return 1;
        }
    }
 
    if (!copyExtraPlugins(options)) {
        fprintf(stderr, "Failed to copy extra plugins\n");
        return 1;
    }
 
    if (!injectSigningConfig(options, signing)) {
        fprintf(stderr, "Failed to inject signing configuration\n");
        return 1;
    }
 
    // Phase 4: Build HAP package
    if (!buildHap(options, &hapOutputPath)) {
        fprintf(stderr, "Failed to build HAP\n");
        return 1;
    }
 
    if (!signHap(options, signing, &hapOutputPath)) {
        fprintf(stderr, "Failed to sign HAP\n");
        return 1;
    }
 
    // Phase 5: Test bundle finalization
    if (options.testBundleMode) {
        if (!writeTestBinariesList(options, bundledBinaries)) {
            fprintf(stderr, "Failed to write binaries.txt\n");
            return 1;
        }
    }
 
    // hvigor writes the unsigned HAP whether or not it also signs, so that is the
    // OUTPUT of the CMake custom command.
    if (!options.depFilePath.isEmpty()) {
        const QString unsignedHapPath = options.outputDirectory
                + "/entry/build/default/outputs/default/entry-default-unsigned.hap"_L1;
        if (!writeDepfile(options, unsignedHapPath))
            fprintf(stderr, "Warning: Failed to write dependency file\n");
    }
 
    // Phase 6: Install to device (standard mode only)
    if (!options.testBundleMode) {
        if (!installToDevice(options, hapOutputPath)) {
            fprintf(stderr, "Failed to install to device\n");
            return 1;
        }
    }
 
    fprintf(stdout, "\n==============================================\n");
    fprintf(stdout, "Deployment completed successfully!\n");
    fprintf(stdout, "==============================================\n");
    fprintf(stdout, "Project location: %s\n", qPrintable(options.outputDirectory));
 
    if (!hapOutputPath.isEmpty())
        fprintf(stdout, "HAP package: %s\n", qPrintable(hapOutputPath));
 
    if (options.verbose)
        fprintf(stdout, "\nTotal time: %lld ms\n", options.timer.elapsed());
 
    return 0;
}