qt/qtbase/src/tools/harmonydeployqt/main.cpp

Revision control

Copy as Markdown

// 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 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-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"
"Passwords must be hvigor-encrypted blobs. If any signing input is set,\n"
"all six required values must be present, or the HAP is left unsigned.\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 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(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->signingAlg = parser.value(signingAlgOption);
return true;
}
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();
// 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
// the user explicitly 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;
}
// build-profile.json5 ships with `"signingConfigs": []`; replace that literal
// with a populated block when the user supplies signing material. JSON5 input
// (trailing commas, // comments) precludes QJsonDocument, hence string surgery.
static bool injectSigningConfig(const Options &options)
{
struct Field
{
const char *envName;
const char *cliFlag;
QString cliValue;
QByteArray envValue;
QByteArray resolved() const
{
if (!cliValue.isEmpty())
return cliValue.toUtf8();
return envValue;
}
QString sourceLabel() const
{
return cliValue.isEmpty()
? QString::fromLatin1(envName)
: QString::fromLatin1(cliFlag);
}
};
Field required[] = {
{ "QT_HARMONYOS_SIGNING_CERT_PATH", "--signing-cert-path",
options.signingCertPath, qgetenv("QT_HARMONYOS_SIGNING_CERT_PATH") },
{ "QT_HARMONYOS_SIGNING_PROFILE", "--signing-profile",
options.signingProfile, qgetenv("QT_HARMONYOS_SIGNING_PROFILE") },
{ "QT_HARMONYOS_SIGNING_STORE_FILE", "--signing-store-file",
options.signingStoreFile, qgetenv("QT_HARMONYOS_SIGNING_STORE_FILE") },
{ "QT_HARMONYOS_SIGNING_KEY_ALIAS", "--signing-key-alias",
options.signingKeyAlias, qgetenv("QT_HARMONYOS_SIGNING_KEY_ALIAS") },
{ "QT_HARMONYOS_SIGNING_KEY_PASSWORD", "--signing-key-password",
options.signingKeyPassword, qgetenv("QT_HARMONYOS_SIGNING_KEY_PASSWORD") },
{ "QT_HARMONYOS_SIGNING_STORE_PASSWORD", "--signing-store-password",
options.signingStorePassword, qgetenv("QT_HARMONYOS_SIGNING_STORE_PASSWORD") },
};
QByteArray signAlg = options.signingAlg.isEmpty()
? qgetenv("QT_HARMONYOS_SIGNING_ALG")
: options.signingAlg.toUtf8();
bool anySet = !signAlg.isEmpty();
for (const Field &f : required)
anySet = anySet || !f.resolved().isEmpty();
if (!anySet)
return true;
QStringList missing;
for (const Field &f : required) {
if (f.resolved().isEmpty())
missing << QString::fromLatin1(f.cliFlag) + " / "_L1
+ QString::fromLatin1(f.envName);
}
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;
}
if (signAlg.isEmpty())
signAlg = "SHA256withECDSA";
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 QByteArray &value, bool last) {
replacement.append(" \"");
replacement.append(key);
replacement.append("\": \"");
replacement.append(escapeJsonString(value));
replacement.append('"');
if (!last)
replacement.append(',');
replacement.append('\n');
};
appendField("certpath", required[0].resolved(), false);
appendField("keyAlias", required[3].resolved(), false);
appendField("keyPassword", required[4].resolved(), false);
appendField("profile", required[1].resolved(), false);
appendField("signAlg", signAlg, false);
appendField("storeFile", required[2].resolved(), false);
appendField("storePassword", required[5].resolved(), 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));
fprintf(stdout, " certpath: %s (from %s)\n",
required[0].resolved().constData(), qPrintable(required[0].sourceLabel()));
fprintf(stdout, " profile: %s (from %s)\n",
required[1].resolved().constData(), qPrintable(required[1].sourceLabel()));
fprintf(stdout, " storeFile: %s (from %s)\n",
required[2].resolved().constData(), qPrintable(required[2].sourceLabel()));
fprintf(stdout, " keyAlias: %s (from %s)\n",
required[3].resolved().constData(), qPrintable(required[3].sourceLabel()));
fprintf(stdout, " signAlg: %s\n", signAlg.constData());
}
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);
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;
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)) {
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;
}
// Phase 5: Test bundle finalization
if (options.testBundleMode) {
if (!writeTestBinariesList(options, bundledBinaries)) {
fprintf(stderr, "Failed to write binaries.txt\n");
return 1;
}
}
// Write dependency file for CMake DEPFILE support
// Always write depfile (even if HAP build was skipped), using expected output path
if (!options.depFilePath.isEmpty()) {
if (hapOutputPath.isEmpty()) {
// Construct expected HAP path (matches CMake's HAP_OUTPUT_FILE)
if (options.testBundleMode) {
hapOutputPath = options.outputDirectory
+ "/entry/build/default/outputs/default/autotests.hap"_L1;
} else {
// Extract target name from binary: libnativeresource_test.so -> nativeresource_test
QString targetName = QFileInfo(options.applicationBinary).completeBaseName();
if (targetName.startsWith("lib"_L1))
targetName = targetName.mid(3);
hapOutputPath = options.outputDirectory + "/entry/build/default/outputs/default/"_L1
+ targetName + ".hap"_L1;
}
}
if (!writeDepfile(options, hapOutputPath))
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;
}