Aus dem Quellcode kompilieren Qt für HarmonyOS

Plattformhinweise – iOS

Bereitstellung

Das Entwickeln, Kompilieren, Ausführen und Debuggen einer Qt-Anwendung für iOS kann mit „ Qt Creator “ unter macOS erfolgen. Die Toolchain wird von Apples Xcode bereitgestellt, und die Ausführung von qmake oder CMake für ein auf iOS ausgerichtetes Projekt generiert zudem eine Xcode-Projektdatei (.xcodeproj) mit den anfänglichen Anwendungseinstellungen. Da „ Qt Creator “ keine Oberfläche zur Verwaltung aller für die iOS-Plattform spezifischen Einstellungen bietet, ist es manchmal erforderlich, diese direkt in Xcode anzupassen. Es ist besonders wichtig, vor der Einreichung einer Anwendung zur Veröffentlichung im Apple App Store zu überprüfen, ob die Anwendung korrekt konfiguriert ist.

Anwendungs-Bundles

iOS-Anwendungen werden in der Regel als eigenständige Anwendungsbündel bereitgestellt. Das Anwendungsbündel enthält die ausführbare Datei der Anwendung sowie Abhängigkeiten wie die Qt-Bibliotheken, Plugins, Übersetzungen und andere Ressourcen, die die Anwendung möglicherweise benötigt.

Um Ihre Anwendung mit CMake als Anwendungsbundle zu erstellen, setzen Sie die MACOSX_BUNDLE Eigenschaft für Ihr ausführbares Ziel wie folgt ein:

qt_add_executable(MyApp)
if(APPLE)
    set_target_properties(MyApp PROPERTIES MACOSX_BUNDLE TRUE)
endif()

Bei qmake sind Bündel standardmäßig aktiviert. Setzen Sie in Ihrer Projektdatei (.pro) die Option „ CONFIG -= app_bundle “, um diese Funktion zu deaktivieren.

Informationen zu Eigenschaftslisten-Dateien

Die Info-Property-List-Datei (Info.plist) unter iOS und macOS dient zur Konfiguration eines Anwendungs-Bundles. Zu diesen Konfigurationseinstellungen gehören:

Anzeigename und Kennung der Anwendung
Erforderliche Gerätefunktionen
Unterstützte Ausrichtungen der Benutzeroberfläche
Symbole und Startbilder

Weitere Informationen finden Sie in der Dokumentation zur „Information Property List“-Datei in der iOS Developer Library.

„Info.plist“ mit CMake

CMake generiert eine Standard- Info.plist -Datei, wenn für ein Ziel die Eigenschaft „ MACOSX_BUNDLE “ auf „ TRUE “ gesetzt ist. Leider ist diese Datei für iOS-Projekte nicht geeignet.

Stattdessen können Projekte `qt_add_executable` verwenden, wodurch automatisch eine ` Info.plist `-Datei mit Standardwerten generiert wird, die für iOS-Projekte geeignet sind.

Um eine benutzerdefinierte ` Info.plist`-Datei anzugeben, können Projekte die Ziel-Eigenschaft ` MACOSX_BUNDLE_INFO_PLIST ` wie unten gezeigt festlegen. Dadurch wird die automatische Dateigenerierung durch `qt_add_executable` deaktiviert und stattdessen die native Verarbeitung von CMake für die vom Projekt bereitgestellte ` Info.plist `-Datei verwendet.

qt_add_executable(app)
if(IOS)
    set_target_properties(app
        PROPERTIES MACOSX_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_SOURCE_DIR}/ios/Info.plist")
endif()

Informationen dazu, welche Ziel-Eigenschaften und Variablen für die von CMake durchgeführte Vorlagensubstitution angegeben werden können, finden Sie in der CMake-Dokumentation zu `MACOSX_BUNDLE_INFO_PLIST`.

„Info.plist“ mit QMake

Wenn qmake ausgeführt wird, wird eine „ Info.plist “-Datei mit entsprechenden Standardwerten generiert.

