Deployment

ArcGIS Maps SDK for Qt enables you to build mapping applications for Windows, macOS, Linux, Android, and iOS. Follow the steps below to ensure you have licensed the capabilities that your app uses and that you understand associated costs.

• License the capabilities you included in the app. Refer to the License levels and capabilities topic to determine the license level you require, and to the Get a license topic to learn how to acquire a license.
• Esri and data attribution requirements.
• If you deploy content or services from ArcGIS location services, see the FAQ topic in the Mapping and location services guide.

• Prepare and Deploy your app

Apps built with ArcGIS Maps SDK for Qt are self-contained. For example, deploying a Windows app does not add keys to the Windows registry. Deploying apps can be as simple as copying and pasting your app's executable files along with other dependent files to a different machine or device. Likewise, uninstalling can be as simple as deleting the files. The SDK lets you build and deploy self-contained, stand-alone apps or build and deploy capabilities into existing software.

Esri and data attribution requirements

When you use Esri technology, you must include Esri attribution and data attribution. This includes applications that use any ArcGIS API, SDK, service, content, or data. The attribution is required for applications that either contain a map or do not contain a map. These requirements are outlined in detail in Esri and data attribution.

Prepare and Deploy your app

1. Prepare your app

   • For Android, compile your app and use the androiddeployqt deployment tool provided by the Qt Group to create an Application Package (APK) or Android App Bundle (AAB). Consult the Google Play store documentation for details about publishing your app on their platform.
   • For iOS, build your Qt project, open the output .xcodeproj file in Xcode, and create an .ipa by archiving your app. Note that apps can be distributed either through the Apple developer enterprise program or by submitting your app to the App Store.
   • For macOS, compile your app and use the Mac deployment tool provided by the Qt Group. This tool bundles the dependencies into an application bundle.
   • For Linux, compile your app. Place the executable and any associated resources such as packages, data, or client files, inside a folder you intend to use as a deployment folder. You can get details from the article Linux deployment on the Qt Group's website.
   • For Windows, build your Qt project. , and use the Windows deployment tool provided by the Qt Group. This tool creates a deployable folder containing all the dependencies needed to run the app.
   • For Linux and Windows, if your application uses Local Server functionality, you must also create a Local Server deployment to include with your deployed application. Refer to Deploy Local Server for more information.
   • If your application uses Local Server to create local map services and the input map files use third-party fonts, you must make sure those third-party fonts are installed on each client machine where your application will run.
   • When deploying your app to macOS, iOS, or Windows, you will need to include additional shaders or force the use of OpenGL. See the Deploying shaders section below for more information.

2. The deployment folder now contains everything you need to deploy your app. To distribute and deploy your app, copy and paste the deployment folder onto each of your end-user's machines or devices. Each deployment folder can be self-contained and consists of the following:

   • Your app executable
   • Supporting platform and framework libraries required by your app
   • Runtime components and libraries
   • Supporting files, such as data for local use

3. Test the app by running it from this location.

Deploying specialized symbols

You may need to deploy specialized symbols, such as military symbol dictionaries, for use with your ArcGIS Runtime app.

You have two options for including these symbols in your deployment.

1. You can download the Military Dictionary Symbol Styles that Esri hosts in ArcGIS Online and include them in your app deployment. You will need to add logic in your app to locate and use the files, as needed.
2. Add logic to your app that prepares the app for offline use by downloading the files and storing them locally. You can access these resources when your user is online either by programmatically downloading them or accessing them as portal items, reading their contents, and storing them locally. The following code example shows how to access some of the hosted military symbol items.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
    // Get the ArcGIS Online portal (default if no URL is provided).
    Portal* portal = new Portal(this);

    // Get the military symbol items (use their unique item IDs).
    PortalItem* itemMil2525c = new PortalItem(portal, "ef95f95470db437f80ea764a9d05203b", this);
    PortalItem* itemMil2525d = new PortalItem(portal, "c78b149a1d52414682c86a5feeb13d30", this);

    // Asynchronously fetches the data for these items and saves it to a specified filePath.
    // The signal emitted when fetching data is completed is Item::fetchDataCompleted(bool success)
    QFuture<void> ignoredc = itemMil2525c->fetchDataAsync(outMil2525cDataPath);
    QFuture<void> ignoredd = itemMil2525d->fetchDataAsync(outMil2525dDataPath);

