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
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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
// ArArcGIS Maps SDKs for Native Apps license string
var myNativeLiteLicenseKey = "nativelite,3000,rudxxxxxxxxx,day-month-year,xxxxxxxxxxxxxxxxxxxx";

// Extension license strings for various StreetMap Premium areas

var smpNorthAmerica = "nativesmpna,3000,rudxxxxxxxxx,day-month-year,xxxxxxxxxxxxxxxxxxxx";
var smpLatinAmerica = "nativesmpla,3000,rudxxxxxxxxx,day-month-year,xxxxxxxxxxxxxxxxxxxx";
var smpEurope = "nativesmpe,3000,rudxxxxxxxxx,day-month-year,xxxxxxxxxxxxxxxxxxxx";

// Add StreetMap Premium license strings to an array
string[] extensions = { smpNorthAmerica, smpLatinAmerica, smpEurope };

// Set the license for ArcGIS Maps SDKs for Native Apps and the three extensions (areas)
ArcGISRuntimeEnvironment.SetLicense(myNativeLiteLicenseKey, extensions);

// Initialize the ArcGIS Runtime Environment before any components are created
ArcGISRuntimeEnvironment.Initialize();

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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
// ... code here to read license strings from a text file into an array of strings ...

// Variable to store the (one) ArcGIS Maps SDKs for Native Apps license string
var nativeLicense = string.Empty;

// Variable to store the extension license strings (all others in the file)
var extensionLicenses = new List<string>();

// Loop through all license strings from the file
foreach(var s in licenseStrings)
{
    // See if it's an ArcGIS Maps SDKs for Native Apps license string
    if(s.StartsWith("nativelite") ||
        s.StartsWith("nativebasic") ||
        s.StartsWith("nativestandard") ||
        s.StartsWith("nativeadvanced"))
    {
        // Store the key
        nativeLicense = s;
    }
    else
    {
        // All other keys are added to the list of extension licenses
        extensionLicenses.Add(s);
    }
}

// Set the licenses before using any ArcGIS Maps SDKs for Native Apps objects
ArcGISRuntimeEnvironment.SetLicense(nativeLicense, extensionLicenses.ToArray());

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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
// Get the licensing info for the current app
Esri.ArcGISRuntime.License licenseInfo = ArcGISRuntimeEnvironment.GetLicense();

// Get all extension licenses
IEnumerable<ExtensionLicense> extLicenses = licenseInfo.Extensions;

// Loop through extension licenses and see when each expires
foreach (ExtensionLicense ext in extLicenses)
{
    // Get license name ("runtimesmpna", e.g.) and expiration date
    var licenseName = ext.Name;
    DateTimeOffset expires = ext.Expiry;

    // Get the number of days until the license expires
    var daysUntilExpired = expires.Subtract(DateTimeOffset.Now).Days;

    // If within 10 days of expiration, notify the user
    if(daysUntilExpired <= 10)
    {
        // ... warn that  will expire in  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
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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
// Open a StreetMap Premium mobile map package
MobileMapPackage indianaPackage = await MobileMapPackage.OpenAsync(MapPackagePath);

// Get the first map
Map navigationMap = indianaPackage.Maps[0];

// Add it to the map view
MyMapView.Map = navigationMap;

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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
// Open a StreetMap Premium mobile map package
MobileMapPackage indianaPackage = await MobileMapPackage.OpenAsync(MapPackagePath);

// Get the locator task for this area
LocatorTask locatorTask = indianaPackage.LocatorTask;

// Get geocode candidates
IReadOnlyList<GeocodeResult> candidates = await locatorTask.GeocodeAsync("Indianapolis Motor Speedway");

// Get the candidate with the best score
GeocodeResult match = candidates.OrderByDescending(c => c.Score).FirstOrDefault();

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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
// Get the (first and only) street network dataset from one of the maps in the package
TransportationNetworkDataset streetNetwork = navigationMap.TransportationNetworks[0];

// Create a new route task that uses the street network
RouteTask routeTask = await RouteTask.CreateAsync(streetNetwork);

// Get the default route parameters from the task
RouteParameters defaultRouteParams = await routeTask.CreateDefaultParametersAsync();

// Create two stops and add them to a list
Stop fromStop = new Stop(fromMapPoint);
Stop toStop = new Stop(toMapPoint);

List<Stop> stops = new List<Stop> { fromStop, toStop };

// Clear any existing stops, then set the new ones
defaultRouteParams.ClearStops();
defaultRouteParams.SetStops(stops);

// Solve the route
RouteResult solveRouteResult = await routeTask.SolveRouteAsync(defaultRouteParams);