Es empfiehlt sich, die generierte „Info.plist“-Datei durch eine eigene Kopie zu ersetzen, um zu verhindern, dass sie beim nächsten Ausführen von qmake überschrieben wird. Sie können eine benutzerdefinierte Informations-Eigenschaftsliste mit der Variablen `QMAKE_INFO_PLIST` in Ihrer `.pro`-Datei definieren.

ios {
    QMAKE_INFO_PLIST = ios/Info.plist
}

Anwendungsressourcen

Für Dateien, die nicht in Qt-Ressourcen gebündelt werden können, bietet die qmake-Variable ` QMAKE_BUNDLE_DATA ` die Möglichkeit, eine Reihe von Dateien anzugeben, die in das Anwendungsbundle kopiert werden sollen. Zum Beispiel:

ios {
    fontFiles.files = $$files(fonts/*.ttf)
    fontFiles.path = fonts
    QMAKE_BUNDLE_DATA += fontFiles
}

Mit CMake lässt sich dasselbe auf folgende Weise erreichen:

qt_add_executable(app)
file(GLOB_RECURSE font_files CONFIGURE_DEPENDS "fonts/*.ttf")
if(IOS AND font_files)
    target_sources(app PRIVATE ${font_files})
    set_source_files_properties(
        ${font_files}
        PROPERTIES MACOSX_PACKAGE_LOCATION Resources/fonts)
endif()

Für Bildressourcen besteht eine alternative Möglichkeit darin, Asset-Kataloge in Xcode zu verwenden, die mit qmake wie folgt hinzugefügt werden können:

ios {
    QMAKE_ASSET_CATALOGS += ios/Assets.xcassets
}

Mit CMake:

qt_add_executable(app)
set(asset_catalog_path "ios/Assets.xcassets")
target_sources(app PRIVATE "${asset_catalog_path}")
set_source_files_properties(
    ${asset_catalog_path}
    PROPERTIES MACOSX_PACKAGE_LOCATION Resources)

Symbole

Ab Xcode 13 müssen Symbole zum Symbol-Set eines Asset-Katalogs hinzugefügt werden, der in der Regel „ AppIcon “ heißt. Xcode kümmert sich dann darum, die Datei „ Info.plist “ mit den richtigen Schlüsseln und Werten zu aktualisieren sowie alle erforderlichen Symbol-Dateien direkt in das Anwendungs-Bundle zu kopieren.

Ab Xcode 14 ist nur noch ein Bild mit einer Größe von 1024 × 1024 Pixel erforderlich. Xcode übernimmt die Generierung aller erforderlichen Symbole daraus. Es ist auch möglich, die Bilder manuell im Asset-Katalog anzugeben.

Eine detaillierte Liste der Icons, die angegeben werden können, finden Sie unter „Icon-Dateien“.

Der Dateiname spielt keine Rolle, wohl aber die tatsächliche Pixelgröße. Für eine universelle iOS-Anwendung sind folgende Bilder erforderlich:

AppIcon60x60@2x.png: 120 x 120 (für das iPhone)
AppIcon76x76@2x~ipad.png: 152 x 152 (für iPad)
AppIcon167x167.png: 167 x 167 (für das iPad Pro)
AppIcon1024x1024.png: 1024 x 1024 (für den App Store)

Ad-hoc-Veröffentlichungen sollten außerdem die folgenden Dateinamen im Anwendungsbundle enthalten, um die Anwendung in iTunes anzuzeigen:

iTunesArtwork 512 × 512
iTunesArtwork@2x 1024 x 1024

Am einfachsten fügen Sie die Symbole hinzu, indem Sie der Anleitung in der Xcode-Dokumentation unter „Asset-Kataloge und -Sets erstellen“ folgen.

Beim Erstellen eines Projekts mit CMake sollte außerdem das folgende Xcode-Attribut angegeben werden, um sicherzustellen, dass die App-Symbole von Xcode generiert werden.

set_target_properties(app_target_name PROPERTIES
    XCODE_ATTRIBUTE_ASSETCATALOG_COMPILER_APPICON_NAME AppIcon)

Nachfolgend finden Sie ein Beispiel dafür, wie eine „ Assets.xcassets/AppIcon.appiconset/Contents.json “-Datei für Xcode 14 aussehen könnte:

{
  "images" : [
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "20x20"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "3x",
      "size" : "20x20"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "29x29"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "3x",
      "size" : "29x29"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "38x38"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "3x",
      "size" : "38x38"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "40x40"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "3x",
      "size" : "40x40"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "60x60"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "3x",
      "size" : "60x60"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "64x64"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "3x",
      "size" : "64x64"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "68x68"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "76x76"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "83.5x83.5"
    },
    {
      "filename" : "AppIcon1024x1024.png",
      "idiom" : "universal",
      "platform" : "ios",
      "size" : "1024x1024"
    }
  ],
  "info" : {
    "author" : "xcode",
    "version" : 1
  }
}

Startbildschirme und Startbilder

Startbildschirme

Jede iOS-App muss einen Startbildschirm bereitstellen, der beim Start der App angezeigt wird. Ein Startbildschirm ist eine Interface-Builder- .xib -Datei, die auch als Storyboard-Datei bezeichnet wird. Weitere Informationen finden Sie unter „Festlegen des Startbildschirms Ihrer App“.

Die Unterstützung für Startbildschirme wurde mit iOS 9.0 eingeführt.

Sowohl qmake als auch CMake generieren einen Standard-Startbildschirm namens „ LaunchScreen.storyboard “.

Um einen benutzerdefinierten Startbildschirm festzulegen, muss dieser in das Anwendungsbundle kopiert werden, und der Schlüssel „ UILaunchStoryboardName “ muss in der Datei „ Info.plist “ auf den Namen des Startbildschirms gesetzt werden.

Qt unterstützt benutzerdefinierte Startbildschirme mit CMake seit Qt 6.4 und mit qmake seit Qt 6.0.

Angenommen, die Startdatei heißt „ Launch.storyboard “, kann sie wie folgt in die Datei „ Info.plist “ aufgenommen werden:

<key>UILaunchStoryboardName</key>
<string>Launch</string>

Um den Startbildschirm mit qmake in das Anwendungsbundle zu kopieren, verwenden Sie den folgenden Codeausschnitt in Ihrer Projekt-`.pro`-Datei:

ios {
    QMAKE_IOS_LAUNCH_SCREEN = $$PWD/Launch.storyboard
}

Mit CMake:

qt_add_executable(app)
if(IOS)
    set_target_properties(app PROPERTIES
        QT_IOS_LAUNCH_SCREEN "${CMAKE_CURRENT_SOURCE_DIR}/Launch.storyboard")
endif()

Launch Images

Es ist auch möglich, Startbilder (PNG-Dateien) anstelle eines Startbildschirms festzulegen.

Hinweis: Die Verwendung von Startbildern wird nicht empfohlen, da deren Unterstützung seit iOS 13.0 veraltet ist. Ziehen Sie stattdessen die Umstellung auf Startbildschirme in Betracht.

Startbilder müssen in das Anwendungsbundle kopiert werden, und ihre Namen müssen in der Datei „ Info.plist “ mithilfe des Schlüssels „ UILaunchImages “ festgelegt werden.

Die folgenden Bilder müssen vorbereitet werden:

LaunchImage-iOS7-568h@2x.png: 640 x 1136
LaunchImage-iOS7-Landscape.png: 1024 x 768
LaunchImage-iOS7-Landscape@2x.png: 2048 x 1536
LaunchImage-iOS7-Portrait.png: 768 x 1024
LaunchImage-iOS7-Portrait@2x.png: 1536 x 2048
LaunchImage-iOS7@2x.png: 640 x 960

Die Bilder können wie folgt unter Info.plist hinzugefügt werden:

<key>UILaunchImages</key>
<array>
    <dict>
        <key>UILaunchImageMinimumOSVersion</key>
        <string>7.0</string>
        <key>UILaunchImageName</key>
        <string>LaunchImage-iOS7</string>
        <key>UILaunchImageOrientation</key>
        <string>Portrait</string>
        <key>UILaunchImageSize</key>
        <string>{320, 568}</string>
    </dict>
    <dict>
        <key>UILaunchImageMinimumOSVersion</key>
        <string>7.0</string>
        <key>UILaunchImageName</key>
        <string>LaunchImage-iOS7</string>
        <key>UILaunchImageOrientation</key>
        <string>Portrait</string>
        <key>UILaunchImageSize</key>
        <string>{320, 480}</string>
    </dict>
</array>
<key>UILaunchImages~ipad</key>
<array>
    <dict>
        <key>UILaunchImageMinimumOSVersion</key>
        <string>7.0</string>
        <key>UILaunchImageName</key>
        <string>LaunchImage-iOS7-Landscape</string>
        <key>UILaunchImageOrientation</key>
        <string>Landscape</string>
        <key>UILaunchImageSize</key>
        <string>{768, 1024}</string>
    </dict>
    <dict>
        <key>UILaunchImageMinimumOSVersion</key>
        <string>7.0</string>
        <key>UILaunchImageName</key>
        <string>LaunchImage-iOS7-Portrait</string>
        <key>UILaunchImageOrientation</key>
        <string>Portrait</string>
        <key>UILaunchImageSize</key>
        <string>{768, 1024}</string>
    </dict>
    <dict>
        <key>UILaunchImageMinimumOSVersion</key>
        <string>7.0</string>
        <key>UILaunchImageName</key>
        <string>LaunchImage-iOS7</string>
        <key>UILaunchImageOrientation</key>
        <string>Portrait</string>
        <key>UILaunchImageSize</key>
        <string>{320, 568}</string>
    </dict>
    <dict>
        <key>UILaunchImageMinimumOSVersion</key>
        <string>7.0</string>
        <key>UILaunchImageName</key>
        <string>LaunchImage-iOS7</string>
        <key>UILaunchImageOrientation</key>
        <string>Portrait</string>
        <key>UILaunchImageSize</key>
        <string>{320, 480}</string>
    </dict>
</array>

Um die Startbilder mit qmake in das Anwendungsbundle zu kopieren, verwenden Sie den folgenden Codeausschnitt in Ihrer Projekt-`.pro`-Datei:

ios {
    app_launch_images.files = $$files($$PWD/ios/LaunchImage*.png)
    QMAKE_BUNDLE_DATA += app_launch_images
}

Mit CMake:

qt_add_executable(app)
file(GLOB_RECURSE launch_images CONFIGURE_DEPENDS "ios/LaunchImage*.png")
if(IOS AND launch_images)
    target_sources(app PRIVATE ${launch_images})
    set_source_files_properties(
        ${launch_images}
        PROPERTIES MACOSX_PACKAGE_LOCATION Resources)
endif()

Hinweis: Frühere iOS-Versionen unterstützten die Angabe eines einzelnen Startbildes mithilfe des Schlüssels „ UILaunchImageFile “ in „ Info.plist “, doch diese Unterstützung wurde seit iOS 10.0 als veraltet markiert.

Native Bildauswahl

Wenn Ihre Datei „ Info.plist “ einen Eintrag für „ NSPhotoLibraryUsageDescription “ enthält, bindet qmake automatisch ein zusätzliches Plugin ein, das den Zugriff auf den nativen Bildauswähler ermöglicht.

Bei CMake müssen Sie den nativen Bildauswähler manuell über ` qt_import_plugins` einbinden:

qt_import_plugins(app INCLUDE Qt6::QIosOptionalPlugin_NSPhotoLibraryPlugin)

Wenn das Verzeichnis in Ihrer ` QFileDialog ` wie folgt festgelegt ist:

QStandardPaths::standardLocations(QStandardPaths::PicturesLocation).last();

oder alternativ die „ currentFolder “ in einem „ FileDialog “ in QML auf:

shortcuts.pictures

Daraufhin wird der native Bildauswähler angezeigt, der den Zugriff auf das Fotoalbum des Benutzers ermöglicht.

Angabe der unterstützten iOS-Versionen

Apple-Plattformen verfügen über eine integrierte Möglichkeit, die von einer Anwendung unterstützten Betriebssystemversionen anzugeben. Dadurch können ältere Versionen der Plattformen automatisch eine benutzerfreundliche Fehlermeldung anzeigen, die den Benutzer auffordert, sein Betriebssystem zu aktualisieren, anstatt abzustürzen und einen Stack-Trace anzuzeigen.

Die wichtigsten Konzepte zur Angabe der Unterstützung für einen bestimmten Bereich von Betriebssystemversionen sind:

Das Bereitstellungsziel gibt die absolute Mindestversion von macOS oder iOS an, die Ihre Anwendung unterstützt.
Die SDK-Version gibt die empfohlene Höchstversion von macOS oder iOS an, die Ihre Anwendung unterstützt.

Wenn Sie eine Anwendung für eine Apple-Plattform entwickeln, sollten Sie stets die aktuellste Version von Xcode und das zum Zeitpunkt der Entwicklung verfügbare neueste SDK verwenden. Auf einigen Plattformen, wie beispielsweise iOS, wird Ihre App sogar aus dem App Store abgelehnt, wenn Sie dies nicht tun. Daher ist die SDK-Version immer größer oder gleich dem Bereitstellungsziel.

Wenn Sie eine Anwendung für eine Apple-Plattform entwickeln, müssen Sie das Bereitstellungsziel festlegen. Verschiedene Build-Tools innerhalb der Xcode-Toolchain verfügen alle über ein Flag, mit dem Sie diesen Wert festlegen können, darunter unter anderem der Compiler und der Linker. Durch die Festlegung des Deployment-Targets erklären Sie ausdrücklich, dass Ihre Anwendung mindestens auf dieser Version funktionieren muss und mit früheren Versionen des Betriebssystems nicht kompatibel ist. Es liegt dann an Ihnen, sicherzustellen, dass Ihre Nutzung der System-APIs mit Ihrer Deklaration übereinstimmt. Da der Compiler weiß, was Sie deklariert haben, kann er dabei helfen, dies durchzusetzen.

Die SDK-Version gilt als „weiche“ Höchstversion des Betriebssystems, mit der eine Anwendung kompatibel ist. Das bedeutet: Wenn die Anwendung mit einem bestimmten SDK erstellt wurde, verwendet sie auch auf neueren Betriebssystemversionen weiterhin das Verhalten dieses SDKs, da das Betriebssystem die Ladebefehle der Binärdatei überprüft und die Abwärtskompatibilität mit älteren Betriebssystemen emuliert. Wenn eine Anwendung beispielsweise mit dem macOS 10.12 SDK erstellt wurde, nutzt sie auch unter 10.13 und höher weiterhin das Verhalten von 10.12.

Mach-O-Binärdateien sind jedoch von Natur aus vorwärtskompatibel. So läuft beispielsweise eine mit dem iOS 9-SDK erstellte Anwendung problemlos unter iOS 10, nutzt jedoch möglicherweise nicht die Verhaltensänderungen, die an bestimmten Funktionen in der neuen Version vorgenommen wurden, bis die Anwendung mit dem neueren SDK neu kompiliert wird.

Die Mindestversion des Betriebssystems kann dem System über Compiler- und Linker-Flags mitgeteilt werden, die diese in die Mach-O-Binärdatei einbetten. Zudem muss der Schlüssel „ LSMinimumSystemVersion “ im App-Bundle der Anwendung gesetzt werden. Dieser Wert muss mit dem an den Compiler und den Linker übergebenen Wert übereinstimmen, da das Betriebssystem unter macOS dadurch einen benutzerfreundlichen Fehlerdialog anzeigen kann, der darauf hinweist, dass die Anwendung eine neuere Betriebssystemversion benötigt – anstelle eines Absturzdialogs. Der Schlüssel „ LSMinimumSystemVersion “ ist zudem der Schlüssel, den der App Store verwendet, um die erforderliche Betriebssystemversion anzuzeigen; die Compiler- und Linker-Flags haben hier keinen Einfluss.

In den meisten Fällen funktionieren Qt-Anwendungen ohne Probleme. Beispielsweise setzen die Qt-Mkspecs in qmake die Variablen ` QMAKE_IOS_DEPLOYMENT_TARGET ` oder ` QMAKE_MACOSX_DEPLOYMENT_TARGET ` auf die Mindestversion, die Qt selbst unterstützt. Ebenso setzen die Qt-Module in Qbs die Variablen „ cpp.minimumIosVersion “, „ cpp.minimumMacosVersion “, „ cpp.minimumTvosVersion “ oder „ cpp.minimumWatchosVersion “ auf die Mindestversion, die Qt selbst unterstützt.

Sie müssen jedoch vorsichtig sein, wenn Sie Ihre Zielversion manuell festlegen. Wenn Sie einen Wert festlegen, der höher ist als von Qt gefordert, und eine eigene ` Info.plist `-Datei bereitstellen, müssen Sie einen ` LSMinimumSystemVersion `-Eintrag zur ` Info.plist `-Datei hinzufügen, der dem Wert des Bereitstellungsziels entspricht, da das Betriebssystem den Wert aus ` LSMinimumSystemVersion ` als maßgeblich verwendet.

Wenn Sie einen Wert für das Bereitstellungsziel angeben, der unter den von Qt geforderten Anforderungen liegt, wird die Anwendung mit ziemlicher Sicherheit an einer Stelle in den Qt-Bibliotheken abstürzen, wenn sie auf einer älteren Version als der von Qt unterstützten ausgeführt wird. Stellen Sie daher sicher, dass der tatsächliche Code des Build-Systems die tatsächlich erforderliche Mindestversion des Betriebssystems widerspiegelt.

Veröffentlichung im Apple App Store

Die Überprüfung, ob Ihre Qt-für-iOS-Anwendung für die Veröffentlichung im App Store bereit ist, kann wie unter „Einreichen der Anwendung“ beschrieben erfolgen. Zum Einreichen der Anwendung können Sie Xcode oder den Application Loader (der mit Xcode installiert wird) verwenden. „ Qt Creator “ bietet keine Oberfläche zur Verwaltung aller Einstellungen in einer Xcode-Projektkonfiguration.

Die Anwendung sollte auf den iOS-Versionen und Geräten getestet werden, für deren Unterstützung sie vorgesehen ist. Das Mindest-Bereitstellungsziel für Qt-Anwendungen variiert je nach Qt-Version. Weitere Informationen finden Sie unter „Unterstützte Konfigurationen“.

Der eigentliche Veröffentlichungsprozess umfasst die Erstellung eines Verteilungszertifikats und eines Provisioning-Profils, die Erstellung eines signierten Archivs Ihrer Anwendung sowie die Durchführung einer Reihe von Validierungstests.

Weitere Informationen finden Sie im Leitfaden zur App-Verteilung in der iOS-Entwicklerbibliothek.

Warnungen zur Symbol-Sichtbarkeit

Im Zusammenhang mit der Verknüpfung von C++-Bibliotheken werden Funktionen und Objekte als Symbole bezeichnet. Symbole können entweder die Sichtbarkeit „ default “ oder „ hidden “ haben.

Aus Leistungsgründen kompilieren Qt und viele andere Bibliotheken ihre Quellcodes standardmäßig mit der Sichtbarkeit „ hidden “ und kennzeichnen Symbole erst dann mit der Sichtbarkeit „ default “, wenn sie für die Verwendung in Anwenderprojekten vorgesehen sind.

Leider kann der Apple-Linker Warnungen ausgeben, wenn eine Bibliothek mit der Sichtbarkeit „ hidden “ kompiliert wird und eine Anwendung oder Bibliothek eines Benutzerprojekts mit der Sichtbarkeit „ default “ kompiliert wird.

Wenn Projektentwickler die Warnung unterdrücken möchten, müssen sie ihren Projektcode ebenfalls mit der Sichtbarkeit „ hidden “ erstellen.

In CMake kann dies erreicht werden, indem der folgende Code in Ihre ` CMakeLists.txt` eingefügt wird:

set(CMAKE_CXX_VISIBILITY_PRESET hidden)

In qmake kann dies erreicht werden, indem Sie den folgenden Code in Ihre ` .pro `-Datei einfügen:

CONFIG+=hide_symbols

Falls ein Projekt Bibliotheken erstellt, müssen alle Symbole in der Bibliothek, die in einer anderen Bibliothek oder Anwendung verwendet werden sollen, explizit mit der Sichtbarkeit „ default “ gekennzeichnet werden. Dies kann beispielsweise dadurch erfolgen, dass solche Funktionen oder Klassen mit „ Q_DECL_EXPORT “ versehen werden.

Problem bei der Produktarchivierung mit CMake

Aufgrund eines Problems in CMake kann der Versuch, ein Produktarchiv mit einer iOS-Anwendung zu erstellen, fehlschlagen.

Dies kann sowohl beim Erstellen des Archivs in Xcode über den Menüpunkt „Produkt“ → „Archivieren“ als auch über die Befehlszeile mit dem Befehl „ xcodebuild -archivePath “ auftreten.

Die Fehlermeldung verweist möglicherweise auf undefinierte Symbole oder nicht vorhandene Dateipfade.

Um das Problem zu umgehen, stellen Sie sicher, dass Sie eine „ Release “-Version des Projekts erstellen, bevor Sie versuchen, ein Archiv zu erstellen.

dSYM-Bundle fehlt in einem xcarchive, das von einem CMake-Xcode-Projekt erstellt wurde

Aufgrund eines Fehlers in Xcode und bestimmter CMake-Einschränkungen wird bei einem von CMake generierten Xcode-Projekt während des Archivierungsvorgangs in Xcode das „ dSYM “-Bundle der Anwendung nicht in das „ xcarchive “ aufgenommen.

Qt bietet eine optionale Abhilfe an, damit das „ dSYM “-Bundle in das „ xcarchive “ aufgenommen wird, was jedoch mit Einschränkungen verbunden ist. Das heißt, die folgenden CMake-Funktionen funktionieren nicht korrekt:

$<TARGET_FILE:app> -Generatorausdrücke werden möglicherweise zu einem ungültigen Pfad erweitert, der nicht zur App-Binärdatei führt
Die Variable „ CMAKE_RUNTIME_OUTPUT_DIRECTORY “ und die zugehörige Ziel-Eigenschaft „ RUNTIME_OUTPUT_DIRECTORY “ werden ignoriert, selbst wenn sie gesetzt sind
weitere unbekannte Probleme

Um die oben genannten Probleme zu beheben, können Sie Folgendes tun:

Aktivieren Sie die Problemumgehung nur, wenn Sie die „ xcarchive “ erstellen möchten, und nicht während der Projektentwicklung
Stellen Sie sicher, dass Sie ausführbare Dateien und Bibliotheken nur im Stammverzeichnis des Projekts hinzufügen und nicht in Aufrufen von „ add_subdirectory “.

Um die Abhilfe zu aktivieren, konfigurieren Sie das Projekt mit der folgenden Option:

cmake . -DQT_USE_RISKY_DSYM_ARCHIVING_WORKAROUND=ON

oder setzen Sie die Variable im Projekt vor allen Aufrufen von ` qt_add_executable ` oder ` qt_add_library `:

set(QT_USE_RISKY_DSYM_ARCHIVING_WORKAROUND ON)

...

qt_add_executable(app)

Kompilieren aus dem Quellcode Qt für HarmonyOS

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.