Deploying shaders

ArcGIS Maps SDK for Qt renders 2D maps and 3D scenes with different graphics APIs, depending on the platform. The Qt Rendering Hardware Interface (RHI) for Qt Quick applications defaults to Metal for macOS/iOS, Direct3D on Windows, OpenGL on Linux, and OpenGL ES on Android. When developing Qt Quick apps for macOS/iOS or Windows, you will need to include Metal or Direct3D shaders respectively or force the use of OpenGL. Qt Widgets exclusively uses OpenGL rendering and does not support Metal or Direct3D. OpenGL does not require any additional shaders in your deployment.

• Mac apps will require a minimum of Metal 2.0 for Big Sur and Monterey, or Metal 3.0 for Ventura. ArcGIS Maps SDK for Qt comes with Metal shader files in the SDK installation at ~/ArcGIS_SDKs/Qt{Maps SDK version no.}/sdk/macOS/universal/shaders. You will need to copy these shader files into your app bundle at <app_bundle>/Contents/Resources/shaders.

• iOS will make use of Metal shaders by default, but these are included within the Runtimecore.framework and don't require you to include any additional shaders.

• Windows apps require a minimum of Direct3D 11.1. ArcGIS Maps SDK for Qt comes with Direct3D shader files in the SDK installation at Program Files/ArcGIS SDKs/Qt{Maps SDK version no.}/sdk/windows/x64/shaders. You will need to copy these shader files into your app directory at yourAppDirectory/shaders.

• If you want your application to always force the use of OpenGL regardless of platform and not use the target's default rendering API, you can make the following call in your main() C++ method, before constructing any QQuickWindow:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
    // This line of code should be in the main.cpp file to force OpenGL rendering.
    QQuickWindow::setGraphicsApi(QSGRendererInterface::GraphicsApi::OpenGL);

Export compliance and restrictions on cryptography

When you submit your app to an app store (such as Apple's App Store, Google Play Store, or the Microsoft Apps store) your app may be stored on a server in the United States and is therefore subject to US export laws, regardless of where you or your organization are based. The Bureau of Industry and Security, under the United States Department of Commerce, regulates the export of technology that uses encryption. In some cases, the use of encryption may be considered an export of encryption software, subjecting your app to US export compliance requirements. Because the ArcGIS Maps SDK for Qt uses encryption libraries provided by the underlying operating system, it does not require the declaration of non-exempt encryption when submitted as part of your app.

It is the responsibility of the app developer (and publisher) to make sure that an app complies with all applicable laws and regulations.

The following links provide more information about US export compliance and restrictions on cryptography:

• Export Administration Regulations (EAR)
• Apple Developer: Complying with Encryption Export Regulations
• Google Play: US export compliance
• Microsoft: Export restrictions on cryptography

Apple privacy manifest

App Store requirements dictate that all applications must include a privacy manifest starting May 1, 2024. Importantly, third-party SDKs used in the app (such as ArcGIS Maps SDK for Qt) must also provide a privacy manifest. Starting with version 200.4, Esri delivers a PrivacyInfo.xcprivacy file in the Qt macOS setup at the following location: ArcGIS_SDKs/Qt200.4.0/sdk/iOS/PrivacyInfo.xcprivacy.

Once installed, there are additional required steps you must take to add the privacy manifest to your application, as it will not be picked up automatically.

Starting from Qt Creator, run qmake or CMake on your application and open the generated Xcode project in Xcode 15 or later. Once the project is opened in Xcode, drag and drop the PrivacyInfo.xcprivacy into the project, as shown below:

Then, take the default options, as shown below:

Note that you need to provide a privacy manifest for any other third-party SDKs in your application, including the Qt framework itself.

At this point, you can continue with the typical App Store submission process.

Deploying to the Apple AppStore using MFi Accessories

The Apple AppStore has guidelines and restrictions for apps that communicate with MFi accessories (for example an external GPS receiver). Apps that use NMEA data need to satisfy the Apple requirements to be accepted in the store. Apps need to declare support via PPID in their submission and the MFi provider needs to list the bundle ID so Apple can cross-reference it. For more information see Apple's MFi Program site.