Revision control
++ # Copyright (C) 2026 The Qt Company Ltd.
++ # SPDX-License-Identifier: BSD-3-Clause
++
++ #
++ # Internal HarmonyOS deployment functions for automatic HAP target generation
++ #
++ # This file implements the finalizer pattern for HarmonyOS, similar to Android.
++ # When a Qt executable is created, these functions are called automatically to:
++ # 1. Set smart defaults for deployment properties
++ # 2. Generate deployment configuration
++ # 3. Create the ${target}_make_hap build target
++ #
++
++ # Promote QT_HARMONYOS_HDC / QT_HARMONYOS_HVIGOR from the environment to the
++ # matching cache var when the latter is not already set on the command line.
++ if(NOT DEFINED HARMONYOS_HDC
++ AND DEFINED ENV{QT_HARMONYOS_HDC}
++ AND NOT "$ENV{QT_HARMONYOS_HDC}" STREQUAL "")
++ set(HARMONYOS_HDC "$ENV{QT_HARMONYOS_HDC}")
++ endif()
++ if(NOT DEFINED HARMONYOS_HVIGOR
++ AND DEFINED ENV{QT_HARMONYOS_HVIGOR}
++ AND NOT "$ENV{QT_HARMONYOS_HVIGOR}" STREQUAL "")
++ set(HARMONYOS_HVIGOR "$ENV{QT_HARMONYOS_HVIGOR}")
++ endif()
++
++ # Detect the HarmonyOS SDK and NDK root directories from environment, CMake variables,
++ # the toolchain file or the compiler path, and set the output variables in the caller's
++ # scope. Either output may end up empty, most notably in a native on-device build, where
++ # there is no SDK and no NDK.
++ function(_qt_internal_harmonyos_get_sdk_ndk_paths sdk_root_var ndk_root_var)
++ set(sdk_root "")
++ set(ndk_root "")
++
++ if(DEFINED OHOS_SDK_ROOT)
++ set(sdk_root "${OHOS_SDK_ROOT}")
++ elseif(DEFINED ENV{OHOS_SDK_ROOT})
++ set(sdk_root "$ENV{OHOS_SDK_ROOT}")
++ elseif(CMAKE_SYSTEM_NAME STREQUAL "OHOS" AND CMAKE_CXX_COMPILER)
++ # Derive from compiler path: .../sdk/default/openharmony/native/llvm/bin/clang++
++ get_filename_component(_compiler_dir "${CMAKE_CXX_COMPILER}" DIRECTORY)
++ get_filename_component(_llvm_dir "${_compiler_dir}" DIRECTORY)
++ get_filename_component(_native_dir "${_llvm_dir}" DIRECTORY)
++ get_filename_component(sdk_root "${_native_dir}" DIRECTORY)
++ endif()
++
++ if(DEFINED OHOS_SDK_NATIVE)
++ # Set by the SDK's ohos.toolchain.cmake.
++ set(ndk_root "${OHOS_SDK_NATIVE}")
++ elseif(sdk_root AND IS_DIRECTORY "${sdk_root}/native")
++ set(ndk_root "${sdk_root}/native")
++ elseif(CMAKE_SYSTEM_NAME STREQUAL "OHOS" AND CMAKE_CXX_COMPILER)
++ # Derive from compiler path: .../native/llvm/bin/clang++
++ get_filename_component(_compiler_dir "${CMAKE_CXX_COMPILER}" DIRECTORY)
++ get_filename_component(_llvm_dir "${_compiler_dir}" DIRECTORY)
++ get_filename_component(ndk_root "${_llvm_dir}" DIRECTORY)
++ endif()
++
++ set(${sdk_root_var} "${sdk_root}" PARENT_SCOPE)
++ set(${ndk_root_var} "${ndk_root}" PARENT_SCOPE)
++ endfunction()
++
++ # Resolve the Qt installation root and subdirectory variables.
++ # QT6_INSTALL_PREFIX is set by QtInstallPaths.cmake (via find_package), but not during
++ # an internal qtbase build; in that case fall back to QtBase_BINARY_DIR.
++ function(_qt_internal_harmonyos_get_qt_install_dirs
++ install_root_var libs_dir_var plugins_dir_var qml_dir_var data_dir_var)
++ if(QT6_INSTALL_PREFIX)
++ set(${install_root_var} "${QT6_INSTALL_PREFIX}" PARENT_SCOPE)
++ set(${libs_dir_var} "${QT6_INSTALL_LIBS}" PARENT_SCOPE)
++ set(${plugins_dir_var} "${QT6_INSTALL_PLUGINS}" PARENT_SCOPE)
++ set(${qml_dir_var} "${QT6_INSTALL_QML}" PARENT_SCOPE)
++ set(${data_dir_var} "${QT6_INSTALL_DATA}" PARENT_SCOPE)
++ else()
++ set(${install_root_var} "${QtBase_BINARY_DIR}" PARENT_SCOPE)
++ set(${libs_dir_var} "${INSTALL_LIBDIR}" PARENT_SCOPE)
++ set(${plugins_dir_var} "${INSTALL_PLUGINSDIR}" PARENT_SCOPE)
++ set(${qml_dir_var} "${INSTALL_QMLDIR}" PARENT_SCOPE)
++ set(${data_dir_var} "${INSTALL_DATADIR}" PARENT_SCOPE)
++ endif()
++ endfunction()
++
++ # Collects the project's shared and module libraries once (cached globally) and adds them to the
++ # target's project-libraries list, except for the target itself.
++ # Runs deferred at the end of the top-level directory, when all project targets exist.
++ function(_qt_internal_harmonyos_add_project_libraries target)
++ get_property(collected GLOBAL PROPERTY _qt_harmonyos_project_library_candidates SET)
++ if(collected)
++ get_property(targets GLOBAL PROPERTY _qt_harmonyos_project_library_candidates)
++ else()
++ _qt_internal_collect_buildsystem_targets(targets
++ "${CMAKE_SOURCE_DIR}" INCLUDE SHARED_LIBRARY MODULE_LIBRARY)
++ set_property(GLOBAL PROPERTY _qt_harmonyos_project_library_candidates "${targets}")
++ endif()
++
++ list(REMOVE_ITEM targets ${target})
++ list(TRANSFORM targets REPLACE "(.+)" "$<TARGET_FILE:\\1>")
++ get_property(libs TARGET ${target} PROPERTY _qt_harmonyos_project_libraries)
++ list(APPEND libs ${targets})
++ list(REMOVE_DUPLICATES libs)
++ set_target_properties(${target} PROPERTIES _qt_harmonyos_project_libraries "${libs}")
++ endfunction()
++
++ # Collect directly-linked SHARED_LIBRARY CMake targets into a list of their
++ # output file paths (using generator expressions so paths are resolved at
++ # generation time). Also respects an explicit QT_HARMONYOS_EXTRA_LIBS property,
++ # whose entries may be CMake target names (resolved to the target's output file)
++ # or file paths / generator expressions.
++ # Analogous to Qt Android's QT_ANDROID_EXTRA_LIBS mechanism.
++ function(_qt_internal_harmonyos_collect_extra_libs target output_var)
++ set(result "")
++
++ get_target_property(link_libs "${target}" LINK_LIBRARIES)
++ if(link_libs AND NOT link_libs STREQUAL "link_libs-NOTFOUND")
++ foreach(lib IN LISTS link_libs)
++ # Skip generator expressions and linker flags — they can't be
++ # tested with if(TARGET ...) and don't refer to CMake targets.
++ if(lib MATCHES "^\\$<" OR lib MATCHES "^-")
++ continue()
++ endif()
++ if(NOT TARGET "${lib}")
++ continue()
++ endif()
++ get_target_property(lib_type "${lib}" TYPE)
++ if(lib_type STREQUAL "SHARED_LIBRARY")
++ list(APPEND result "$<TARGET_FILE:${lib}>")
++ endif()
++ endforeach()
++ endif()
++
++ # Honour explicit QT_HARMONYOS_EXTRA_LIBS target property. Each entry is
++ # either the name of a CMake target (resolved to the target's output file)
++ # or a file path / generator expression that evaluates to such a path.
++ set(extra_libs_props QT_HARMONYOS_EXTRA_LIBS)
++ # TODO Remove QT_OHOS_EXTRA_LIBS after a grace period but latest after 6.12.0.
++ list(APPEND extra_libs_props QT_OHOS_EXTRA_LIBS)
++ foreach(prop IN LISTS extra_libs_props)
++ get_target_property(extra_libs "${target}" ${prop})
++ if(extra_libs AND NOT extra_libs STREQUAL "extra_libs-NOTFOUND")
++ foreach(item IN LISTS extra_libs)
++ if(TARGET "${item}")
++ list(APPEND result "$<TARGET_FILE:${item}>")
++ else()
++ list(APPEND result "${item}")
++ endif()
++ endforeach()
++ endif()
++ endforeach()
++
++ list(REMOVE_DUPLICATES result)
++ set(${output_var} "${result}" PARENT_SCOPE)
++ endfunction()
++
++ # Append a JSON `"key": "value"` entry (with leading comma + newline) to
++ # `${out_var}` for the target's property, evaluated at generate-time via
++ # GENEX_EVAL so transitively-set values reach the JSON. Emits nothing if the
++ # property is unset or empty.
++ function(_qt_internal_harmonyos_add_deployment_property out_var json_key target property)
++ set(property_genex "$<GENEX_EVAL:$<TARGET_PROPERTY:${target},${property}>>")
++ string(APPEND ${out_var}
++ "$<$<BOOL:${property_genex}>:"
++ ",\n \"${json_key}\": \"${property_genex}\""
++ ">"
++ )
++ set(${out_var} "${${out_var}}" PARENT_SCOPE)
++ endfunction()
++
++ # Integer variant: emits the value without surrounding quotes. An integer 0
++ # is treated as unset (matches the historical semantics of the metadata loop).
++ function(_qt_internal_harmonyos_add_deployment_int_property out_var json_key target property)
++ set(property_genex "$<GENEX_EVAL:$<TARGET_PROPERTY:${target},${property}>>")
++ string(APPEND ${out_var}
++ "$<$<BOOL:${property_genex}>:"
++ ",\n \"${json_key}\": ${property_genex}"
++ ">"
++ )
++ set(${out_var} "${${out_var}}" PARENT_SCOPE)
++ endfunction()
++
++ # Append a JSON `"key": [ "v1", "v2" ]` entry. The semicolon-delimited list
++ # value is joined with $<COMMA> at generate-time. Emits nothing if the
++ # property is unset or empty.
++ function(_qt_internal_harmonyos_add_deployment_list_property out_var json_key target property)
++ set(property_genex "$<GENEX_EVAL:$<TARGET_PROPERTY:${target},${property}>>")
++ string(APPEND ${out_var}
++ "$<$<BOOL:${property_genex}>:"
++ ",\n \"${json_key}\": [\"$<JOIN:${property_genex},\"$<COMMA>\">\"]"
++ ">"
++ )
++ set(${out_var} "${${out_var}}" PARENT_SCOPE)
++ endfunction()
++
++ # Stash CMake-format copies of path-bearing target properties on internal
++ # `_qt_harmonyos_*` properties so the emission helpers can read them
++ # via genex without further escaping. Pre-release contract: users supply
++ # CMake-format paths (forward slashes), mirroring the Qt 6.6+ NEW behavior of
++ # the Android equivalent (`_qt_internal_android_format_deployment_paths`).
++ #
++ # qml-root-path concatenates two sources with a `;` glue when both are
++ # non-empty:
++ # * QT_QML_ROOT_PATH -- user-set roots
++ # * _qt_internal_qml_root_path -- roots auto-collected by
++ # _qt_internal_collect_qml_root_paths when .qml files are added as
++ # resources (populated for OHOS via the corresponding hook in
++ # Qt6CoreMacros.cmake).
++ function(_qt_internal_harmonyos_format_deployment_paths target)
++ string(JOIN "" qml_root_path_genex
++ "$<GENEX_EVAL:$<TARGET_PROPERTY:${target},QT_QML_ROOT_PATH>>"
++ "$<"
++ "$<AND:"
++ "$<BOOL:$<GENEX_EVAL:$<TARGET_PROPERTY:${target},QT_QML_ROOT_PATH>>>,"
++ "$<BOOL:$<GENEX_EVAL:$<TARGET_PROPERTY:${target},_qt_internal_qml_root_path>>>"
++ ">:;"
++ ">"
++ "$<GENEX_EVAL:$<TARGET_PROPERTY:${target},_qt_internal_qml_root_path>>"
++ )
++
++ set_target_properties(${target} PROPERTIES
++ _qt_harmonyos_qml_import_paths
++ "$<GENEX_EVAL:$<TARGET_PROPERTY:${target},QT_QML_IMPORT_PATH>>"
++ _qt_harmonyos_qml_root_paths
++ "${qml_root_path_genex}"
++ _qt_harmonyos_package_source_dir
++ "$<GENEX_EVAL:$<TARGET_PROPERTY:${target},QT_HARMONYOS_PACKAGE_SOURCE_DIR>>"
++ )
++
++ # QT_HARMONYOS_EXTRA_PLUGINS items are either CMake plugin target names or
++ # absolute file paths; target names are resolved to $<TARGET_FILE:> here so
++ # the emission helper sees a flat list of paths/genexes.
++ get_target_property(_extra_plugins ${target} QT_HARMONYOS_EXTRA_PLUGINS)
++ set(_resolved_extra_plugins "")
++ if(_extra_plugins AND NOT _extra_plugins STREQUAL "_extra_plugins-NOTFOUND")
++ foreach(item IN LISTS _extra_plugins)
++ if(TARGET ${item})
++ list(APPEND _resolved_extra_plugins "$<TARGET_FILE:${item}>")
++ else()
++ list(APPEND _resolved_extra_plugins "${item}")
++ endif()
++ endforeach()
++ endif()
++ set_target_properties(${target} PROPERTIES
++ _qt_harmonyos_extra_plugins "${_resolved_extra_plugins}"
++ )
++ endfunction()
++
++
++ # Sets default values for HarmonyOS deployment properties if not already set
++ function(_qt_internal_set_harmonyos_deployment_defaults target)
++ # Set default bundle name: org.qtproject.example.${target_sanitized}
++ get_target_property(bundle_name ${target} QT_HARMONYOS_APP_BUNDLE_NAME)
++ if(NOT bundle_name OR bundle_name STREQUAL "bundle_name-NOTFOUND")
++ # Sanitize target name to be a valid identifier
++ string(MAKE_C_IDENTIFIER "${target}" target_sanitized)
++ set_target_properties(${target} PROPERTIES
++ QT_HARMONYOS_APP_BUNDLE_NAME "org.qtproject.example.${target_sanitized}"
++ )
++ endif()
++
++ # Set default app name: ${target}
++ get_target_property(app_name ${target} QT_HARMONYOS_APP_NAME)
++ if(NOT app_name OR app_name STREQUAL "app_name-NOTFOUND")
++ set_target_properties(${target} PROPERTIES
++ QT_HARMONYOS_APP_NAME "${target}"
++ )
++ endif()
++
++ # Set default target architecture to the architecture used with the toolchain file.
++ get_target_property(target_archs ${target} QT_HARMONYOS_TARGET_ARCHS)
++ if(NOT target_archs OR target_archs STREQUAL "target_archs-NOTFOUND")
++ set_target_properties(${target} PROPERTIES
++ QT_HARMONYOS_TARGET_ARCHS "${OHOS_ARCH}"
++ )
++ endif()
++ endfunction()
++
++ # Generates the HarmonyOS deployment settings JSON file
++ function(_qt_internal_harmonyos_generate_deployment_settings target)
++ # Query bundle name from target property (now guaranteed to exist)
++ get_target_property(bundle_name ${target} QT_HARMONYOS_APP_BUNDLE_NAME)
++
++ # Query app name from target property
++ get_target_property(app_name ${target} QT_HARMONYOS_APP_NAME)
++ if(NOT app_name OR app_name STREQUAL "app_name-NOTFOUND")
++ set(app_name "${target}")
++ endif()
++
++ # Query target architectures from property
++ get_target_property(target_archs ${target} QT_HARMONYOS_TARGET_ARCHS)
++ if(NOT target_archs OR target_archs STREQUAL "target_archs-NOTFOUND")
++ set(target_archs "${OHOS_ARCH}")
++ endif()
++
++ # Check for multi-arch support (not yet implemented)
++ if(target_archs MATCHES ";")
++ list(LENGTH target_archs arch_count)
++ if(arch_count GREATER 1)
++ message(WARNING "Multiple architectures specified for ${target}: ${target_archs}. "
++ "Multi-architecture HAP generation is not yet supported. "
++ "Only the first architecture will be used.")
++ endif()
++ endif()
++
++ # Detect SDK and NDK paths
++ _qt_internal_harmonyos_get_sdk_ndk_paths(sdk_root ndk_root)
++
++ # Stash JSON-escaped copies of string-typed user-supplied properties on
++ # internal `_qt_harmonyos_*` properties. The emission helpers below
++ # substitute property values verbatim into the JSON; an unescaped `"` or
++ # `\` (e.g. in an app LABEL containing quoted text, or a Windows-style
++ # ICON path with backslashes) would otherwise corrupt the JSON.
++ foreach(prop_kv IN ITEMS
++ "QT_HARMONYOS_APP_VENDOR;_qt_harmonyos_app_vendor;string"
++ "QT_HARMONYOS_APP_VERSION_NAME;_qt_harmonyos_app_version_name;string"
++ "QT_HARMONYOS_APP_LABEL;_qt_harmonyos_app_label;string"
++ "QT_HARMONYOS_APP_ICON;_qt_harmonyos_app_icon;path"
++ "QT_HARMONYOS_MODULE_DESCRIPTION;_qt_harmonyos_module_description;string"
++ "QT_HARMONYOS_ABILITY_ORIENTATION;_qt_harmonyos_ability_orientation;string"
++ "QT_HARMONYOS_COMPATIBLE_SDK_VERSION;_qt_harmonyos_compatible_sdk_version;string"
++ "QT_HARMONYOS_TARGET_SDK_VERSION;_qt_harmonyos_target_sdk_version;string"
++ "QT_HARMONYOS_COMPILE_SDK_VERSION;_qt_harmonyos_compile_sdk_version;string"
++ )
++ list(GET prop_kv 0 _prop)
++ list(GET prop_kv 1 _mirror)
++ list(GET prop_kv 2 _type)
++ get_target_property(_value ${target} ${_prop})
++ if(_value)
++ # A `$media:<name>` value is a resource reference, not a path. It must
++ # not go through file(TO_CMAKE_PATH), which turns the `:` into a list
++ # separator on non-Windows hosts.
++ if(_type STREQUAL "path" AND NOT _value MATCHES "^\\$media:")
++ file(TO_CMAKE_PATH "${_value}" _value)
++ get_target_property(_target_source_dir ${target} SOURCE_DIR)
++ cmake_path(ABSOLUTE_PATH _value
++ BASE_DIRECTORY "${_target_source_dir}"
++ NORMALIZE
++ )
++ endif()
++ _qt_internal_json_escape_content("${_value}" _value)
++ set_target_properties(${target} PROPERTIES ${_mirror} "${_value}")
++ endif()
++ endforeach()
++
++ # Cache path-bearing properties on internal `_qt_harmonyos_*`
++ # properties for the genex-driven emission helpers below.
++ _qt_internal_harmonyos_format_deployment_paths(${target})
++
++ # Get binary path (will be a generator expression for multi-config)
++ set(BINARY_PATH "$<TARGET_FILE:${target}>")
++
++ # Convert target architectures to JSON array
++ if(target_archs MATCHES ";")
++ # List format
++ set(TARGET_ARCHS_JSON "")
++ foreach(arch ${target_archs})
++ if(TARGET_ARCHS_JSON)
++ string(APPEND TARGET_ARCHS_JSON ", ")
++ endif()
++ string(APPEND TARGET_ARCHS_JSON "\"${arch}\"")
++ endforeach()
++ else()
++ # Single value or semicolon-separated string
++ string(REPLACE ";" "\", \"" TARGET_ARCHS_JSON "${target_archs}")
++ set(TARGET_ARCHS_JSON "\"${TARGET_ARCHS_JSON}\"")
++ endif()
++
++ # Generate JSON config file
++ set(CONFIG_FILE "${CMAKE_CURRENT_BINARY_DIR}/${target}-harmony-deployment-settings.json")
++
++ set(JSON_CONTENT "{\n")
++ string(APPEND JSON_CONTENT " \"application-binary\": \"${BINARY_PATH}\",\n")
++ string(APPEND JSON_CONTENT " \"harmonyos-app-name\": \"${app_name}\",\n")
++ string(APPEND JSON_CONTENT " \"harmonyos-app-bundle-name\": \"${bundle_name}\",\n")
++ string(APPEND JSON_CONTENT " \"harmonyos-target-arch\": [${TARGET_ARCHS_JSON}]")
++
++ # App-level metadata set via the QT_HARMONYOS_APP_* target properties.
++ # Properties are read via $<TARGET_PROPERTY:> genex so transitively-set
++ # values (e.g. from linked targets) reach the JSON; absent entries leave
++ # the template default in place.
++ _qt_internal_harmonyos_add_deployment_property(JSON_CONTENT
++ "harmonyos-app-vendor" ${target} _qt_harmonyos_app_vendor)
++ _qt_internal_harmonyos_add_deployment_int_property(JSON_CONTENT
++ "harmonyos-app-version-code" ${target} QT_HARMONYOS_APP_VERSION_CODE)
++ _qt_internal_harmonyos_add_deployment_property(JSON_CONTENT
++ "harmonyos-app-version-name" ${target} _qt_harmonyos_app_version_name)
++ _qt_internal_harmonyos_add_deployment_property(JSON_CONTENT
++ "harmonyos-app-label" ${target} _qt_harmonyos_app_label)
++ _qt_internal_harmonyos_add_deployment_property(JSON_CONTENT
++ "harmonyos-app-icon" ${target} _qt_harmonyos_app_icon)
++
++ # SDK versions land in entry/build-profile.json5 via harmonydeployqt
++ # template substitution.
++ _qt_internal_harmonyos_add_deployment_property(JSON_CONTENT
++ "harmonyos-compatible-sdk-version" ${target} _qt_harmonyos_compatible_sdk_version)
++ _qt_internal_harmonyos_add_deployment_property(JSON_CONTENT
++ "harmonyos-target-sdk-version" ${target} _qt_harmonyos_target_sdk_version)
++ _qt_internal_harmonyos_add_deployment_property(JSON_CONTENT
++ "harmonyos-compile-sdk-version" ${target} _qt_harmonyos_compile_sdk_version)
++
++ # Module-level metadata.
++ _qt_internal_harmonyos_add_deployment_property(JSON_CONTENT
++ "harmonyos-module-description" ${target} _qt_harmonyos_module_description)
++ _qt_internal_harmonyos_add_deployment_list_property(JSON_CONTENT
++ "harmonyos-module-device-types" ${target} QT_HARMONYOS_MODULE_DEVICE_TYPES)
++ _qt_internal_harmonyos_add_deployment_property(JSON_CONTENT
++ "harmonyos-ability-orientation" ${target} _qt_harmonyos_ability_orientation)
++
++ if(sdk_root)
++ file(TO_CMAKE_PATH "${sdk_root}" sdk_root)
++ string(APPEND JSON_CONTENT ",\n \"sdk-root\": \"${sdk_root}\"")
++ endif()
++
++ if(ndk_root)
++ file(TO_CMAKE_PATH "${ndk_root}" ndk_root)
++ string(APPEND JSON_CONTENT ",\n \"ndk-root\": \"${ndk_root}\"")
++ endif()
++
++ # Add Qt installation directories (following androiddeployqt pattern)
++ # For cross-compilation: target dirs from current build, host tools from QT_HOST_PATH
++ _qt_internal_harmonyos_get_qt_install_dirs(
++ _qt_install_root _qt_install_libs_dir _qt_install_plugins_dir _qt_install_qml_dir
++ _qt_install_data_dir)
++ string(APPEND JSON_CONTENT
++ ",\n \"qtLibsDirectory\": \"${_qt_install_root}/${_qt_install_libs_dir}\"")
++ string(APPEND JSON_CONTENT
++ ",\n \"qtPluginsDirectory\": \"${_qt_install_root}/${_qt_install_plugins_dir}\"")
++ string(APPEND JSON_CONTENT
++ ",\n \"qtQmlDirectory\": \"${_qt_install_root}/${_qt_install_qml_dir}\"")
++
++ # Host Qt tools directory (macOS build for qmlimportscanner, etc.)
++ if(QT_HOST_PATH)
++ file(TO_CMAKE_PATH "${QT_HOST_PATH}" QT_HOST_PATH)
++ string(APPEND JSON_CONTENT
++ ",\n \"qtLibExecsDirectory\": \"${QT_HOST_PATH}/${QT6_HOST_INFO_LIBEXECDIR}\"")
++ string(APPEND JSON_CONTENT ",\n \"qtHostDirectory\": \"${QT_HOST_PATH}\"")
++ endif()
++
++ # Package source directory. User-set QT_HARMONYOS_PACKAGE_SOURCE_DIR wins
++ # over the bundled template (templates are only built for OHOS, so they
++ # live under the target Qt prefix, not QT_HOST_PATH). $<IF:> picks the
++ # right value at generate time; if both are empty (Qt install lacks the
++ # template AND the user didn't set the property), harmonydeployqt's own
++ # template search kicks in on the empty value.
++ set(_template_default "")
++ set(_template_dir
++ "${_qt_install_root}/${_qt_install_data_dir}/src/harmonyos/templates")
++ if(EXISTS "${_template_dir}")
++ file(REAL_PATH "${_template_dir}" _template_default)
++ endif()
++ set(_user_pkg_src_genex
++ "$<GENEX_EVAL:$<TARGET_PROPERTY:${target},_qt_harmonyos_package_source_dir>>")
++ string(APPEND JSON_CONTENT
++ ",\n \"harmonyos-package-source-directory\": "
++ "\"$<IF:$<BOOL:${_user_pkg_src_genex}>,${_user_pkg_src_genex},${_template_default}>\""
++ )
++
++ # Extra library search directories for third-party deps (e.g. HARMONYOS_DEPS_ROOT/lib for ICU).
++ # CMAKE_FIND_ROOT_PATH has the Qt install prefix prepended by qt.toolchain.cmake; skip it so
++ # we only emit paths that point to user-supplied dependency prefixes.
++ set(_extra_root_paths "${CMAKE_FIND_ROOT_PATH}")
++ list(REMOVE_DUPLICATES _extra_root_paths)
++ if(QT6_INSTALL_PREFIX)
++ list(REMOVE_ITEM _extra_root_paths "${QT6_INSTALL_PREFIX}")
++ endif()
++ set(_extra_libs_dirs_json "")
++ foreach(_root_path IN LISTS _extra_root_paths)
++ set(_lib_dir "${_root_path}/lib")
++ if(EXISTS "${_lib_dir}")
++ file(TO_CMAKE_PATH "${_lib_dir}" _lib_dir)
++ if(_extra_libs_dirs_json)
++ string(APPEND _extra_libs_dirs_json ", ")
++ endif()
++ string(APPEND _extra_libs_dirs_json "\"${_lib_dir}\"")
++ endif()
++ endforeach()
++ if(_extra_libs_dirs_json)
++ string(APPEND JSON_CONTENT ",\n \"extra-libs-dirs\": [${_extra_libs_dirs_json}]")
++ endif()
++
++ # QML root + import paths. Both emitted as JSON arrays so multiple roots /
++ # import paths can be forwarded to qmlimportscanner.
++ _qt_internal_harmonyos_add_deployment_list_property(JSON_CONTENT
++ "qml-root-path" ${target} _qt_harmonyos_qml_root_paths)
++ _qt_internal_harmonyos_add_deployment_list_property(JSON_CONTENT
++ "qml-import-paths" ${target} _qt_harmonyos_qml_import_paths)
++
++ # Collect permissions: the executable's own first (so its entries win
++ # for duplicate names), then transitive permissions contributed by Qt
++ # modules (and any other linked targets) via _qt_harmonyos_permissions.
++ set(harmonyos_permissions "")
++ get_target_property(user_permissions ${target} _qt_harmonyos_permissions)
++ if(user_permissions AND NOT user_permissions STREQUAL "user_permissions-NOTFOUND")
++ list(APPEND harmonyos_permissions ${user_permissions})
++ endif()
++
++ __qt_internal_collect_all_target_dependencies(${target} dep_targets)
++ foreach(dep IN LISTS dep_targets)
++ get_target_property(dep_perms ${dep} _qt_harmonyos_permissions)
++ if(dep_perms AND NOT dep_perms STREQUAL "dep_perms-NOTFOUND")
++ list(APPEND harmonyos_permissions ${dep_perms})
++ endif()
++ endforeach()
++
++ if(harmonyos_permissions)
++ # De-duplicate by the JSON "name" field, keeping the first occurrence.
++ set(seen_names "")
++ set(unique_permissions "")
++ foreach(entry IN LISTS harmonyos_permissions)
++ string(JSON name GET "${entry}" name)
++ if(NOT name IN_LIST seen_names)
++ list(APPEND seen_names "${name}")
++ list(APPEND unique_permissions "${entry}")
++ endif()
++ endforeach()
++ list(JOIN unique_permissions ",\n " harmonyos_permissions_joined)
++ string(APPEND JSON_CONTENT
++ ",\n \"permissions\": [\n ${harmonyos_permissions_joined}\n ]")
++ endif()
++
++ # Directly-linked SHARED_LIBRARY targets (e.g. test helper libs like qmetatype_lib1) are
++ # not Qt libraries and would otherwise be omitted from harmonydeployqt's ELF dependency
++ # scan, which only tracks libQt6* libs.
++ _qt_internal_harmonyos_collect_extra_libs(${target} extra_libs)
++ set_target_properties(${target} PROPERTIES _qt_harmonyos_project_libraries "${extra_libs}")
++ cmake_language(EVAL CODE
++ "cmake_language(DEFER DIRECTORY [[${CMAKE_SOURCE_DIR}]]
++ CALL _qt_internal_harmonyos_add_project_libraries [[${target}]])"
++ )
++ _qt_internal_harmonyos_add_deployment_list_property(JSON_CONTENT
++ "project-libraries" ${target} _qt_harmonyos_project_libraries)
++
++ # User-supplied extra plugin paths/targets (resolved to $<TARGET_FILE:>
++ # in _qt_internal_harmonyos_format_deployment_paths).
++ _qt_internal_harmonyos_add_deployment_list_property(JSON_CONTENT
++ "harmonyos-extra-plugins" ${target} _qt_harmonyos_extra_plugins)
++
++ string(APPEND JSON_CONTENT "\n}\n")
++
++ # Write config file at generation time (will contain generator expressions)
++ file(GENERATE OUTPUT "${CONFIG_FILE}" CONTENT "${JSON_CONTENT}")
++
++ # Store config file path on target for use in HAP target creation
++ set_target_properties(${target} PROPERTIES
++ QT_HARMONYOS_DEPLOYMENT_SETTINGS_FILE "${CONFIG_FILE}"
++ )
++ endfunction()
++
++ # Creates the ${target}_make_hap custom target
++ function(_qt_internal_harmonyos_add_hap_target target)
++ # Check if target already created (avoid duplicates)
++ get_target_property(hap_target_created ${target} _qt_harmonyos_hap_target_created)
++ if(hap_target_created)
++ return()
++ endif()
++ set_target_properties(${target} PROPERTIES _qt_harmonyos_hap_target_created TRUE)
++
++ # Get config file path
++ get_target_property(CONFIG_FILE ${target} QT_HARMONYOS_DEPLOYMENT_SETTINGS_FILE)
++ if(NOT CONFIG_FILE)
++ message(WARNING "Cannot create HAP target for ${target}: deployment settings not generated")
++ return()
++ endif()
++
++ # Set default output directory
++ set(OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/harmonyos-build")
++
++ # Check if the generator supports DEPFILE
++ _qt_internal_check_depfile_support(has_depfile_support)
++
++ # Define HAP output file and depfile paths
++ set(HAP_OUTPUT_FILE "${OUTPUT_DIR}/entry/build/default/outputs/default/${target}.hap")
++ set(DEP_FILE_PATH "${CMAKE_CURRENT_BINARY_DIR}/${target}_hap.d")
++
++ # Find harmonydeployqt tool
++ if(QT_HOST_PATH)
++ set(HARMONYDEPLOYQT_EXECUTABLE "${QT_HOST_PATH}/${QT6_HOST_INFO_BINDIR}/harmonydeployqt")
++ else()
++ set(HARMONYDEPLOYQT_EXECUTABLE
++ "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${QT6_HOST_INFO_BINDIR}/harmonydeployqt")
++ endif()
++
++ # hvigor tool path override. HARMONYOS_HVIGOR is an internal cache variable,
++ # also populated from the QT_HARMONYOS_HVIGOR environment variable above. The
++ # hvigorw wrapper is part of the build toolchain, not per-target metadata.
++ # When unset, harmonydeployqt auto-detects the hvigorw script inside the
++ # generated package.
++ if(HARMONYOS_HVIGOR)
++ set(_hvigor_args --hvigor "${HARMONYOS_HVIGOR}")
++ else()
++ set(_hvigor_args "")
++ endif()
++
++ # Create deployment target with DEPFILE support when available
++ if(has_depfile_support)
++ # Use add_custom_command with DEPFILE for dependency tracking
++ cmake_policy(PUSH)
++ if(POLICY CMP0116)
++ cmake_policy(SET CMP0116 NEW)
++ set(relative_to_dir ${CMAKE_CURRENT_BINARY_DIR})
++ else()
++ set(relative_to_dir ${CMAKE_BINARY_DIR})
++ endif()
++
++ add_custom_command(OUTPUT "${HAP_OUTPUT_FILE}"
++ COMMAND ${HARMONYDEPLOYQT_EXECUTABLE}
++ --input "${CONFIG_FILE}"
++ --output "${OUTPUT_DIR}"
++ ${_hvigor_args}
++ --depfile "${DEP_FILE_PATH}"
++ --depfile-base "${relative_to_dir}"
++ DEPENDS ${target} "${CONFIG_FILE}"
++ DEPFILE "${DEP_FILE_PATH}"
++ COMMENT "Generating HarmonyOS HAP for ${target}"
++ VERBATIM
++ )
++ cmake_policy(POP)
++
++ add_custom_target(${target}_make_hap DEPENDS "${HAP_OUTPUT_FILE}")
++ else()
++ # Fallback for generators/CMake versions without DEPFILE support
++ # (see _qt_internal_check_depfile_support for the exact conditions)
++ add_custom_target(${target}_make_hap
++ COMMAND ${HARMONYDEPLOYQT_EXECUTABLE}
++ --input "${CONFIG_FILE}"
++ --output "${OUTPUT_DIR}"
++ ${_hvigor_args}
++ DEPENDS ${target}
++ COMMENT "Generating HarmonyOS HAP for ${target}"
++ VERBATIM
++ )
++ endif()
++ endfunction()
++
++ # Main finalizer function called automatically by Qt's finalization system
++ # This is the entry point that gets registered with INTERFACE_QT_EXECUTABLE_FINALIZERS
++ function(_qt_internal_harmonyos_executable_finalizer target)
++ # Prevent duplicate calls
++ get_target_property(already_called ${target} _qt_harmonyos_executable_finalizer_called)
++ if(already_called)
++ return()
++ endif()
++ set_target_properties(${target} PROPERTIES _qt_harmonyos_executable_finalizer_called TRUE)
++
++ # Check target type - process executables and module libraries
++ # (OHOS uses MODULE_LIBRARY for apps)
++ get_target_property(target_type ${target} TYPE)
++ if(NOT target_type STREQUAL "EXECUTABLE" AND NOT target_type STREQUAL "MODULE_LIBRARY")
++ return()
++ endif()
++
++ # Set defaults, generate settings, create HAP target
++ _qt_internal_set_harmonyos_deployment_defaults(${target})
++ _qt_internal_harmonyos_generate_deployment_settings(${target})
++ _qt_internal_harmonyos_add_hap_target(${target})
++ endfunction()
++
++ # Helper to register the finalizer with a target
++ # This adds the finalizer function to INTERFACE_QT_EXECUTABLE_FINALIZERS property
++ function(_qt_internal_add_harmonyos_executable_finalizer target)
++ set_property(TARGET ${target} APPEND PROPERTY
++ INTERFACE_QT_EXECUTABLE_FINALIZERS
++ _qt_internal_harmonyos_executable_finalizer
++ )
++ endfunction()
++
++ function(qt6_add_harmonyos_permission target)
++ _qt_internal_add_harmonyos_permission(${ARGV})
++ endfunction()
++
++ if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS)
++ function(qt_add_harmonyos_permission target)
++ qt6_add_harmonyos_permission(${ARGV})
++ endfunction()
++ endif()
++
++ function(_qt_internal_harmonyos_test_bundle_settings_file out_var)
++ set(${out_var} "${CMAKE_BINARY_DIR}/all_tests-harmony-deployment-settings.json" PARENT_SCOPE)
++ endfunction()
++
++ # Test bundle: deployment-settings JSON for an "uber" HAP containing every
++ # libtst_*.so under CMAKE_BINARY_DIR.
++ function(_qt_internal_harmonyos_generate_test_bundle_deployment_settings)
++ _qt_internal_harmonyos_get_sdk_ndk_paths(sdk_root ndk_root)
++
++ _qt_internal_harmonyos_test_bundle_settings_file(CONFIG_FILE)
++
++ set(JSON_CONTENT "{\n")
++ string(APPEND JSON_CONTENT " \"test-bundle\": true,\n")
++ string(APPEND JSON_CONTENT " \"test-binaries-directory\": \"${CMAKE_BINARY_DIR}\",\n")
++ string(APPEND JSON_CONTENT " \"harmonyos-app-name\": \"QtAutoTests\",\n")
++ string(APPEND JSON_CONTENT " \"harmonyos-app-bundle-name\": \"org.qtproject.autotests\",\n")
++ string(APPEND JSON_CONTENT " \"harmonyos-target-arch\": [\"${OHOS_ARCH}\"]")
++
++ # Exclude "phone" so the bundle is a native 2-in-1 app: a bundle that
++ # lists "phone" is treated as a phone-app-on-PC, which makes
++ # window.restore() fail (QTBUG-148467) and breaks window-state tests.
++ string(APPEND JSON_CONTENT ",\n \"harmonyos-module-device-types\": [\"tablet\", \"2in1\"]")
++
++ if(sdk_root)
++ string(APPEND JSON_CONTENT ",\n \"sdk-root\": \"${sdk_root}\"")
++ endif()
++
++ if(ndk_root)
++ string(APPEND JSON_CONTENT ",\n \"ndk-root\": \"${ndk_root}\"")
++ endif()
++
++ _qt_internal_harmonyos_get_qt_install_dirs(
++ _qt_install_root _qt_install_libs_dir _qt_install_plugins_dir _qt_install_qml_dir
++ _qt_install_data_dir)
++ string(APPEND JSON_CONTENT
++ ",\n \"qtLibsDirectory\": \"${_qt_install_root}/${_qt_install_libs_dir}\"")
++ string(APPEND JSON_CONTENT
++ ",\n \"qtPluginsDirectory\": \"${_qt_install_root}/${_qt_install_plugins_dir}\"")
++ string(APPEND JSON_CONTENT
++ ",\n \"qtQmlDirectory\": \"${_qt_install_root}/${_qt_install_qml_dir}\"")
++
++ # Add the build-tree QML and plugins directories as higher-priority import
++ # paths. harmonydeployqt only scans the installed Qt prefix
++ # (qtQmlDirectory / qtPluginsDirectory), which fails in two cases: a
++ # prefix build where install has not been run yet, and a non-prefix build
++ # where nothing is ever installed. harmonydeployqt processes
++ # qml-import-paths and plugins-import-paths before their respective
++ # install-prefix counterparts, so build-tree files shadow installed copies
++ # via copyFileIfNewer's mtime-based priority. In a superbuild the two
++ # paths resolve to the same absolute location; the normalised-path
++ # comparisons below suppress duplicate entries. Both fields are arrays
++ # for consistency with QT_QML_IMPORT_PATH and to allow multiple paths in
++ # the future; currently each holds at most one entry.
++ set(_build_qml_dir "${QT_BUILD_DIR}/${INSTALL_QMLDIR}")
++ get_filename_component(_norm_build_qml "${_build_qml_dir}" ABSOLUTE)
++ get_filename_component(_norm_install_qml "${_qt_install_root}/${_qt_install_qml_dir}" ABSOLUTE)
++ if(NOT "${_norm_build_qml}" STREQUAL "${_norm_install_qml}")
++ string(APPEND JSON_CONTENT
++ ",\n \"qml-import-paths\": [\"${_norm_build_qml}\"]")
++ endif()
++ unset(_build_qml_dir)
++ unset(_norm_build_qml)
++ unset(_norm_install_qml)
++
++ set(_build_plugins_dir "${QT_BUILD_DIR}/${INSTALL_PLUGINSDIR}")
++ get_filename_component(_norm_build_plugins "${_build_plugins_dir}" ABSOLUTE)
++ get_filename_component(_norm_install_plugins "${_qt_install_root}/${_qt_install_plugins_dir}" ABSOLUTE)
++ if(NOT "${_norm_build_plugins}" STREQUAL "${_norm_install_plugins}")
++ string(APPEND JSON_CONTENT
++ ",\n \"plugins-import-paths\": [\"${_norm_build_plugins}\"]")
++ endif()
++ unset(_build_plugins_dir)
++ unset(_norm_build_plugins)
++ unset(_norm_install_plugins)
++
++ if(QT_HOST_PATH)
++ string(APPEND JSON_CONTENT
++ ",\n \"qtLibExecsDirectory\": \"${QT_HOST_PATH}/${QT6_HOST_INFO_LIBEXECDIR}\"")
++ string(APPEND JSON_CONTENT ",\n \"qtHostDirectory\": \"${QT_HOST_PATH}\"")
++ endif()
++
++ # Templates are built only for OHOS, so they live under the target prefix.
++ set(TEMPLATE_DIR
++ "${_qt_install_root}/${_qt_install_data_dir}/src/harmonyos/templates")
++ if(EXISTS "${TEMPLATE_DIR}")
++ file(REAL_PATH "${TEMPLATE_DIR}" TEMPLATE_DIR)
++ string(APPEND JSON_CONTENT
++ ",\n \"harmonyos-package-source-directory\": \"${TEMPLATE_DIR}\"")
++ endif()
++
++ # Strip the Qt install prefix that qt.toolchain.cmake prepends — we only
++ # want user-supplied third-party prefixes (e.g. HARMONYOS_DEPS_ROOT/lib).
++ set(_extra_root_paths "${CMAKE_FIND_ROOT_PATH}")
++ list(REMOVE_DUPLICATES _extra_root_paths)
++ if(QT6_INSTALL_PREFIX)
++ list(REMOVE_ITEM _extra_root_paths "${QT6_INSTALL_PREFIX}")
++ endif()
++ set(_extra_libs_dirs_json "")
++ foreach(_root_path IN LISTS _extra_root_paths)
++ set(_lib_dir "${_root_path}/lib")
++ if(EXISTS "${_lib_dir}")
++ file(TO_CMAKE_PATH "${_lib_dir}" _lib_dir)
++ if(_extra_libs_dirs_json)
++ string(APPEND _extra_libs_dirs_json ", ")
++ endif()
++ string(APPEND _extra_libs_dirs_json "\"${_lib_dir}\"")
++ endif()
++ endforeach()
++ if(_extra_libs_dirs_json)
++ string(APPEND JSON_CONTENT ",\n \"extra-libs-dirs\": [${_extra_libs_dirs_json}]")
++ endif()
++
++ # Collect permissions mirroring _qt_internal_harmonyos_generate_deployment_settings():
++ # each test target's own permissions first (so explicit overrides win), then the
++ # union of all transitive Qt module dependencies. Walk each unique dep only once.
++ # De-duplicate by JSON "name" field; first occurrence wins.
++ set(_all_permissions "")
++ set(_seen_names "")
++ set(_all_deps "")
++ get_property(_test_targets GLOBAL PROPERTY QT_INTERNAL_HARMONYOS_TEST_TARGETS)
++ set_property(GLOBAL PROPERTY QT_INTERNAL_HARMONYOS_TEST_TARGETS "")
++ foreach(_test IN LISTS _test_targets)
++ if(NOT TARGET "${_test}")
++ continue()
++ endif()
++ get_target_property(_own_perms "${_test}" _qt_harmonyos_permissions)
++ if(_own_perms AND NOT _own_perms STREQUAL "_own_perms-NOTFOUND")
++ foreach(_entry IN LISTS _own_perms)
++ string(JSON _name GET "${_entry}" name)
++ if(NOT _name IN_LIST _seen_names)
++ list(APPEND _seen_names "${_name}")
++ list(APPEND _all_permissions "${_entry}")
++ endif()
++ endforeach()
++ endif()
++ __qt_internal_collect_all_target_dependencies("${_test}" _deps)
++ list(APPEND _all_deps ${_deps})
++ endforeach()
++ list(REMOVE_DUPLICATES _all_deps)
++ foreach(_dep IN LISTS _all_deps)
++ get_target_property(_perms "${_dep}" _qt_harmonyos_permissions)
++ if(NOT _perms OR _perms STREQUAL "_perms-NOTFOUND")
++ continue()
++ endif()
++ foreach(_entry IN LISTS _perms)
++ string(JSON _name GET "${_entry}" name)
++ if(NOT _name IN_LIST _seen_names)
++ list(APPEND _seen_names "${_name}")
++ list(APPEND _all_permissions "${_entry}")
++ endif()
++ endforeach()
++ endforeach()
++
++ if(_all_permissions)
++ list(JOIN _all_permissions ",\n " _permissions_joined)
++ string(APPEND JSON_CONTENT
++ ",\n \"permissions\": [\n ${_permissions_joined}\n ]")
++ endif()
++
++ set(_all_dialogs "")
++ set(_seen_dialogs "")
++ foreach(_dialog_target IN LISTS _test_targets _all_deps)
++ if(NOT TARGET "${_dialog_target}")
++ continue()
++ endif()
++ get_target_property(_dialogs "${_dialog_target}" _qt_harmonyos_blocking_test_dialogs)
++ if(NOT _dialogs OR _dialogs STREQUAL "_dialogs-NOTFOUND")
++ continue()
++ endif()
++ foreach(_entry IN LISTS _dialogs)
++ string(JSON _name GET "${_entry}" name)
++ if(NOT _name IN_LIST _seen_dialogs)
++ list(APPEND _seen_dialogs "${_name}")
++ list(APPEND _all_dialogs "${_entry}")
++ endif()
++ endforeach()
++ endforeach()
++
++ if(_all_dialogs)
++ list(JOIN _all_dialogs ",\n " _dialogs_joined)
++ string(APPEND JSON_CONTENT
++ ",\n \"blockingTestDialogs\": [\n ${_dialogs_joined}\n ]")
++ endif()
++
++ # Collect QT_HARMONYOS_EXTRA_PLUGINS from every test target.
++ set(_all_extra_plugins "")
++ foreach(_test IN LISTS _test_targets)
++ if(NOT TARGET "${_test}")
++ continue()
++ endif()
++ get_target_property(_extra_plugins "${_test}" QT_HARMONYOS_EXTRA_PLUGINS)
++ if(NOT _extra_plugins OR _extra_plugins STREQUAL "_extra_plugins-NOTFOUND")
++ continue()
++ endif()
++ foreach(_item IN LISTS _extra_plugins)
++ if(TARGET "${_item}")
++ list(APPEND _all_extra_plugins "$<TARGET_FILE:${_item}>")
++ else()
++ list(APPEND _all_extra_plugins "${_item}")
++ endif()
++ endforeach()
++ endforeach()
++ list(REMOVE_DUPLICATES _all_extra_plugins)
++
++ if(_all_extra_plugins)
++ list(JOIN _all_extra_plugins "\", \"" _extra_plugins_joined)
++ string(APPEND JSON_CONTENT
++ ",\n \"harmonyos-extra-plugins\": [\"${_extra_plugins_joined}\"]")
++ endif()
++
++ string(APPEND JSON_CONTENT "\n}\n")
++
++ file(GENERATE OUTPUT "${CONFIG_FILE}" CONTENT "${JSON_CONTENT}")
++ endfunction()
++
++ # Create all_tests_make_hap: invoke harmonydeployqt in test-bundle mode.
++ # When HARMONYOS_HVIGOR is set, the helper also runs hvigor to build the
++ # signed HAP; otherwise only the project is generated.
++ # hvigor writes entry-default-signed.hap when signing is configured and
++ # entry-default-unsigned.hap otherwise. Pick the matching name so the build
++ # edge's OUTPUT and the install fixture target what hvigor actually produces.
++ function(_qt_internal_harmonyos_test_bundle_hap_basename out_var)
++ if(DEFINED ENV{QT_HARMONYOS_SIGNING_CERT_PATH}
++ OR DEFINED ENV{QT_HARMONYOS_SIGNING_PROFILE}
++ OR DEFINED ENV{QT_HARMONYOS_SIGNING_STORE_FILE}
++ OR DEFINED ENV{QT_HARMONYOS_SIGNING_KEY_ALIAS}
++ OR DEFINED ENV{QT_HARMONYOS_SIGNING_KEY_PASSWORD}
++ OR DEFINED ENV{QT_HARMONYOS_SIGNING_STORE_PASSWORD})
++ set(${out_var} "entry-default-signed.hap" PARENT_SCOPE)
++ else()
++ set(${out_var} "entry-default-unsigned.hap" PARENT_SCOPE)
++ endif()
++ endfunction()
++
++ function(_qt_internal_harmonyos_add_all_tests_hap_target)
++ _qt_internal_harmonyos_test_bundle_settings_file(CONFIG_FILE)
++ cmake_language(DEFER CALL _qt_internal_harmonyos_generate_test_bundle_deployment_settings)
++ set(OUTPUT_DIR "${CMAKE_BINARY_DIR}/harmonyos-tests-bundle")
++
++ _qt_internal_check_depfile_support(has_depfile_support)
++
++ _qt_internal_harmonyos_test_bundle_hap_basename(_hap_basename)
++ set(HAP_OUTPUT_FILE "${OUTPUT_DIR}/entry/build/default/outputs/default/${_hap_basename}")
++ set(BINARIES_TXT_FILE "${OUTPUT_DIR}/binaries.txt")
++ set(DEP_FILE_PATH "${CMAKE_BINARY_DIR}/all_tests_hap.d")
++
++ if(QT_HOST_PATH)
++ set(HARMONYDEPLOYQT_EXECUTABLE
++ "${QT_HOST_PATH}/${QT6_HOST_INFO_BINDIR}/harmonydeployqt")
++ else()
++ set(HARMONYDEPLOYQT_EXECUTABLE
++ "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${QT6_HOST_INFO_BINDIR}/harmonydeployqt")
++ endif()
++
++ set(extra_deploy_args "")
++ if(HARMONYOS_HVIGOR)
++ list(APPEND extra_deploy_args --hvigor "${HARMONYOS_HVIGOR}")
++ endif()
++
++ # Without hvigor the signed HAP is never produced and the install fixture
++ # would later fail with a confusing "file not found".
++ if(NOT HARMONYOS_HVIGOR
++ AND (DEFINED ENV{QT_HARMONYOS_SIGNING_CERT_PATH}
++ OR DEFINED ENV{QT_HARMONYOS_SIGNING_PROFILE}
++ OR DEFINED ENV{QT_HARMONYOS_SIGNING_STORE_FILE}
++ OR DEFINED ENV{QT_HARMONYOS_SIGNING_KEY_ALIAS}
++ OR DEFINED ENV{QT_HARMONYOS_SIGNING_KEY_PASSWORD}
++ OR DEFINED ENV{QT_HARMONYOS_SIGNING_STORE_PASSWORD}))
++ message(WARNING "QT_HARMONYOS_SIGNING_* environment variables are set, but "
++ "HARMONYOS_HVIGOR is not. The signed test HAP will not be produced; the "
++ "HAP install fixture will fail. Pass -DHARMONYOS_HVIGOR=<path-to-hvigorw> "
++ "or export QT_HARMONYOS_HVIGOR before configuring.")
++ endif()
++
++ # Match the EXCLUDE_FROM_ALL policy that qt_build_tests() applies to the
++ # individual test binaries: build the HAP as part of the default target
++ # only when QT_BUILD_TESTS_BY_DEFAULT is on.
++ if(QT_INTERNAL_TEST_TARGETS_EXCLUDE_FROM_ALL)
++ set(_all_keyword "")
++ else()
++ set(_all_keyword "ALL")
++ endif()
++
++ if(has_depfile_support)
++ cmake_policy(PUSH)
++ if(POLICY CMP0116)
++ cmake_policy(SET CMP0116 NEW)
++ endif()
++ set(relative_to_dir ${CMAKE_BINARY_DIR})
++
++ add_custom_command(OUTPUT "${HAP_OUTPUT_FILE}" "${BINARIES_TXT_FILE}"
++ COMMAND ${HARMONYDEPLOYQT_EXECUTABLE}
++ --test-bundle
++ --input "${CONFIG_FILE}"
++ --output "${OUTPUT_DIR}"
++ --depfile "${DEP_FILE_PATH}"
++ --depfile-base "${relative_to_dir}"
++ ${extra_deploy_args}
++ DEPENDS "${CONFIG_FILE}"
++ DEPFILE "${DEP_FILE_PATH}"
++ COMMENT "Generating HarmonyOS test bundle HAP"
++ VERBATIM
++ )
++ cmake_policy(POP)
++
++ add_custom_target(all_tests_make_hap ${_all_keyword}
++ DEPENDS "${HAP_OUTPUT_FILE}" "${BINARIES_TXT_FILE}")
++ else()
++ add_custom_target(all_tests_make_hap ${_all_keyword}
++ COMMAND ${HARMONYDEPLOYQT_EXECUTABLE}
++ --test-bundle
++ --input "${CONFIG_FILE}"
++ --output "${OUTPUT_DIR}"
++ ${extra_deploy_args}
++ DEPENDS "${CONFIG_FILE}"
++ COMMENT "Generating HarmonyOS test bundle HAP"
++ VERBATIM
++ )
++ endif()
++
++ _qt_internal_ensure_internal_custom_target(qt_internal_plugins)
++ add_dependencies(all_tests_make_hap qt_internal_plugins)
++ endfunction()
++
++ # FIXTURES_SETUP test that pushes the signed HAP to the device before any
++ # autotest runs. Requires HARMONYOS_HDC. Use QT_HARMONYOS_DEVICE (read from
++ # the environment when the generated script runs, i.e. per ctest invocation)
++ # to target a specific device, matching harmonyostestrunner's --device/-t.
++ function(_qt_internal_harmonyos_add_hap_install_fixture hap_signed_file)
++ if(NOT HARMONYOS_HDC)
++ return()
++ endif()
++
++ file(TO_CMAKE_PATH "${HARMONYOS_HDC}" hdc_cmake_path)
++ file(TO_CMAKE_PATH "${hap_signed_file}" hap_cmake_path)
++
++ set(install_script "${CMAKE_BINARY_DIR}/HarmonyOSInstallHapFixture.cmake")
++ file(GENERATE OUTPUT "${install_script}" CONTENT
++ "set(hdc \"${hdc_cmake_path}\")
++ set(hap \"${hap_cmake_path}\")
++ set(hdc_args \"\")
++ if(DEFINED ENV{QT_HARMONYOS_DEVICE} AND NOT \"\$ENV{QT_HARMONYOS_DEVICE}\" STREQUAL \"\")
++ set(hdc_args -t \"\$ENV{QT_HARMONYOS_DEVICE}\")
++ endif()
++ message(STATUS \"Installing HarmonyOS test HAP: \${hap}\")
++ file(TO_NATIVE_PATH \"\${hap}\" hap_native)
++ execute_process(
++ COMMAND \"\${hdc}\" \${hdc_args} app install -r \"\${hap_native}\"
++ RESULT_VARIABLE result
++ OUTPUT_VARIABLE output
++ ERROR_VARIABLE output
++ )
++ message(STATUS \"\${output}\")
++ if(NOT result EQUAL 0 OR output MATCHES \"error: failed to install bundle\")
++ message(FATAL_ERROR \"HAP install failed (exit code: \${result}):\\n\${output}\")
++ endif()
++ "
++ )
++
++ add_test(NAME HarmonyOSTestBundleInstall
++ COMMAND "${CMAKE_COMMAND}" -P "${install_script}"
++ )
++ set_tests_properties(HarmonyOSTestBundleInstall PROPERTIES
++ FIXTURES_SETUP HarmonyOSTestBundle
++ RUN_SERIAL TRUE
++ TIMEOUT 120
++ )
++ endfunction()
++
++ # Entry point. Idempotent; safe to call from qt_build_tests() for every module.
++ function(qt_internal_add_harmonyos_test_bundle)
++ if(NOT CMAKE_SYSTEM_NAME STREQUAL "OHOS")
++ message(WARNING "qt_internal_add_harmonyos_test_bundle() called on non-OHOS platform")
++ return()
++ endif()
++ if(TARGET all_tests_make_hap)
++ return()
++ endif()
++ _qt_internal_harmonyos_add_all_tests_hap_target()
++
++ set(OUTPUT_DIR "${CMAKE_BINARY_DIR}/harmonyos-tests-bundle")
++ _qt_internal_harmonyos_test_bundle_hap_basename(_hap_basename)
++ set(HAP_INSTALL_FILE
++ "${OUTPUT_DIR}/entry/build/default/outputs/default/${_hap_basename}")
++ _qt_internal_harmonyos_add_hap_install_fixture("${HAP_INSTALL_FILE}")
++ endfunction()