Add StreetMap Premium data

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
        // ArcGIS Runtime license string.
        let myRuntimeLicenseKey = LicenseKey("runtimelite,1000,rudxxxxxxxxx,28-feb-2019,xxxxxxxxxxxxxxxxxxxx")!

        // Extension license strings for various StreetMap Premium areas.
        let smpNorthAmerica = LicenseKey("runtimesmpna,1000,rudxxxxxxxxx,13-mar-2023,xxxxxxxxxxxxxxxxxxxx")!
        let smpLatinAmerica = LicenseKey("runtimesmpla,1000,rudxxxxxxxxx,13-mar-2023,xxxxxxxxxxxxxxxxxxxx")!
        let smpEurope = LicenseKey("runtimesmpe,1000,rudxxxxxxxxx,16-dec-2023,xxxxxxxxxxxxxxxxxxxx")!

        // Sets the ArcGIS Runtime license string and the three StreetMap Premium area license strings.
        do {
            result = try ArcGISEnvironment.setLicense(
                with: myRuntimeLicenseKey,
                extensions: [smpEurope, smpLatinAmerica, smpNorthAmerica]
            )
            print("Licensed SMP extensions")
        } catch {
            print(error)
        }

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
        // ... code here to read license strings from a text file into an array of strings ...
        // The variable to store the (one) ArcGIS Runtime license string.
        var runtimeLicense = ""
        // The variable to store the extension license string (all others in the file).
        var extensionLicenses = [""]
        // Loops through all license strings from the file.
        for licenseString in licenseStrings {
            if licenseString.starts(with: "runtimelite") ||
                licenseString.starts(with: "runtimebasic") ||
                licenseString.starts(with: "runtimestandard") ||
                licenseString.starts(with: "runtimeadvanced") {
                runtimeLicense = licenseString
            } else {
                extensionLicenses.append(licenseString)
            }
        }
        guard let extensions = extensionLicenses as? [LicenseKey] else { return }
        // Sets the licenses before using any ArcGIS API objects.
        do {
            result = try ArcGISEnvironment.setLicense(
                with: LicenseKey(runtimeLicense)!,
                extensions: extensions
            )
            print("Licensed SMP extensions")
        } catch {
            print(error)
        }

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
        // Gets the licensing info for the current app.
        let licenseInfo = ArcGISEnvironment.license
        // Gets all extension licenses.
        let extensionLicenses = licenseInfo.extensions
        // Loops through extension licenses and see when each expires.
        for extensionLicense in extensionLicenses {
            extensionName = extensionLicense.name
            // Gets the expiry date.
            let expiryDate = extensionLicense.expirationDate
            // Gets the number of days until the license expires.
            if let days = Calendar.current.dateComponents([.day], from: expiryDate, to: .now).day {
                // If within 10 days of expiration, notify the user.
                if days <= 10 {
                    print("Warning: License will expire in \(days) days")
                }
            }
        }

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
        let fileURL = URL(string: "IndianaMobileMapPackageURL")!
        // Opens a StreetMap Premium mobile map package.
        let indianaPackage = MobileMapPackage(fileURL: fileURL)

        // Gets the first map.
        let map = indianaPackage.maps.first

        // Adds the map to the map view.
        // ...

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
        // Gets the locator task for this area.
        let locatorTask = indianaPackage.locatorTask

        // Gets geocode candidates.
        do {
            geocodeResults = try await locatorTask?.geocode(forSearchText: "Indianapolis Motor Speedway")
            // Process the results.
        } catch {
            print(error)
        }

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
        // Gets the (first and only) street network dataset from one of the maps in the package.
        guard let streetNetwork = map.transportationNetworks.first else { return }
        // Creates a new route task that uses the street network.
        let routeTask = RouteTask(dataset: streetNetwork)
        // Gets the default route parameters from the task and solve the route.
        // ...