]> git.proxmox.com Git - rustc.git/blame - vendor/windows-sys-0.28.0/src/Windows/Win32/Devices/Geolocation/mod.rs
projects / rustc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
New upstream version 1.66.0+dfsg1
[rustc.git] / vendor / windows-sys-0.28.0 / src / Windows / Win32 / Devices / Geolocation / mod.rs
CommitLineData
064997fb
FG		 1#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals, clashing_extern_declarations, clippy::all)]
2#[link(name = "windows")]
3extern "system" {}
4pub const BREADCRUMBING_UNSUPPORTED: u32 = 0u32;
5pub const BREADCRUMBING_VERSION_1: u32 = 1u32;
6pub const CivicAddressReport: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 3550378973, data2: 32005, data3: 18104, data4: [135, 33, 128, 207, 3, 95, 87, 215] };
7pub const CivicAddressReportFactory: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 705819692, data2: 16001, data3: 19156, data4: [156, 190, 69, 87, 157, 137, 103, 26] };
8pub const DefaultLocation: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 2340405216, data2: 23767, data3: 18762, data4: [175, 140, 40, 58, 101, 112, 117, 6] };
9pub const DispCivicAddressReport: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
10 data1: 1280928492,
11 data2: 34116,
12 data3: 16514,
13 data4: [186, 159, 235, 10, 125, 142, 101, 198],
14};
15pub const DispLatLongReport: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
16 data1: 2054959735,
17 data2: 36740,
18 data3: 17974,
19 data4: [149, 178, 235, 181, 80, 127, 247, 126],
20};
21pub const GNSS_AGNSSFORMAT_LTO: u32 = 4u32;
22pub const GNSS_AGNSSFORMAT_XTRA1: u32 = 1u32;
23pub const GNSS_AGNSSFORMAT_XTRA2: u32 = 2u32;
24pub const GNSS_AGNSSFORMAT_XTRA3: u32 = 8u32;
25pub const GNSS_AGNSSFORMAT_XTRA3_1: u32 = 16u32;
26pub const GNSS_AGNSSFORMAT_XTRA3_2: u32 = 32u32;
27pub const GNSS_AGNSSFORMAT_XTRA_INT: u32 = 64u32;
28#[repr(C)]
29#[cfg(feature = "Win32_Foundation")]
30pub struct GNSS_AGNSS_INJECT {
31 pub Size: u32,
32 pub Version: u32,
33 pub InjectionType: GNSS_AGNSS_REQUEST_TYPE,
34 pub InjectionStatus: super::super::Foundation::NTSTATUS,
35 pub InjectionDataSize: u32,
36 pub Unused: [u8; 512],
37 pub Anonymous: GNSS_AGNSS_INJECT_0,
38}
39#[cfg(feature = "Win32_Foundation")]
40impl ::core::marker::Copy for GNSS_AGNSS_INJECT {}
41#[cfg(feature = "Win32_Foundation")]
42impl ::core::clone::Clone for GNSS_AGNSS_INJECT {
43 fn clone(&self) -> Self {
44 *self
45 }
46}
47#[repr(C)]
48#[cfg(feature = "Win32_Foundation")]
49pub union GNSS_AGNSS_INJECT_0 {
50 pub Time: GNSS_AGNSS_INJECTTIME,
51 pub Position: GNSS_AGNSS_INJECTPOSITION,
52 pub BlobData: GNSS_AGNSS_INJECTBLOB,
53}
54#[cfg(feature = "Win32_Foundation")]
55impl ::core::marker::Copy for GNSS_AGNSS_INJECT_0 {}
56#[cfg(feature = "Win32_Foundation")]
57impl ::core::clone::Clone for GNSS_AGNSS_INJECT_0 {
58 fn clone(&self) -> Self {
59 *self
60 }
61}
62#[repr(C)]
63pub struct GNSS_AGNSS_INJECTBLOB {
64 pub Size: u32,
65 pub Version: u32,
66 pub BlobOui: u32,
67 pub BlobVersion: u32,
68 pub AgnssFormat: u32,
69 pub BlobSize: u32,
70 pub BlobData: [u8; 1],
71}
72impl ::core::marker::Copy for GNSS_AGNSS_INJECTBLOB {}
73impl ::core::clone::Clone for GNSS_AGNSS_INJECTBLOB {
74 fn clone(&self) -> Self {
75 *self
76 }
77}
78#[repr(C)]
79pub struct GNSS_AGNSS_INJECTPOSITION {
80 pub Size: u32,
81 pub Version: u32,
82 pub Age: u32,
83 pub BasicData: GNSS_FIXDATA_BASIC,
84 pub AccuracyData: GNSS_FIXDATA_ACCURACY,
85}
86impl ::core::marker::Copy for GNSS_AGNSS_INJECTPOSITION {}
87impl ::core::clone::Clone for GNSS_AGNSS_INJECTPOSITION {
88 fn clone(&self) -> Self {
89 *self
90 }
91}
92#[repr(C)]
93#[cfg(feature = "Win32_Foundation")]
94pub struct GNSS_AGNSS_INJECTTIME {
95 pub Size: u32,
96 pub Version: u32,
97 pub UtcTime: super::super::Foundation::FILETIME,
98 pub TimeUncertainty: u32,
99}
100#[cfg(feature = "Win32_Foundation")]
101impl ::core::marker::Copy for GNSS_AGNSS_INJECTTIME {}
102#[cfg(feature = "Win32_Foundation")]
103impl ::core::clone::Clone for GNSS_AGNSS_INJECTTIME {
104 fn clone(&self) -> Self {
105 *self
106 }
107}
108#[repr(C)]
109pub struct GNSS_AGNSS_REQUEST_PARAM {
110 pub Size: u32,
111 pub Version: u32,
112 pub RequestType: GNSS_AGNSS_REQUEST_TYPE,
113 pub BlobFormat: u32,
114}
115impl ::core::marker::Copy for GNSS_AGNSS_REQUEST_PARAM {}
116impl ::core::clone::Clone for GNSS_AGNSS_REQUEST_PARAM {
117 fn clone(&self) -> Self {
118 *self
119 }
120}
121pub type GNSS_AGNSS_REQUEST_TYPE = i32;
122pub const GNSS_AGNSS_TimeInjection: GNSS_AGNSS_REQUEST_TYPE = 1i32;
123pub const GNSS_AGNSS_PositionInjection: GNSS_AGNSS_REQUEST_TYPE = 2i32;
124pub const GNSS_AGNSS_BlobInjection: GNSS_AGNSS_REQUEST_TYPE = 3i32;
125#[repr(C)]
126pub struct GNSS_BREADCRUMBING_ALERT_DATA {
127 pub Size: u32,
128 pub Version: u32,
129 pub Unused: [u8; 512],
130}
131impl ::core::marker::Copy for GNSS_BREADCRUMBING_ALERT_DATA {}
132impl ::core::clone::Clone for GNSS_BREADCRUMBING_ALERT_DATA {
133 fn clone(&self) -> Self {
134 *self
135 }
136}
137#[repr(C)]
138pub struct GNSS_BREADCRUMBING_PARAM {
139 pub Size: u32,
140 pub Version: u32,
141 pub MaximumHorizontalUncertainty: u32,
142 pub MinDistanceBetweenFixes: u32,
143 pub MaximumErrorTimeoutMs: u32,
144 pub Unused: [u8; 512],
145}
146impl ::core::marker::Copy for GNSS_BREADCRUMBING_PARAM {}
147impl ::core::clone::Clone for GNSS_BREADCRUMBING_PARAM {
148 fn clone(&self) -> Self {
149 *self
150 }
151}
152#[repr(C)]
153#[cfg(feature = "Win32_Foundation")]
154pub struct GNSS_BREADCRUMB_LIST {
155 pub Size: u32,
156 pub Version: u32,
157 pub NumCrumbs: u32,
158 pub Anonymous: GNSS_BREADCRUMB_LIST_0,
159}
160#[cfg(feature = "Win32_Foundation")]
161impl ::core::marker::Copy for GNSS_BREADCRUMB_LIST {}
162#[cfg(feature = "Win32_Foundation")]
163impl ::core::clone::Clone for GNSS_BREADCRUMB_LIST {
164 fn clone(&self) -> Self {
165 *self
166 }
167}
168#[repr(C)]
169#[cfg(feature = "Win32_Foundation")]
170pub union GNSS_BREADCRUMB_LIST_0 {
171 pub v1: [GNSS_BREADCRUMB_V1; 50],
172}
173#[cfg(feature = "Win32_Foundation")]
174impl ::core::marker::Copy for GNSS_BREADCRUMB_LIST_0 {}
175#[cfg(feature = "Win32_Foundation")]
176impl ::core::clone::Clone for GNSS_BREADCRUMB_LIST_0 {
177 fn clone(&self) -> Self {
178 *self
179 }
180}
181#[repr(C)]
182#[cfg(feature = "Win32_Foundation")]
183pub struct GNSS_BREADCRUMB_V1 {
184 pub FixTimeStamp: super::super::Foundation::FILETIME,
185 pub Latitude: f64,
186 pub Longitude: f64,
187 pub HorizontalAccuracy: u32,
188 pub Speed: u16,
189 pub SpeedAccuracy: u16,
190 pub Altitude: i16,
191 pub AltitudeAccuracy: u16,
192 pub Heading: i16,
193 pub HeadingAccuracy: u8,
194 pub FixSuccess: u8,
195}
196#[cfg(feature = "Win32_Foundation")]
197impl ::core::marker::Copy for GNSS_BREADCRUMB_V1 {}
198#[cfg(feature = "Win32_Foundation")]
199impl ::core::clone::Clone for GNSS_BREADCRUMB_V1 {
200 fn clone(&self) -> Self {
201 *self
202 }
203}
204#[repr(C)]
205pub struct GNSS_CHIPSETINFO {
206 pub Size: u32,
207 pub Version: u32,
208 pub ManufacturerID: [u16; 25],
209 pub HardwareID: [u16; 25],
210 pub FirmwareVersion: [u16; 20],
211 pub Unused: [u8; 512],
212}
213impl ::core::marker::Copy for GNSS_CHIPSETINFO {}
214impl ::core::clone::Clone for GNSS_CHIPSETINFO {
215 fn clone(&self) -> Self {
216 *self
217 }
218}
219#[repr(C)]
220pub struct GNSS_CONTINUOUSTRACKING_PARAM {
221 pub Size: u32,
222 pub Version: u32,
223 pub PreferredInterval: u32,
224}
225impl ::core::marker::Copy for GNSS_CONTINUOUSTRACKING_PARAM {}
226impl ::core::clone::Clone for GNSS_CONTINUOUSTRACKING_PARAM {
227 fn clone(&self) -> Self {
228 *self
229 }
230}
231#[repr(C)]
232pub struct GNSS_CP_NI_INFO {
233 pub Size: u32,
234 pub Version: u32,
235 pub RequestorId: [u16; 260],
236 pub NotificationText: [u16; 260],
237}
238impl ::core::marker::Copy for GNSS_CP_NI_INFO {}
239impl ::core::clone::Clone for GNSS_CP_NI_INFO {
240 fn clone(&self) -> Self {
241 *self
242 }
243}
244#[repr(C)]
245#[cfg(feature = "Win32_Foundation")]
246pub struct GNSS_CWTESTDATA {
247 pub Size: u32,
248 pub Version: u32,
249 pub TestResultStatus: super::super::Foundation::NTSTATUS,
250 pub SignalToNoiseRatio: f64,
251 pub Frequency: f64,
252 pub Unused: [u8; 512],
253}
254#[cfg(feature = "Win32_Foundation")]
255impl ::core::marker::Copy for GNSS_CWTESTDATA {}
256#[cfg(feature = "Win32_Foundation")]
257impl ::core::clone::Clone for GNSS_CWTESTDATA {
258 fn clone(&self) -> Self {
259 *self
260 }
261}
262#[repr(C)]
263#[cfg(feature = "Win32_Foundation")]
264pub struct GNSS_DEVICE_CAPABILITY {
265 pub Size: u32,
266 pub Version: u32,
267 pub SupportMultipleFixSessions: super::super::Foundation::BOOL,
268 pub SupportMultipleAppSessions: super::super::Foundation::BOOL,
269 pub RequireAGnssInjection: super::super::Foundation::BOOL,
270 pub AgnssFormatSupported: u32,
271 pub AgnssFormatPreferred: u32,
272 pub SupportDistanceTracking: super::super::Foundation::BOOL,
273 pub SupportContinuousTracking: super::super::Foundation::BOOL,
274 pub Reserved1: u32,
275 pub Reserved2: super::super::Foundation::BOOL,
276 pub Reserved3: super::super::Foundation::BOOL,
277 pub Reserved4: super::super::Foundation::BOOL,
278 pub Reserved5: super::super::Foundation::BOOL,
279 pub GeofencingSupport: u32,
280 pub Reserved6: super::super::Foundation::BOOL,
281 pub Reserved7: super::super::Foundation::BOOL,
282 pub SupportCpLocation: super::super::Foundation::BOOL,
283 pub SupportUplV2: super::super::Foundation::BOOL,
284 pub SupportSuplV1: super::super::Foundation::BOOL,
285 pub SupportSuplV2: super::super::Foundation::BOOL,
286 pub SupportedSuplVersion: GNSS_SUPL_VERSION,
287 pub MaxGeofencesSupported: u32,
288 pub SupportMultipleSuplRootCert: super::super::Foundation::BOOL,
289 pub GnssBreadCrumbPayloadVersion: u32,
290 pub MaxGnssBreadCrumbFixes: u32,
291 pub Unused: [u8; 496],
292}
293#[cfg(feature = "Win32_Foundation")]
294impl ::core::marker::Copy for GNSS_DEVICE_CAPABILITY {}
295#[cfg(feature = "Win32_Foundation")]
296impl ::core::clone::Clone for GNSS_DEVICE_CAPABILITY {
297 fn clone(&self) -> Self {
298 *self
299 }
300}
301#[repr(C)]
302pub struct GNSS_DISTANCETRACKING_PARAM {
303 pub Size: u32,
304 pub Version: u32,
305 pub MovementThreshold: u32,
306}
307impl ::core::marker::Copy for GNSS_DISTANCETRACKING_PARAM {}
308impl ::core::clone::Clone for GNSS_DISTANCETRACKING_PARAM {
309 fn clone(&self) -> Self {
310 *self
311 }
312}
313#[repr(C)]
314pub struct GNSS_DRIVERCOMMAND_PARAM {
315 pub Size: u32,
316 pub Version: u32,
317 pub CommandType: GNSS_DRIVERCOMMAND_TYPE,
318 pub Reserved: u32,
319 pub CommandDataSize: u32,
320 pub Unused: [u8; 512],
321 pub CommandData: [u8; 1],
322}
323impl ::core::marker::Copy for GNSS_DRIVERCOMMAND_PARAM {}
324impl ::core::clone::Clone for GNSS_DRIVERCOMMAND_PARAM {
325 fn clone(&self) -> Self {
326 *self
327 }
328}
329pub type GNSS_DRIVERCOMMAND_TYPE = i32;
330pub const GNSS_SetLocationServiceEnabled: GNSS_DRIVERCOMMAND_TYPE = 1i32;
331pub const GNSS_SetLocationNIRequestAllowed: GNSS_DRIVERCOMMAND_TYPE = 2i32;
332pub const GNSS_ForceSatelliteSystem: GNSS_DRIVERCOMMAND_TYPE = 3i32;
333pub const GNSS_ForceOperationMode: GNSS_DRIVERCOMMAND_TYPE = 4i32;
334pub const GNSS_ResetEngine: GNSS_DRIVERCOMMAND_TYPE = 9i32;
335pub const GNSS_ClearAgnssData: GNSS_DRIVERCOMMAND_TYPE = 10i32;
336pub const GNSS_SetSuplVersion: GNSS_DRIVERCOMMAND_TYPE = 12i32;
337pub const GNSS_SetNMEALogging: GNSS_DRIVERCOMMAND_TYPE = 13i32;
338pub const GNSS_SetUplServerAccessInterval: GNSS_DRIVERCOMMAND_TYPE = 14i32;
339pub const GNSS_SetNiTimeoutInterval: GNSS_DRIVERCOMMAND_TYPE = 15i32;
340pub const GNSS_ResetGeofencesTracking: GNSS_DRIVERCOMMAND_TYPE = 16i32;
341pub const GNSS_SetSuplVersion2: GNSS_DRIVERCOMMAND_TYPE = 17i32;
342pub const GNSS_CustomCommand: GNSS_DRIVERCOMMAND_TYPE = 256i32;
343pub type GNSS_DRIVER_REQUEST = i32;
344pub const SUPL_CONFIG_DATA: GNSS_DRIVER_REQUEST = 1i32;
345#[repr(C)]
346pub struct GNSS_DRIVER_REQUEST_DATA {
347 pub Size: u32,
348 pub Version: u32,
349 pub Request: GNSS_DRIVER_REQUEST,
350 pub RequestFlag: u32,
351}
352impl ::core::marker::Copy for GNSS_DRIVER_REQUEST_DATA {}
353impl ::core::clone::Clone for GNSS_DRIVER_REQUEST_DATA {
354 fn clone(&self) -> Self {
355 *self
356 }
357}
358pub const GNSS_DRIVER_VERSION_1: u32 = 1u32;
359pub const GNSS_DRIVER_VERSION_2: u32 = 2u32;
360pub const GNSS_DRIVER_VERSION_3: u32 = 3u32;
361pub const GNSS_DRIVER_VERSION_4: u32 = 4u32;
362pub const GNSS_DRIVER_VERSION_5: u32 = 5u32;
363pub const GNSS_DRIVER_VERSION_6: u32 = 6u32;
364#[repr(C)]
365#[cfg(feature = "Win32_Foundation")]
366pub struct GNSS_ERRORINFO {
367 pub Size: u32,
368 pub Version: u32,
369 pub ErrorCode: u32,
370 pub IsRecoverable: super::super::Foundation::BOOL,
371 pub ErrorDescription: [u16; 256],
372 pub Unused: [u8; 512],
373}
374#[cfg(feature = "Win32_Foundation")]
375impl ::core::marker::Copy for GNSS_ERRORINFO {}
376#[cfg(feature = "Win32_Foundation")]
377impl ::core::clone::Clone for GNSS_ERRORINFO {
378 fn clone(&self) -> Self {
379 *self
380 }
381}
382#[repr(C)]
383#[cfg(feature = "Win32_Foundation")]
384pub struct GNSS_EVENT {
385 pub Size: u32,
386 pub Version: u32,
387 pub EventType: GNSS_EVENT_TYPE,
388 pub EventDataSize: u32,
389 pub Unused: [u8; 512],
390 pub Anonymous: GNSS_EVENT_0,
391}
392#[cfg(feature = "Win32_Foundation")]
393impl ::core::marker::Copy for GNSS_EVENT {}
394#[cfg(feature = "Win32_Foundation")]
395impl ::core::clone::Clone for GNSS_EVENT {
396 fn clone(&self) -> Self {
397 *self
398 }
399}
400#[repr(C)]
401#[cfg(feature = "Win32_Foundation")]
402pub union GNSS_EVENT_0 {
403 pub FixData: GNSS_FIXDATA,
404 pub AgnssRequest: GNSS_AGNSS_REQUEST_PARAM,
405 pub NiRequest: GNSS_NI_REQUEST_PARAM,
406 pub ErrorInformation: GNSS_ERRORINFO,
407 pub NmeaData: GNSS_NMEA_DATA,
408 pub GeofenceAlertData: GNSS_GEOFENCE_ALERT_DATA,
409 pub BreadcrumbAlertData: GNSS_BREADCRUMBING_ALERT_DATA,
410 pub GeofencesTrackingStatus: GNSS_GEOFENCES_TRACKINGSTATUS_DATA,
411 pub DriverRequestData: GNSS_DRIVER_REQUEST_DATA,
412 pub CustomData: [u8; 1],
413}
414#[cfg(feature = "Win32_Foundation")]
415impl ::core::marker::Copy for GNSS_EVENT_0 {}
416#[cfg(feature = "Win32_Foundation")]
417impl ::core::clone::Clone for GNSS_EVENT_0 {
418 fn clone(&self) -> Self {
419 *self
420 }
421}
422#[repr(C)]
423#[cfg(feature = "Win32_Foundation")]
424pub struct GNSS_EVENT_2 {
425 pub Size: u32,
426 pub Version: u32,
427 pub EventType: GNSS_EVENT_TYPE,
428 pub EventDataSize: u32,
429 pub Unused: [u8; 512],
430 pub Anonymous: GNSS_EVENT_2_0,
431}
432#[cfg(feature = "Win32_Foundation")]
433impl ::core::marker::Copy for GNSS_EVENT_2 {}
434#[cfg(feature = "Win32_Foundation")]
435impl ::core::clone::Clone for GNSS_EVENT_2 {
436 fn clone(&self) -> Self {
437 *self
438 }
439}
440#[repr(C)]
441#[cfg(feature = "Win32_Foundation")]
442pub union GNSS_EVENT_2_0 {
443 pub FixData: GNSS_FIXDATA,
444 pub FixData2: GNSS_FIXDATA_2,
445 pub AgnssRequest: GNSS_AGNSS_REQUEST_PARAM,
446 pub NiRequest: GNSS_NI_REQUEST_PARAM,
447 pub ErrorInformation: GNSS_ERRORINFO,
448 pub NmeaData: GNSS_NMEA_DATA,
449 pub GeofenceAlertData: GNSS_GEOFENCE_ALERT_DATA,
450 pub BreadcrumbAlertData: GNSS_BREADCRUMBING_ALERT_DATA,
451 pub GeofencesTrackingStatus: GNSS_GEOFENCES_TRACKINGSTATUS_DATA,
452 pub DriverRequestData: GNSS_DRIVER_REQUEST_DATA,
453 pub CustomData: [u8; 1],
454}
455#[cfg(feature = "Win32_Foundation")]
456impl ::core::marker::Copy for GNSS_EVENT_2_0 {}
457#[cfg(feature = "Win32_Foundation")]
458impl ::core::clone::Clone for GNSS_EVENT_2_0 {
459 fn clone(&self) -> Self {
460 *self
461 }
462}
463pub type GNSS_EVENT_TYPE = i32;
464pub const GNSS_Event_FixAvailable: GNSS_EVENT_TYPE = 1i32;
465pub const GNSS_Event_RequireAgnss: GNSS_EVENT_TYPE = 2i32;
466pub const GNSS_Event_Error: GNSS_EVENT_TYPE = 3i32;
467pub const GNSS_Event_NiRequest: GNSS_EVENT_TYPE = 12i32;
468pub const GNSS_Event_NmeaData: GNSS_EVENT_TYPE = 13i32;
469pub const GNSS_Event_GeofenceAlertData: GNSS_EVENT_TYPE = 14i32;
470pub const GNSS_Event_GeofencesTrackingStatus: GNSS_EVENT_TYPE = 15i32;
471pub const GNSS_Event_DriverRequest: GNSS_EVENT_TYPE = 16i32;
472pub const GNSS_Event_BreadcrumbAlertEvent: GNSS_EVENT_TYPE = 17i32;
473pub const GNSS_Event_FixAvailable_2: GNSS_EVENT_TYPE = 18i32;
474pub const GNSS_Event_Custom: GNSS_EVENT_TYPE = 32768i32;
475#[repr(C)]
476#[cfg(feature = "Win32_Foundation")]
477pub struct GNSS_FIXDATA {
478 pub Size: u32,
479 pub Version: u32,
480 pub FixSessionID: u32,
481 pub FixTimeStamp: super::super::Foundation::FILETIME,
482 pub IsFinalFix: super::super::Foundation::BOOL,
483 pub FixStatus: super::super::Foundation::NTSTATUS,
484 pub FixLevelOfDetails: u32,
485 pub BasicData: GNSS_FIXDATA_BASIC,
486 pub AccuracyData: GNSS_FIXDATA_ACCURACY,
487 pub SatelliteData: GNSS_FIXDATA_SATELLITE,
488}
489#[cfg(feature = "Win32_Foundation")]
490impl ::core::marker::Copy for GNSS_FIXDATA {}
491#[cfg(feature = "Win32_Foundation")]
492impl ::core::clone::Clone for GNSS_FIXDATA {
493 fn clone(&self) -> Self {
494 *self
495 }
496}
497#[repr(C)]
498#[cfg(feature = "Win32_Foundation")]
499pub struct GNSS_FIXDATA_2 {
500 pub Size: u32,
501 pub Version: u32,
502 pub FixSessionID: u32,
503 pub FixTimeStamp: super::super::Foundation::FILETIME,
504 pub IsFinalFix: super::super::Foundation::BOOL,
505 pub FixStatus: super::super::Foundation::NTSTATUS,
506 pub FixLevelOfDetails: u32,
507 pub BasicData: GNSS_FIXDATA_BASIC_2,
508 pub AccuracyData: GNSS_FIXDATA_ACCURACY_2,
509 pub SatelliteData: GNSS_FIXDATA_SATELLITE,
510}
511#[cfg(feature = "Win32_Foundation")]
512impl ::core::marker::Copy for GNSS_FIXDATA_2 {}
513#[cfg(feature = "Win32_Foundation")]
514impl ::core::clone::Clone for GNSS_FIXDATA_2 {
515 fn clone(&self) -> Self {
516 *self
517 }
518}
519#[repr(C)]
520pub struct GNSS_FIXDATA_ACCURACY {
521 pub Size: u32,
522 pub Version: u32,
523 pub HorizontalAccuracy: u32,
524 pub HorizontalErrorMajorAxis: u32,
525 pub HorizontalErrorMinorAxis: u32,
526 pub HorizontalErrorAngle: u32,
527 pub HeadingAccuracy: u32,
528 pub AltitudeAccuracy: u32,
529 pub SpeedAccuracy: u32,
530 pub HorizontalConfidence: u32,
531 pub HeadingConfidence: u32,
532 pub AltitudeConfidence: u32,
533 pub SpeedConfidence: u32,
534 pub PositionDilutionOfPrecision: f32,
535 pub HorizontalDilutionOfPrecision: f32,
536 pub VerticalDilutionOfPrecision: f32,
537}
538impl ::core::marker::Copy for GNSS_FIXDATA_ACCURACY {}
539impl ::core::clone::Clone for GNSS_FIXDATA_ACCURACY {
540 fn clone(&self) -> Self {
541 *self
542 }
543}
544#[repr(C)]
545pub struct GNSS_FIXDATA_ACCURACY_2 {
546 pub Size: u32,
547 pub Version: u32,
548 pub HorizontalAccuracy: f64,
549 pub HorizontalErrorMajorAxis: f64,
550 pub HorizontalErrorMinorAxis: f64,
551 pub HorizontalErrorAngle: f64,
552 pub HeadingAccuracy: f64,
553 pub AltitudeAccuracy: f64,
554 pub SpeedAccuracy: f64,
555 pub HorizontalConfidence: u32,
556 pub HeadingConfidence: u32,
557 pub AltitudeConfidence: u32,
558 pub SpeedConfidence: u32,
559 pub PositionDilutionOfPrecision: f64,
560 pub HorizontalDilutionOfPrecision: f64,
561 pub VerticalDilutionOfPrecision: f64,
562 pub GeometricDilutionOfPrecision: f64,
563 pub TimeDilutionOfPrecision: f64,
564}
565impl ::core::marker::Copy for GNSS_FIXDATA_ACCURACY_2 {}
566impl ::core::clone::Clone for GNSS_FIXDATA_ACCURACY_2 {
567 fn clone(&self) -> Self {
568 *self
569 }
570}
571#[repr(C)]
572pub struct GNSS_FIXDATA_BASIC {
573 pub Size: u32,
574 pub Version: u32,
575 pub Latitude: f64,
576 pub Longitude: f64,
577 pub Altitude: f64,
578 pub Speed: f64,
579 pub Heading: f64,
580}
581impl ::core::marker::Copy for GNSS_FIXDATA_BASIC {}
582impl ::core::clone::Clone for GNSS_FIXDATA_BASIC {
583 fn clone(&self) -> Self {
584 *self
585 }
586}
587#[repr(C)]
588pub struct GNSS_FIXDATA_BASIC_2 {
589 pub Size: u32,
590 pub Version: u32,
591 pub Latitude: f64,
592 pub Longitude: f64,
593 pub Altitude: f64,
594 pub Speed: f64,
595 pub Heading: f64,
596 pub AltitudeEllipsoid: f64,
597}
598impl ::core::marker::Copy for GNSS_FIXDATA_BASIC_2 {}
599impl ::core::clone::Clone for GNSS_FIXDATA_BASIC_2 {
600 fn clone(&self) -> Self {
601 *self
602 }
603}
604#[repr(C)]
605#[cfg(feature = "Win32_Foundation")]
606pub struct GNSS_FIXDATA_SATELLITE {
607 pub Size: u32,
608 pub Version: u32,
609 pub SatelliteCount: u32,
610 pub SatelliteArray: [GNSS_SATELLITEINFO; 64],
611}
612#[cfg(feature = "Win32_Foundation")]
613impl ::core::marker::Copy for GNSS_FIXDATA_SATELLITE {}
614#[cfg(feature = "Win32_Foundation")]
615impl ::core::clone::Clone for GNSS_FIXDATA_SATELLITE {
616 fn clone(&self) -> Self {
617 *self
618 }
619}
620pub const GNSS_FIXDETAIL_ACCURACY: u32 = 2u32;
621pub const GNSS_FIXDETAIL_BASIC: u32 = 1u32;
622pub const GNSS_FIXDETAIL_SATELLITE: u32 = 4u32;
623pub type GNSS_FIXSESSIONTYPE = i32;
624pub const GNSS_FixSession_SingleShot: GNSS_FIXSESSIONTYPE = 1i32;
625pub const GNSS_FixSession_DistanceTracking: GNSS_FIXSESSIONTYPE = 2i32;
626pub const GNSS_FixSession_ContinuousTracking: GNSS_FIXSESSIONTYPE = 3i32;
627pub const GNSS_FixSession_LKG: GNSS_FIXSESSIONTYPE = 4i32;
628#[repr(C)]
629pub struct GNSS_FIXSESSION_PARAM {
630 pub Size: u32,
631 pub Version: u32,
632 pub FixSessionID: u32,
633 pub SessionType: GNSS_FIXSESSIONTYPE,
634 pub HorizontalAccuracy: u32,
635 pub HorizontalConfidence: u32,
636 pub Reserved: [u32; 9],
637 pub FixLevelOfDetails: u32,
638 pub Anonymous: GNSS_FIXSESSION_PARAM_0,
639 pub Unused: [u8; 256],
640}
641impl ::core::marker::Copy for GNSS_FIXSESSION_PARAM {}
642impl ::core::clone::Clone for GNSS_FIXSESSION_PARAM {
643 fn clone(&self) -> Self {
644 *self
645 }
646}
647#[repr(C)]
648pub union GNSS_FIXSESSION_PARAM_0 {
649 pub SingleShotParam: GNSS_SINGLESHOT_PARAM,
650 pub DistanceParam: GNSS_DISTANCETRACKING_PARAM,
651 pub ContinuousParam: GNSS_CONTINUOUSTRACKING_PARAM,
652 pub LkgFixParam: GNSS_LKGFIX_PARAM,
653 pub UnusedParam: [u8; 268],
654}
655impl ::core::marker::Copy for GNSS_FIXSESSION_PARAM_0 {}
656impl ::core::clone::Clone for GNSS_FIXSESSION_PARAM_0 {
657 fn clone(&self) -> Self {
658 *self
659 }
660}
661pub const GNSS_GEOFENCESUPPORT_CIRCLE: u32 = 2u32;
662pub const GNSS_GEOFENCESUPPORT_SUPPORTED: u32 = 1u32;
663#[repr(C)]
664#[cfg(feature = "Win32_Foundation")]
665pub struct GNSS_GEOFENCES_TRACKINGSTATUS_DATA {
666 pub Size: u32,
667 pub Version: u32,
668 pub Status: super::super::Foundation::NTSTATUS,
669 pub StatusTimeStamp: super::super::Foundation::FILETIME,
670 pub Unused: [u8; 512],
671}
672#[cfg(feature = "Win32_Foundation")]
673impl ::core::marker::Copy for GNSS_GEOFENCES_TRACKINGSTATUS_DATA {}
674#[cfg(feature = "Win32_Foundation")]
675impl ::core::clone::Clone for GNSS_GEOFENCES_TRACKINGSTATUS_DATA {
676 fn clone(&self) -> Self {
677 *self
678 }
679}
680#[repr(C)]
681pub struct GNSS_GEOFENCE_ALERT_DATA {
682 pub Size: u32,
683 pub Version: u32,
684 pub GeofenceID: u32,
685 pub GeofenceState: GNSS_GEOFENCE_STATE,
686 pub FixBasicData: GNSS_FIXDATA_BASIC,
687 pub FixAccuracyData: GNSS_FIXDATA_ACCURACY,
688 pub Unused: [u8; 512],
689}
690impl ::core::marker::Copy for GNSS_GEOFENCE_ALERT_DATA {}
691impl ::core::clone::Clone for GNSS_GEOFENCE_ALERT_DATA {
692 fn clone(&self) -> Self {
693 *self
694 }
695}
696#[repr(C)]
697pub struct GNSS_GEOFENCE_CREATE_PARAM {
698 pub Size: u32,
699 pub Version: u32,
700 pub AlertTypes: u32,
701 pub InitialState: GNSS_GEOFENCE_STATE,
702 pub Boundary: GNSS_GEOREGION,
703 pub Unused: [u8; 512],
704}
705impl ::core::marker::Copy for GNSS_GEOFENCE_CREATE_PARAM {}
706impl ::core::clone::Clone for GNSS_GEOFENCE_CREATE_PARAM {
707 fn clone(&self) -> Self {
708 *self
709 }
710}
711#[repr(C)]
712#[cfg(feature = "Win32_Foundation")]
713pub struct GNSS_GEOFENCE_CREATE_RESPONSE {
714 pub Size: u32,
715 pub Version: u32,
716 pub CreationStatus: super::super::Foundation::NTSTATUS,
717 pub GeofenceID: u32,
718 pub Unused: [u8; 512],
719}
720#[cfg(feature = "Win32_Foundation")]
721impl ::core::marker::Copy for GNSS_GEOFENCE_CREATE_RESPONSE {}
722#[cfg(feature = "Win32_Foundation")]
723impl ::core::clone::Clone for GNSS_GEOFENCE_CREATE_RESPONSE {
724 fn clone(&self) -> Self {
725 *self
726 }
727}
728#[repr(C)]
729pub struct GNSS_GEOFENCE_DELETE_PARAM {
730 pub Size: u32,
731 pub Version: u32,
732 pub GeofenceID: u32,
733 pub Unused: [u8; 512],
734}
735impl ::core::marker::Copy for GNSS_GEOFENCE_DELETE_PARAM {}
736impl ::core::clone::Clone for GNSS_GEOFENCE_DELETE_PARAM {
737 fn clone(&self) -> Self {
738 *self
739 }
740}
741pub type GNSS_GEOFENCE_STATE = i32;
742pub const GNSS_GeofenceState_Unknown: GNSS_GEOFENCE_STATE = 0i32;
743pub const GNSS_GeofenceState_Entered: GNSS_GEOFENCE_STATE = 1i32;
744pub const GNSS_GeofenceState_Exited: GNSS_GEOFENCE_STATE = 2i32;
745#[repr(C)]
746pub struct GNSS_GEOREGION {
747 pub Size: u32,
748 pub Version: u32,
749 pub GeoRegionType: GNSS_GEOREGIONTYPE,
750 pub Anonymous: GNSS_GEOREGION_0,
751}
752impl ::core::marker::Copy for GNSS_GEOREGION {}
753impl ::core::clone::Clone for GNSS_GEOREGION {
754 fn clone(&self) -> Self {
755 *self
756 }
757}
758#[repr(C)]
759pub union GNSS_GEOREGION_0 {
760 pub Circle: GNSS_GEOREGION_CIRCLE,
761 pub Unused: [u8; 512],
762}
763impl ::core::marker::Copy for GNSS_GEOREGION_0 {}
764impl ::core::clone::Clone for GNSS_GEOREGION_0 {
765 fn clone(&self) -> Self {
766 *self
767 }
768}
769pub type GNSS_GEOREGIONTYPE = i32;
770pub const GNSS_GeoRegion_Circle: GNSS_GEOREGIONTYPE = 1i32;
771#[repr(C)]
772pub struct GNSS_GEOREGION_CIRCLE {
773 pub Latitude: f64,
774 pub Longitude: f64,
775 pub RadiusInMeters: f64,
776}
777impl ::core::marker::Copy for GNSS_GEOREGION_CIRCLE {}
778impl ::core::clone::Clone for GNSS_GEOREGION_CIRCLE {
779 fn clone(&self) -> Self {
780 *self
781 }
782}
783#[repr(C)]
784pub struct GNSS_LKGFIX_PARAM {
785 pub Size: u32,
786 pub Version: u32,
787}
788impl ::core::marker::Copy for GNSS_LKGFIX_PARAM {}
789impl ::core::clone::Clone for GNSS_LKGFIX_PARAM {
790 fn clone(&self) -> Self {
791 *self
792 }
793}
794pub const GNSS_MAXSATELLITE: u32 = 64u32;
795pub type GNSS_NI_NOTIFICATION_TYPE = i32;
796pub const GNSS_NI_NoNotifyNoVerify: GNSS_NI_NOTIFICATION_TYPE = 1i32;
797pub const GNSS_NI_NotifyOnly: GNSS_NI_NOTIFICATION_TYPE = 2i32;
798pub const GNSS_NI_NotifyVerifyDefaultAllow: GNSS_NI_NOTIFICATION_TYPE = 3i32;
799pub const GNSS_NI_NotifyVerifyDefaultNotAllow: GNSS_NI_NOTIFICATION_TYPE = 4i32;
800pub const GNSS_NI_PrivacyOverride: GNSS_NI_NOTIFICATION_TYPE = 5i32;
801pub type GNSS_NI_PLANE_TYPE = i32;
802pub const GNSS_NI_SUPL: GNSS_NI_PLANE_TYPE = 1i32;
803pub const GNSS_NI_CP: GNSS_NI_PLANE_TYPE = 2i32;
804pub const GNSS_NI_V2UPL: GNSS_NI_PLANE_TYPE = 3i32;
805#[repr(C)]
806#[cfg(feature = "Win32_Foundation")]
807pub struct GNSS_NI_REQUEST_PARAM {
808 pub Size: u32,
809 pub Version: u32,
810 pub RequestId: u32,
811 pub RequestType: GNSS_NI_REQUEST_TYPE,
812 pub NotificationType: GNSS_NI_NOTIFICATION_TYPE,
813 pub RequestPlaneType: GNSS_NI_PLANE_TYPE,
814 pub Anonymous: GNSS_NI_REQUEST_PARAM_0,
815 pub ResponseTimeInSec: u32,
816 pub EmergencyLocation: super::super::Foundation::BOOL,
817}
818#[cfg(feature = "Win32_Foundation")]
819impl ::core::marker::Copy for GNSS_NI_REQUEST_PARAM {}
820#[cfg(feature = "Win32_Foundation")]
821impl ::core::clone::Clone for GNSS_NI_REQUEST_PARAM {
822 fn clone(&self) -> Self {
823 *self
824 }
825}
826#[repr(C)]
827#[cfg(feature = "Win32_Foundation")]
828pub union GNSS_NI_REQUEST_PARAM_0 {
829 pub SuplNiInfo: GNSS_SUPL_NI_INFO,
830 pub CpNiInfo: GNSS_CP_NI_INFO,
831 pub V2UplNiInfo: GNSS_V2UPL_NI_INFO,
832}
833#[cfg(feature = "Win32_Foundation")]
834impl ::core::marker::Copy for GNSS_NI_REQUEST_PARAM_0 {}
835#[cfg(feature = "Win32_Foundation")]
836impl ::core::clone::Clone for GNSS_NI_REQUEST_PARAM_0 {
837 fn clone(&self) -> Self {
838 *self
839 }
840}
841pub type GNSS_NI_REQUEST_TYPE = i32;
842pub const GNSS_NI_Request_SingleShot: GNSS_NI_REQUEST_TYPE = 1i32;
843pub const GNSS_NI_Request_AreaTrigger: GNSS_NI_REQUEST_TYPE = 2i32;
844#[repr(C)]
845pub struct GNSS_NI_RESPONSE {
846 pub Size: u32,
847 pub Version: u32,
848 pub RequestId: u32,
849 pub UserResponse: GNSS_NI_USER_RESPONSE,
850}
851impl ::core::marker::Copy for GNSS_NI_RESPONSE {}
852impl ::core::clone::Clone for GNSS_NI_RESPONSE {
853 fn clone(&self) -> Self {
854 *self
855 }
856}
857pub type GNSS_NI_USER_RESPONSE = i32;
858pub const GNSS_Ni_UserResponseAccept: GNSS_NI_USER_RESPONSE = 1i32;
859pub const GNSS_Ni_UserResponseDeny: GNSS_NI_USER_RESPONSE = 2i32;
860pub const GNSS_Ni_UserResponseTimeout: GNSS_NI_USER_RESPONSE = 3i32;
861pub const GNSS_NMEALOGGING_ALL: u32 = 255u32;
862pub const GNSS_NMEALOGGING_NONE: u32 = 0u32;
863#[repr(C)]
864#[cfg(feature = "Win32_Foundation")]
865pub struct GNSS_NMEA_DATA {
866 pub Size: u32,
867 pub Version: u32,
868 pub NmeaSentences: [super::super::Foundation::CHAR; 256],
869}
870#[cfg(feature = "Win32_Foundation")]
871impl ::core::marker::Copy for GNSS_NMEA_DATA {}
872#[cfg(feature = "Win32_Foundation")]
873impl ::core::clone::Clone for GNSS_NMEA_DATA {
874 fn clone(&self) -> Self {
875 *self
876 }
877}
878pub const GNSS_OPERMODE_AFLT: u32 = 16u32;
879pub const GNSS_OPERMODE_ANY: u32 = 0u32;
880pub const GNSS_OPERMODE_CELLID: u32 = 8u32;
881pub const GNSS_OPERMODE_MSA: u32 = 1u32;
882pub const GNSS_OPERMODE_MSB: u32 = 2u32;
883pub const GNSS_OPERMODE_MSS: u32 = 4u32;
884pub const GNSS_OPERMODE_OTDOA: u32 = 32u32;
885#[repr(C)]
886#[cfg(feature = "Win32_Foundation")]
887pub struct GNSS_PLATFORM_CAPABILITY {
888 pub Size: u32,
889 pub Version: u32,
890 pub SupportAgnssInjection: super::super::Foundation::BOOL,
891 pub AgnssFormatSupported: u32,
892 pub Unused: [u8; 516],
893}
894#[cfg(feature = "Win32_Foundation")]
895impl ::core::marker::Copy for GNSS_PLATFORM_CAPABILITY {}
896#[cfg(feature = "Win32_Foundation")]
897impl ::core::clone::Clone for GNSS_PLATFORM_CAPABILITY {
898 fn clone(&self) -> Self {
899 *self
900 }
901}
902#[repr(C)]
903#[cfg(feature = "Win32_Foundation")]
904pub struct GNSS_SATELLITEINFO {
905 pub SatelliteId: u32,
906 pub UsedInPositiong: super::super::Foundation::BOOL,
907 pub Elevation: f64,
908 pub Azimuth: f64,
909 pub SignalToNoiseRatio: f64,
910}
911#[cfg(feature = "Win32_Foundation")]
912impl ::core::marker::Copy for GNSS_SATELLITEINFO {}
913#[cfg(feature = "Win32_Foundation")]
914impl ::core::clone::Clone for GNSS_SATELLITEINFO {
915 fn clone(&self) -> Self {
916 *self
917 }
918}
919pub const GNSS_SATELLITE_ANY: u32 = 0u32;
920pub const GNSS_SATELLITE_BEIDOU: u32 = 4u32;
921pub const GNSS_SATELLITE_GALILEO: u32 = 8u32;
922pub const GNSS_SATELLITE_GLONASS: u32 = 2u32;
923pub const GNSS_SATELLITE_GPS: u32 = 1u32;
924#[repr(C)]
925pub struct GNSS_SELFTESTCONFIG {
926 pub Size: u32,
927 pub Version: u32,
928 pub TestType: u32,
929 pub Unused: [u8; 512],
930 pub InBufLen: u32,
931 pub InBuffer: [u8; 1],
932}
933impl ::core::marker::Copy for GNSS_SELFTESTCONFIG {}
934impl ::core::clone::Clone for GNSS_SELFTESTCONFIG {
935 fn clone(&self) -> Self {
936 *self
937 }
938}
939#[repr(C)]
940#[cfg(feature = "Win32_Foundation")]
941pub struct GNSS_SELFTESTRESULT {
942 pub Size: u32,
943 pub Version: u32,
944 pub TestResultStatus: super::super::Foundation::NTSTATUS,
945 pub Result: u32,
946 pub PinFailedBitMask: u32,
947 pub Unused: [u8; 512],
948 pub OutBufLen: u32,
949 pub OutBuffer: [u8; 1],
950}
951#[cfg(feature = "Win32_Foundation")]
952impl ::core::marker::Copy for GNSS_SELFTESTRESULT {}
953#[cfg(feature = "Win32_Foundation")]
954impl ::core::clone::Clone for GNSS_SELFTESTRESULT {
955 fn clone(&self) -> Self {
956 *self
957 }
958}
959#[repr(C)]
960pub struct GNSS_SINGLESHOT_PARAM {
961 pub Size: u32,
962 pub Version: u32,
963 pub ResponseTime: u32,
964}
965impl ::core::marker::Copy for GNSS_SINGLESHOT_PARAM {}
966impl ::core::clone::Clone for GNSS_SINGLESHOT_PARAM {
967 fn clone(&self) -> Self {
968 *self
969 }
970}
971#[repr(C)]
972pub struct GNSS_STOPFIXSESSION_PARAM {
973 pub Size: u32,
974 pub Version: u32,
975 pub FixSessionID: u32,
976 pub Unused: [u8; 512],
977}
978impl ::core::marker::Copy for GNSS_STOPFIXSESSION_PARAM {}
979impl ::core::clone::Clone for GNSS_STOPFIXSESSION_PARAM {
980 fn clone(&self) -> Self {
981 *self
982 }
983}
984pub type GNSS_SUPL_CERT_ACTION = i32;
985pub const GNSS_Supl_Cert_Inject: GNSS_SUPL_CERT_ACTION = 1i32;
986pub const GNSS_Supl_Cert_Delete: GNSS_SUPL_CERT_ACTION = 2i32;
987pub const GNSS_Supl_Cert_Purge: GNSS_SUPL_CERT_ACTION = 3i32;
988#[repr(C)]
989#[cfg(feature = "Win32_Foundation")]
990pub struct GNSS_SUPL_CERT_CONFIG {
991 pub Size: u32,
992 pub Version: u32,
993 pub CertAction: GNSS_SUPL_CERT_ACTION,
994 pub SuplCertName: [super::super::Foundation::CHAR; 260],
995 pub CertSize: u32,
996 pub Unused: [u8; 512],
997 pub CertData: [u8; 1],
998}
999#[cfg(feature = "Win32_Foundation")]
1000impl ::core::marker::Copy for GNSS_SUPL_CERT_CONFIG {}
1001#[cfg(feature = "Win32_Foundation")]
1002impl ::core::clone::Clone for GNSS_SUPL_CERT_CONFIG {
1003 fn clone(&self) -> Self {
1004 *self
1005 }
1006}
1007#[repr(C)]
1008#[cfg(feature = "Win32_Foundation")]
1009pub struct GNSS_SUPL_HSLP_CONFIG {
1010 pub Size: u32,
1011 pub Version: u32,
1012 pub SuplHslp: [super::super::Foundation::CHAR; 260],
1013 pub SuplHslpFromImsi: [super::super::Foundation::CHAR; 260],
1014 pub Reserved: u32,
1015 pub Unused: [u8; 512],
1016}
1017#[cfg(feature = "Win32_Foundation")]
1018impl ::core::marker::Copy for GNSS_SUPL_HSLP_CONFIG {}
1019#[cfg(feature = "Win32_Foundation")]
1020impl ::core::clone::Clone for GNSS_SUPL_HSLP_CONFIG {
1021 fn clone(&self) -> Self {
1022 *self
1023 }
1024}
1025#[repr(C)]
1026#[cfg(feature = "Win32_Foundation")]
1027pub struct GNSS_SUPL_NI_INFO {
1028 pub Size: u32,
1029 pub Version: u32,
1030 pub RequestorId: [u16; 260],
1031 pub ClientName: [u16; 260],
1032 pub SuplNiUrl: [super::super::Foundation::CHAR; 260],
1033}
1034#[cfg(feature = "Win32_Foundation")]
1035impl ::core::marker::Copy for GNSS_SUPL_NI_INFO {}
1036#[cfg(feature = "Win32_Foundation")]
1037impl ::core::clone::Clone for GNSS_SUPL_NI_INFO {
1038 fn clone(&self) -> Self {
1039 *self
1040 }
1041}
1042#[repr(C)]
1043pub struct GNSS_SUPL_VERSION {
1044 pub MajorVersion: u32,
1045 pub MinorVersion: u32,
1046}
1047impl ::core::marker::Copy for GNSS_SUPL_VERSION {}
1048impl ::core::clone::Clone for GNSS_SUPL_VERSION {
1049 fn clone(&self) -> Self {
1050 *self
1051 }
1052}
1053#[repr(C)]
1054pub struct GNSS_SUPL_VERSION_2 {
1055 pub MajorVersion: u32,
1056 pub MinorVersion: u32,
1057 pub ServiceIndicator: u32,
1058}
1059impl ::core::marker::Copy for GNSS_SUPL_VERSION_2 {}
1060impl ::core::clone::Clone for GNSS_SUPL_VERSION_2 {
1061 fn clone(&self) -> Self {
1062 *self
1063 }
1064}
1065#[repr(C)]
1066#[cfg(feature = "Win32_Foundation")]
1067pub struct GNSS_V2UPL_CONFIG {
1068 pub Size: u32,
1069 pub Version: u32,
1070 pub MPC: [super::super::Foundation::CHAR; 260],
1071 pub PDE: [super::super::Foundation::CHAR; 260],
1072 pub ApplicationTypeIndicator_MR: u8,
1073 pub Unused: [u8; 512],
1074}
1075#[cfg(feature = "Win32_Foundation")]
1076impl ::core::marker::Copy for GNSS_V2UPL_CONFIG {}
1077#[cfg(feature = "Win32_Foundation")]
1078impl ::core::clone::Clone for GNSS_V2UPL_CONFIG {
1079 fn clone(&self) -> Self {
1080 *self
1081 }
1082}
1083#[repr(C)]
1084pub struct GNSS_V2UPL_NI_INFO {
1085 pub Size: u32,
1086 pub Version: u32,
1087 pub RequestorId: [u16; 260],
1088}
1089impl ::core::marker::Copy for GNSS_V2UPL_NI_INFO {}
1090impl ::core::clone::Clone for GNSS_V2UPL_NI_INFO {
1091 fn clone(&self) -> Self {
1092 *self
1093 }
1094}
1095pub const GUID_DEVINTERFACE_GNSS: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 859235812, data2: 394, data3: 18025, data4: [132, 197, 189, 5, 243, 189, 54, 139] };
1096pub type ICivicAddressReport = *mut ::core::ffi::c_void;
1097pub type ICivicAddressReportFactory = *mut ::core::ffi::c_void;
1098pub type IDefaultLocation = *mut ::core::ffi::c_void;
1099pub type IDispCivicAddressReport = *mut ::core::ffi::c_void;
1100pub type IDispLatLongReport = *mut ::core::ffi::c_void;
1101pub type ILatLongReport = *mut ::core::ffi::c_void;
1102pub type ILatLongReportFactory = *mut ::core::ffi::c_void;
1103pub type ILocation = *mut ::core::ffi::c_void;
1104pub type ILocationEvents = *mut ::core::ffi::c_void;
1105pub type ILocationPower = *mut ::core::ffi::c_void;
1106pub type ILocationReport = *mut ::core::ffi::c_void;
1107pub type ILocationReportFactory = *mut ::core::ffi::c_void;
1108pub const IOCTL_GNSS_CONFIG_SUPL_CERT: u32 = 2228488u32;
1109pub const IOCTL_GNSS_CREATE_GEOFENCE: u32 = 2228544u32;
1110pub const IOCTL_GNSS_DELETE_GEOFENCE: u32 = 2228548u32;
1111pub const IOCTL_GNSS_EXECUTE_CWTEST: u32 = 2228496u32;
1112pub const IOCTL_GNSS_EXECUTE_SELFTEST: u32 = 2228500u32;
1113pub const IOCTL_GNSS_GET_CHIPSETINFO: u32 = 2228504u32;
1114pub const IOCTL_GNSS_GET_DEVICE_CAPABILITY: u32 = 2228232u32;
1115pub const IOCTL_GNSS_GET_FIXDATA: u32 = 2228300u32;
1116pub const IOCTL_GNSS_INJECT_AGNSS: u32 = 2228352u32;
1117pub const IOCTL_GNSS_LISTEN_AGNSS: u32 = 2228416u32;
1118pub const IOCTL_GNSS_LISTEN_BREADCRUMBING_ALERT: u32 = 2228680u32;
1119pub const IOCTL_GNSS_LISTEN_DRIVER_REQUEST: u32 = 2228608u32;
1120pub const IOCTL_GNSS_LISTEN_ERROR: u32 = 2228420u32;
1121pub const IOCTL_GNSS_LISTEN_GEOFENCES_TRACKINGSTATUS: u32 = 2228556u32;
1122pub const IOCTL_GNSS_LISTEN_GEOFENCE_ALERT: u32 = 2228552u32;
1123pub const IOCTL_GNSS_LISTEN_NI: u32 = 2228480u32;
1124pub const IOCTL_GNSS_LISTEN_NMEA: u32 = 2228508u32;
1125pub const IOCTL_GNSS_MODIFY_FIXSESSION: u32 = 2228292u32;
1126pub const IOCTL_GNSS_POP_BREADCRUMBS: u32 = 2228684u32;
1127pub const IOCTL_GNSS_RESPOND_NI: u32 = 2228492u32;
1128pub const IOCTL_GNSS_SEND_DRIVERCOMMAND: u32 = 2228236u32;
1129pub const IOCTL_GNSS_SEND_PLATFORM_CAPABILITY: u32 = 2228228u32;
1130pub const IOCTL_GNSS_SET_SUPL_HSLP: u32 = 2228484u32;
1131pub const IOCTL_GNSS_SET_V2UPL_CONFIG: u32 = 2228512u32;
1132pub const IOCTL_GNSS_START_BREADCRUMBING: u32 = 2228672u32;
1133pub const IOCTL_GNSS_START_FIXSESSION: u32 = 2228288u32;
1134pub const IOCTL_GNSS_STOP_BREADCRUMBING: u32 = 2228676u32;
1135pub const IOCTL_GNSS_STOP_FIXSESSION: u32 = 2228296u32;
1136pub const LOCATION_API_VERSION: u32 = 1u32;
1137pub type LOCATION_REPORT_STATUS = i32;
1138pub const REPORT_NOT_SUPPORTED: LOCATION_REPORT_STATUS = 0i32;
1139pub const REPORT_ERROR: LOCATION_REPORT_STATUS = 1i32;
1140pub const REPORT_ACCESS_DENIED: LOCATION_REPORT_STATUS = 2i32;
1141pub const REPORT_INITIALIZING: LOCATION_REPORT_STATUS = 3i32;
1142pub const REPORT_RUNNING: LOCATION_REPORT_STATUS = 4i32;
1143pub const LatLongReport: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 3984703603, data2: 8068, data3: 19624, data4: [161, 97, 24, 60, 119, 107, 198, 81] };
1144pub const LatLongReportFactory: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 2647407816, data2: 34313, data3: 18531, data4: [186, 212, 3, 96, 31, 76, 101, 232] };
1145pub const Location: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
1146 data1: 3854098553,
1147 data2: 61037,
1148 data3: 20019,
1149 data4: [164, 56, 200, 127, 46, 149, 146, 84],
1150};
1151pub const MAX_SERVER_URL_NAME: u32 = 260u32;
1152pub const MIN_BREADCRUMBS_SUPPORTED: u32 = 120u32;
1153pub const MIN_GEOFENCES_REQUIRED: u32 = 100u32;
1154pub type _ICivicAddressReportFactoryEvents = *mut ::core::ffi::c_void;
1155pub type _ILatLongReportFactoryEvents = *mut ::core::ffi::c_void;
backport for Debian buster