1 /*
2  * This file is auto-generated.  DO NOT MODIFY.
3  * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation --structured --version 3 --hash notfrozen -t --stability vintf --min_sdk_version current -pout/soong/.intermediates/hardware/interfaces/common/aidl/android.hardware.common_interface/2/preprocessed.aidl -pout/soong/.intermediates/hardware/interfaces/common/fmq/aidl/android.hardware.common.fmq_interface/1/preprocessed.aidl --previous_api_dir=hardware/interfaces/sensors/aidl/aidl_api/android.hardware.sensors/2 --previous_hash 8cdc9f2ea08fd57e6c60a600fea28a51a2ff12f9 --ninja -d out/soong/.intermediates/hardware/interfaces/sensors/aidl/android.hardware.sensors-V3-ndk-source/gen/staging/android/hardware/sensors/Event.cpp.d -h out/soong/.intermediates/hardware/interfaces/sensors/aidl/android.hardware.sensors-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/hardware/interfaces/sensors/aidl/android.hardware.sensors-V3-ndk-source/gen/staging -Nhardware/interfaces/sensors/aidl hardware/interfaces/sensors/aidl/android/hardware/sensors/Event.aidl
4  *
5  * DO NOT CHECK THIS FILE INTO A CODE TREE (e.g. git, etc..).
6  * ALWAYS GENERATE THIS FILE FROM UPDATED AIDL COMPILER
7  * AS A BUILD INTERMEDIATE ONLY. THIS IS NOT SOURCE CODE.
8  */
9 #pragma once
10 
11 #include <array>
12 #include <cassert>
13 #include <cstdint>
14 #include <memory>
15 #include <optional>
16 #include <string>
17 #include <tuple>
18 #include <type_traits>
19 #include <utility>
20 #include <variant>
21 #include <vector>
22 #include <android/binder_enums.h>
23 #include <android/binder_interface_utils.h>
24 #include <android/binder_parcelable_utils.h>
25 #include <android/binder_to_string.h>
26 #include <aidl/android/hardware/sensors/AdditionalInfo.h>
27 #include <aidl/android/hardware/sensors/DynamicSensorInfo.h>
28 #include <aidl/android/hardware/sensors/Event.h>
29 #include <aidl/android/hardware/sensors/SensorStatus.h>
30 #include <aidl/android/hardware/sensors/SensorType.h>
31 #ifdef BINDER_STABILITY_SUPPORT
32 #include <android/binder_stability.h>
33 #endif  // BINDER_STABILITY_SUPPORT
34 
35 #ifndef __BIONIC__
36 #define __assert2(a,b,c,d) ((void)0)
37 #endif
38 
39 namespace aidl::android::hardware::sensors {
40 class AdditionalInfo;
41 class DynamicSensorInfo;
42 }  // namespace aidl::android::hardware::sensors
43 namespace aidl {
44 namespace android {
45 namespace hardware {
46 namespace sensors {
47 class Event {
48 public:
49   typedef std::true_type fixed_size;
50   static const char* descriptor;
51 
52   class EventPayload {
53   public:
54     typedef std::true_type fixed_size;
55     static const char* descriptor;
56 
57     class Vec4 {
58     public:
59       typedef std::true_type fixed_size;
60       static const char* descriptor;
61 
62       float x __attribute__((aligned (4))) = 0.000000f;
63       float y __attribute__((aligned (4))) = 0.000000f;
64       float z __attribute__((aligned (4))) = 0.000000f;
65       float w __attribute__((aligned (4))) = 0.000000f;
66 
67       binder_status_t readFromParcel(const AParcel* parcel);
68       binder_status_t writeToParcel(AParcel* parcel) const;
69 
70       inline bool operator==(const Vec4& _rhs) const {
71         return std::tie(x, y, z, w) == std::tie(_rhs.x, _rhs.y, _rhs.z, _rhs.w);
72       }
73       inline bool operator<(const Vec4& _rhs) const {
74         return std::tie(x, y, z, w) < std::tie(_rhs.x, _rhs.y, _rhs.z, _rhs.w);
75       }
76       inline bool operator!=(const Vec4& _rhs) const {
77         return !(*this == _rhs);
78       }
79       inline bool operator>(const Vec4& _rhs) const {
80         return _rhs < *this;
81       }
82       inline bool operator>=(const Vec4& _rhs) const {
83         return !(*this < _rhs);
84       }
85       inline bool operator<=(const Vec4& _rhs) const {
86         return !(_rhs < *this);
87       }
88 
89       static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
toString()90       inline std::string toString() const {
91         std::ostringstream _aidl_os;
92         _aidl_os << "Vec4{";
93         _aidl_os << "x: " << ::android::internal::ToString(x);
94         _aidl_os << ", y: " << ::android::internal::ToString(y);
95         _aidl_os << ", z: " << ::android::internal::ToString(z);
96         _aidl_os << ", w: " << ::android::internal::ToString(w);
97         _aidl_os << "}";
98         return _aidl_os.str();
99       }
100     };
101     static_assert(offsetof(Vec4, x) == 0);
102     static_assert(sizeof(float) == 4);
103     static_assert(offsetof(Vec4, y) == 4);
104     static_assert(sizeof(float) == 4);
105     static_assert(offsetof(Vec4, z) == 8);
106     static_assert(sizeof(float) == 4);
107     static_assert(offsetof(Vec4, w) == 12);
108     static_assert(sizeof(float) == 4);
109     static_assert(alignof(Vec4) == 4);
110     static_assert(sizeof(Vec4) == 16);
111     class Vec3 {
112     public:
113       typedef std::true_type fixed_size;
114       static const char* descriptor;
115 
116       float x __attribute__((aligned (4))) = 0.000000f;
117       float y __attribute__((aligned (4))) = 0.000000f;
118       float z __attribute__((aligned (4))) = 0.000000f;
119       ::aidl::android::hardware::sensors::SensorStatus status __attribute__((aligned (1))) = ::aidl::android::hardware::sensors::SensorStatus(0);
120 
121       binder_status_t readFromParcel(const AParcel* parcel);
122       binder_status_t writeToParcel(AParcel* parcel) const;
123 
124       inline bool operator==(const Vec3& _rhs) const {
125         return std::tie(x, y, z, status) == std::tie(_rhs.x, _rhs.y, _rhs.z, _rhs.status);
126       }
127       inline bool operator<(const Vec3& _rhs) const {
128         return std::tie(x, y, z, status) < std::tie(_rhs.x, _rhs.y, _rhs.z, _rhs.status);
129       }
130       inline bool operator!=(const Vec3& _rhs) const {
131         return !(*this == _rhs);
132       }
133       inline bool operator>(const Vec3& _rhs) const {
134         return _rhs < *this;
135       }
136       inline bool operator>=(const Vec3& _rhs) const {
137         return !(*this < _rhs);
138       }
139       inline bool operator<=(const Vec3& _rhs) const {
140         return !(_rhs < *this);
141       }
142 
143       static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
toString()144       inline std::string toString() const {
145         std::ostringstream _aidl_os;
146         _aidl_os << "Vec3{";
147         _aidl_os << "x: " << ::android::internal::ToString(x);
148         _aidl_os << ", y: " << ::android::internal::ToString(y);
149         _aidl_os << ", z: " << ::android::internal::ToString(z);
150         _aidl_os << ", status: " << ::android::internal::ToString(status);
151         _aidl_os << "}";
152         return _aidl_os.str();
153       }
154     };
155     static_assert(offsetof(Vec3, x) == 0);
156     static_assert(sizeof(float) == 4);
157     static_assert(offsetof(Vec3, y) == 4);
158     static_assert(sizeof(float) == 4);
159     static_assert(offsetof(Vec3, z) == 8);
160     static_assert(sizeof(float) == 4);
161     static_assert(offsetof(Vec3, status) == 12);
162     static_assert(sizeof(::aidl::android::hardware::sensors::SensorStatus) == 1);
163     static_assert(alignof(Vec3) == 4);
164     static_assert(sizeof(Vec3) == 16);
165     class Uncal {
166     public:
167       typedef std::true_type fixed_size;
168       static const char* descriptor;
169 
170       float x __attribute__((aligned (4))) = 0.000000f;
171       float y __attribute__((aligned (4))) = 0.000000f;
172       float z __attribute__((aligned (4))) = 0.000000f;
173       float xBias __attribute__((aligned (4))) = 0.000000f;
174       float yBias __attribute__((aligned (4))) = 0.000000f;
175       float zBias __attribute__((aligned (4))) = 0.000000f;
176 
177       binder_status_t readFromParcel(const AParcel* parcel);
178       binder_status_t writeToParcel(AParcel* parcel) const;
179 
180       inline bool operator==(const Uncal& _rhs) const {
181         return std::tie(x, y, z, xBias, yBias, zBias) == std::tie(_rhs.x, _rhs.y, _rhs.z, _rhs.xBias, _rhs.yBias, _rhs.zBias);
182       }
183       inline bool operator<(const Uncal& _rhs) const {
184         return std::tie(x, y, z, xBias, yBias, zBias) < std::tie(_rhs.x, _rhs.y, _rhs.z, _rhs.xBias, _rhs.yBias, _rhs.zBias);
185       }
186       inline bool operator!=(const Uncal& _rhs) const {
187         return !(*this == _rhs);
188       }
189       inline bool operator>(const Uncal& _rhs) const {
190         return _rhs < *this;
191       }
192       inline bool operator>=(const Uncal& _rhs) const {
193         return !(*this < _rhs);
194       }
195       inline bool operator<=(const Uncal& _rhs) const {
196         return !(_rhs < *this);
197       }
198 
199       static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
toString()200       inline std::string toString() const {
201         std::ostringstream _aidl_os;
202         _aidl_os << "Uncal{";
203         _aidl_os << "x: " << ::android::internal::ToString(x);
204         _aidl_os << ", y: " << ::android::internal::ToString(y);
205         _aidl_os << ", z: " << ::android::internal::ToString(z);
206         _aidl_os << ", xBias: " << ::android::internal::ToString(xBias);
207         _aidl_os << ", yBias: " << ::android::internal::ToString(yBias);
208         _aidl_os << ", zBias: " << ::android::internal::ToString(zBias);
209         _aidl_os << "}";
210         return _aidl_os.str();
211       }
212     };
213     static_assert(offsetof(Uncal, x) == 0);
214     static_assert(sizeof(float) == 4);
215     static_assert(offsetof(Uncal, y) == 4);
216     static_assert(sizeof(float) == 4);
217     static_assert(offsetof(Uncal, z) == 8);
218     static_assert(sizeof(float) == 4);
219     static_assert(offsetof(Uncal, xBias) == 12);
220     static_assert(sizeof(float) == 4);
221     static_assert(offsetof(Uncal, yBias) == 16);
222     static_assert(sizeof(float) == 4);
223     static_assert(offsetof(Uncal, zBias) == 20);
224     static_assert(sizeof(float) == 4);
225     static_assert(alignof(Uncal) == 4);
226     static_assert(sizeof(Uncal) == 24);
227     class HeadTracker {
228     public:
229       typedef std::true_type fixed_size;
230       static const char* descriptor;
231 
232       float rx __attribute__((aligned (4))) = 0.000000f;
233       float ry __attribute__((aligned (4))) = 0.000000f;
234       float rz __attribute__((aligned (4))) = 0.000000f;
235       float vx __attribute__((aligned (4))) = 0.000000f;
236       float vy __attribute__((aligned (4))) = 0.000000f;
237       float vz __attribute__((aligned (4))) = 0.000000f;
238       int32_t discontinuityCount __attribute__((aligned (4))) = 0;
239 
240       binder_status_t readFromParcel(const AParcel* parcel);
241       binder_status_t writeToParcel(AParcel* parcel) const;
242 
243       inline bool operator==(const HeadTracker& _rhs) const {
244         return std::tie(rx, ry, rz, vx, vy, vz, discontinuityCount) == std::tie(_rhs.rx, _rhs.ry, _rhs.rz, _rhs.vx, _rhs.vy, _rhs.vz, _rhs.discontinuityCount);
245       }
246       inline bool operator<(const HeadTracker& _rhs) const {
247         return std::tie(rx, ry, rz, vx, vy, vz, discontinuityCount) < std::tie(_rhs.rx, _rhs.ry, _rhs.rz, _rhs.vx, _rhs.vy, _rhs.vz, _rhs.discontinuityCount);
248       }
249       inline bool operator!=(const HeadTracker& _rhs) const {
250         return !(*this == _rhs);
251       }
252       inline bool operator>(const HeadTracker& _rhs) const {
253         return _rhs < *this;
254       }
255       inline bool operator>=(const HeadTracker& _rhs) const {
256         return !(*this < _rhs);
257       }
258       inline bool operator<=(const HeadTracker& _rhs) const {
259         return !(_rhs < *this);
260       }
261 
262       static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
toString()263       inline std::string toString() const {
264         std::ostringstream _aidl_os;
265         _aidl_os << "HeadTracker{";
266         _aidl_os << "rx: " << ::android::internal::ToString(rx);
267         _aidl_os << ", ry: " << ::android::internal::ToString(ry);
268         _aidl_os << ", rz: " << ::android::internal::ToString(rz);
269         _aidl_os << ", vx: " << ::android::internal::ToString(vx);
270         _aidl_os << ", vy: " << ::android::internal::ToString(vy);
271         _aidl_os << ", vz: " << ::android::internal::ToString(vz);
272         _aidl_os << ", discontinuityCount: " << ::android::internal::ToString(discontinuityCount);
273         _aidl_os << "}";
274         return _aidl_os.str();
275       }
276     };
277     static_assert(offsetof(HeadTracker, rx) == 0);
278     static_assert(sizeof(float) == 4);
279     static_assert(offsetof(HeadTracker, ry) == 4);
280     static_assert(sizeof(float) == 4);
281     static_assert(offsetof(HeadTracker, rz) == 8);
282     static_assert(sizeof(float) == 4);
283     static_assert(offsetof(HeadTracker, vx) == 12);
284     static_assert(sizeof(float) == 4);
285     static_assert(offsetof(HeadTracker, vy) == 16);
286     static_assert(sizeof(float) == 4);
287     static_assert(offsetof(HeadTracker, vz) == 20);
288     static_assert(sizeof(float) == 4);
289     static_assert(offsetof(HeadTracker, discontinuityCount) == 24);
290     static_assert(sizeof(int32_t) == 4);
291     static_assert(alignof(HeadTracker) == 4);
292     static_assert(sizeof(HeadTracker) == 28);
293     class LimitedAxesImu {
294     public:
295       typedef std::true_type fixed_size;
296       static const char* descriptor;
297 
298       float x __attribute__((aligned (4))) = 0.000000f;
299       float y __attribute__((aligned (4))) = 0.000000f;
300       float z __attribute__((aligned (4))) = 0.000000f;
301       float xSupported __attribute__((aligned (4))) = 0.000000f;
302       float ySupported __attribute__((aligned (4))) = 0.000000f;
303       float zSupported __attribute__((aligned (4))) = 0.000000f;
304 
305       binder_status_t readFromParcel(const AParcel* parcel);
306       binder_status_t writeToParcel(AParcel* parcel) const;
307 
308       inline bool operator==(const LimitedAxesImu& _rhs) const {
309         return std::tie(x, y, z, xSupported, ySupported, zSupported) == std::tie(_rhs.x, _rhs.y, _rhs.z, _rhs.xSupported, _rhs.ySupported, _rhs.zSupported);
310       }
311       inline bool operator<(const LimitedAxesImu& _rhs) const {
312         return std::tie(x, y, z, xSupported, ySupported, zSupported) < std::tie(_rhs.x, _rhs.y, _rhs.z, _rhs.xSupported, _rhs.ySupported, _rhs.zSupported);
313       }
314       inline bool operator!=(const LimitedAxesImu& _rhs) const {
315         return !(*this == _rhs);
316       }
317       inline bool operator>(const LimitedAxesImu& _rhs) const {
318         return _rhs < *this;
319       }
320       inline bool operator>=(const LimitedAxesImu& _rhs) const {
321         return !(*this < _rhs);
322       }
323       inline bool operator<=(const LimitedAxesImu& _rhs) const {
324         return !(_rhs < *this);
325       }
326 
327       static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
toString()328       inline std::string toString() const {
329         std::ostringstream _aidl_os;
330         _aidl_os << "LimitedAxesImu{";
331         _aidl_os << "x: " << ::android::internal::ToString(x);
332         _aidl_os << ", y: " << ::android::internal::ToString(y);
333         _aidl_os << ", z: " << ::android::internal::ToString(z);
334         _aidl_os << ", xSupported: " << ::android::internal::ToString(xSupported);
335         _aidl_os << ", ySupported: " << ::android::internal::ToString(ySupported);
336         _aidl_os << ", zSupported: " << ::android::internal::ToString(zSupported);
337         _aidl_os << "}";
338         return _aidl_os.str();
339       }
340     };
341     static_assert(offsetof(LimitedAxesImu, x) == 0);
342     static_assert(sizeof(float) == 4);
343     static_assert(offsetof(LimitedAxesImu, y) == 4);
344     static_assert(sizeof(float) == 4);
345     static_assert(offsetof(LimitedAxesImu, z) == 8);
346     static_assert(sizeof(float) == 4);
347     static_assert(offsetof(LimitedAxesImu, xSupported) == 12);
348     static_assert(sizeof(float) == 4);
349     static_assert(offsetof(LimitedAxesImu, ySupported) == 16);
350     static_assert(sizeof(float) == 4);
351     static_assert(offsetof(LimitedAxesImu, zSupported) == 20);
352     static_assert(sizeof(float) == 4);
353     static_assert(alignof(LimitedAxesImu) == 4);
354     static_assert(sizeof(LimitedAxesImu) == 24);
355     class LimitedAxesImuUncal {
356     public:
357       typedef std::true_type fixed_size;
358       static const char* descriptor;
359 
360       float x __attribute__((aligned (4))) = 0.000000f;
361       float y __attribute__((aligned (4))) = 0.000000f;
362       float z __attribute__((aligned (4))) = 0.000000f;
363       float xBias __attribute__((aligned (4))) = 0.000000f;
364       float yBias __attribute__((aligned (4))) = 0.000000f;
365       float zBias __attribute__((aligned (4))) = 0.000000f;
366       float xSupported __attribute__((aligned (4))) = 0.000000f;
367       float ySupported __attribute__((aligned (4))) = 0.000000f;
368       float zSupported __attribute__((aligned (4))) = 0.000000f;
369 
370       binder_status_t readFromParcel(const AParcel* parcel);
371       binder_status_t writeToParcel(AParcel* parcel) const;
372 
373       inline bool operator==(const LimitedAxesImuUncal& _rhs) const {
374         return std::tie(x, y, z, xBias, yBias, zBias, xSupported, ySupported, zSupported) == std::tie(_rhs.x, _rhs.y, _rhs.z, _rhs.xBias, _rhs.yBias, _rhs.zBias, _rhs.xSupported, _rhs.ySupported, _rhs.zSupported);
375       }
376       inline bool operator<(const LimitedAxesImuUncal& _rhs) const {
377         return std::tie(x, y, z, xBias, yBias, zBias, xSupported, ySupported, zSupported) < std::tie(_rhs.x, _rhs.y, _rhs.z, _rhs.xBias, _rhs.yBias, _rhs.zBias, _rhs.xSupported, _rhs.ySupported, _rhs.zSupported);
378       }
379       inline bool operator!=(const LimitedAxesImuUncal& _rhs) const {
380         return !(*this == _rhs);
381       }
382       inline bool operator>(const LimitedAxesImuUncal& _rhs) const {
383         return _rhs < *this;
384       }
385       inline bool operator>=(const LimitedAxesImuUncal& _rhs) const {
386         return !(*this < _rhs);
387       }
388       inline bool operator<=(const LimitedAxesImuUncal& _rhs) const {
389         return !(_rhs < *this);
390       }
391 
392       static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
toString()393       inline std::string toString() const {
394         std::ostringstream _aidl_os;
395         _aidl_os << "LimitedAxesImuUncal{";
396         _aidl_os << "x: " << ::android::internal::ToString(x);
397         _aidl_os << ", y: " << ::android::internal::ToString(y);
398         _aidl_os << ", z: " << ::android::internal::ToString(z);
399         _aidl_os << ", xBias: " << ::android::internal::ToString(xBias);
400         _aidl_os << ", yBias: " << ::android::internal::ToString(yBias);
401         _aidl_os << ", zBias: " << ::android::internal::ToString(zBias);
402         _aidl_os << ", xSupported: " << ::android::internal::ToString(xSupported);
403         _aidl_os << ", ySupported: " << ::android::internal::ToString(ySupported);
404         _aidl_os << ", zSupported: " << ::android::internal::ToString(zSupported);
405         _aidl_os << "}";
406         return _aidl_os.str();
407       }
408     };
409     static_assert(offsetof(LimitedAxesImuUncal, x) == 0);
410     static_assert(sizeof(float) == 4);
411     static_assert(offsetof(LimitedAxesImuUncal, y) == 4);
412     static_assert(sizeof(float) == 4);
413     static_assert(offsetof(LimitedAxesImuUncal, z) == 8);
414     static_assert(sizeof(float) == 4);
415     static_assert(offsetof(LimitedAxesImuUncal, xBias) == 12);
416     static_assert(sizeof(float) == 4);
417     static_assert(offsetof(LimitedAxesImuUncal, yBias) == 16);
418     static_assert(sizeof(float) == 4);
419     static_assert(offsetof(LimitedAxesImuUncal, zBias) == 20);
420     static_assert(sizeof(float) == 4);
421     static_assert(offsetof(LimitedAxesImuUncal, xSupported) == 24);
422     static_assert(sizeof(float) == 4);
423     static_assert(offsetof(LimitedAxesImuUncal, ySupported) == 28);
424     static_assert(sizeof(float) == 4);
425     static_assert(offsetof(LimitedAxesImuUncal, zSupported) == 32);
426     static_assert(sizeof(float) == 4);
427     static_assert(alignof(LimitedAxesImuUncal) == 4);
428     static_assert(sizeof(LimitedAxesImuUncal) == 36);
429     class HeartRate {
430     public:
431       typedef std::true_type fixed_size;
432       static const char* descriptor;
433 
434       float bpm __attribute__((aligned (4))) = 0.000000f;
435       ::aidl::android::hardware::sensors::SensorStatus status __attribute__((aligned (1))) = ::aidl::android::hardware::sensors::SensorStatus(0);
436 
437       binder_status_t readFromParcel(const AParcel* parcel);
438       binder_status_t writeToParcel(AParcel* parcel) const;
439 
440       inline bool operator==(const HeartRate& _rhs) const {
441         return std::tie(bpm, status) == std::tie(_rhs.bpm, _rhs.status);
442       }
443       inline bool operator<(const HeartRate& _rhs) const {
444         return std::tie(bpm, status) < std::tie(_rhs.bpm, _rhs.status);
445       }
446       inline bool operator!=(const HeartRate& _rhs) const {
447         return !(*this == _rhs);
448       }
449       inline bool operator>(const HeartRate& _rhs) const {
450         return _rhs < *this;
451       }
452       inline bool operator>=(const HeartRate& _rhs) const {
453         return !(*this < _rhs);
454       }
455       inline bool operator<=(const HeartRate& _rhs) const {
456         return !(_rhs < *this);
457       }
458 
459       static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
toString()460       inline std::string toString() const {
461         std::ostringstream _aidl_os;
462         _aidl_os << "HeartRate{";
463         _aidl_os << "bpm: " << ::android::internal::ToString(bpm);
464         _aidl_os << ", status: " << ::android::internal::ToString(status);
465         _aidl_os << "}";
466         return _aidl_os.str();
467       }
468     };
469     static_assert(offsetof(HeartRate, bpm) == 0);
470     static_assert(sizeof(float) == 4);
471     static_assert(offsetof(HeartRate, status) == 4);
472     static_assert(sizeof(::aidl::android::hardware::sensors::SensorStatus) == 1);
473     static_assert(alignof(HeartRate) == 4);
474     static_assert(sizeof(HeartRate) == 8);
475     class Heading {
476     public:
477       typedef std::true_type fixed_size;
478       static const char* descriptor;
479 
480       float heading __attribute__((aligned (4))) = 0.000000f;
481       float accuracy __attribute__((aligned (4))) = 0.000000f;
482 
483       binder_status_t readFromParcel(const AParcel* parcel);
484       binder_status_t writeToParcel(AParcel* parcel) const;
485 
486       inline bool operator==(const Heading& _rhs) const {
487         return std::tie(heading, accuracy) == std::tie(_rhs.heading, _rhs.accuracy);
488       }
489       inline bool operator<(const Heading& _rhs) const {
490         return std::tie(heading, accuracy) < std::tie(_rhs.heading, _rhs.accuracy);
491       }
492       inline bool operator!=(const Heading& _rhs) const {
493         return !(*this == _rhs);
494       }
495       inline bool operator>(const Heading& _rhs) const {
496         return _rhs < *this;
497       }
498       inline bool operator>=(const Heading& _rhs) const {
499         return !(*this < _rhs);
500       }
501       inline bool operator<=(const Heading& _rhs) const {
502         return !(_rhs < *this);
503       }
504 
505       static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
toString()506       inline std::string toString() const {
507         std::ostringstream _aidl_os;
508         _aidl_os << "Heading{";
509         _aidl_os << "heading: " << ::android::internal::ToString(heading);
510         _aidl_os << ", accuracy: " << ::android::internal::ToString(accuracy);
511         _aidl_os << "}";
512         return _aidl_os.str();
513       }
514     };
515     static_assert(offsetof(Heading, heading) == 0);
516     static_assert(sizeof(float) == 4);
517     static_assert(offsetof(Heading, accuracy) == 4);
518     static_assert(sizeof(float) == 4);
519     static_assert(alignof(Heading) == 4);
520     static_assert(sizeof(Heading) == 8);
521     class MetaData {
522     public:
523       typedef std::true_type fixed_size;
524       static const char* descriptor;
525 
526       enum class MetaDataEventType : int32_t {
527         META_DATA_FLUSH_COMPLETE = 1,
528       };
529 
530       ::aidl::android::hardware::sensors::Event::EventPayload::MetaData::MetaDataEventType what __attribute__((aligned (4))) = ::aidl::android::hardware::sensors::Event::EventPayload::MetaData::MetaDataEventType(0);
531 
532       binder_status_t readFromParcel(const AParcel* parcel);
533       binder_status_t writeToParcel(AParcel* parcel) const;
534 
535       inline bool operator==(const MetaData& _rhs) const {
536         return std::tie(what) == std::tie(_rhs.what);
537       }
538       inline bool operator<(const MetaData& _rhs) const {
539         return std::tie(what) < std::tie(_rhs.what);
540       }
541       inline bool operator!=(const MetaData& _rhs) const {
542         return !(*this == _rhs);
543       }
544       inline bool operator>(const MetaData& _rhs) const {
545         return _rhs < *this;
546       }
547       inline bool operator>=(const MetaData& _rhs) const {
548         return !(*this < _rhs);
549       }
550       inline bool operator<=(const MetaData& _rhs) const {
551         return !(_rhs < *this);
552       }
553 
554       static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
toString()555       inline std::string toString() const {
556         std::ostringstream _aidl_os;
557         _aidl_os << "MetaData{";
558         _aidl_os << "what: " << ::android::internal::ToString(what);
559         _aidl_os << "}";
560         return _aidl_os.str();
561       }
562     };
563     static_assert(offsetof(MetaData, what) == 0);
564     static_assert(sizeof(::aidl::android::hardware::sensors::Event::EventPayload::MetaData::MetaDataEventType) == 4);
565     static_assert(alignof(MetaData) == 4);
566     static_assert(sizeof(MetaData) == 4);
567     class Pose6Dof {
568     public:
569       typedef std::true_type fixed_size;
570       static const char* descriptor;
571 
572       std::array<float, 15> values __attribute__((aligned (4))) = {{}};
573 
574       binder_status_t readFromParcel(const AParcel* parcel);
575       binder_status_t writeToParcel(AParcel* parcel) const;
576 
577       inline bool operator==(const Pose6Dof& _rhs) const {
578         return std::tie(values) == std::tie(_rhs.values);
579       }
580       inline bool operator<(const Pose6Dof& _rhs) const {
581         return std::tie(values) < std::tie(_rhs.values);
582       }
583       inline bool operator!=(const Pose6Dof& _rhs) const {
584         return !(*this == _rhs);
585       }
586       inline bool operator>(const Pose6Dof& _rhs) const {
587         return _rhs < *this;
588       }
589       inline bool operator>=(const Pose6Dof& _rhs) const {
590         return !(*this < _rhs);
591       }
592       inline bool operator<=(const Pose6Dof& _rhs) const {
593         return !(_rhs < *this);
594       }
595 
596       static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
toString()597       inline std::string toString() const {
598         std::ostringstream _aidl_os;
599         _aidl_os << "Pose6Dof{";
600         _aidl_os << "values: " << ::android::internal::ToString(values);
601         _aidl_os << "}";
602         return _aidl_os.str();
603       }
604     };
605     static_assert(offsetof(Pose6Dof, values) == 0);
606     static_assert(sizeof(std::array<float, 15>) == 60);
607     static_assert(alignof(Pose6Dof) == 4);
608     static_assert(sizeof(Pose6Dof) == 60);
609     class Data {
610     public:
611       typedef std::true_type fixed_size;
612       static const char* descriptor;
613 
614       std::array<float, 16> values __attribute__((aligned (4))) = {{}};
615 
616       binder_status_t readFromParcel(const AParcel* parcel);
617       binder_status_t writeToParcel(AParcel* parcel) const;
618 
619       inline bool operator==(const Data& _rhs) const {
620         return std::tie(values) == std::tie(_rhs.values);
621       }
622       inline bool operator<(const Data& _rhs) const {
623         return std::tie(values) < std::tie(_rhs.values);
624       }
625       inline bool operator!=(const Data& _rhs) const {
626         return !(*this == _rhs);
627       }
628       inline bool operator>(const Data& _rhs) const {
629         return _rhs < *this;
630       }
631       inline bool operator>=(const Data& _rhs) const {
632         return !(*this < _rhs);
633       }
634       inline bool operator<=(const Data& _rhs) const {
635         return !(_rhs < *this);
636       }
637 
638       static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
toString()639       inline std::string toString() const {
640         std::ostringstream _aidl_os;
641         _aidl_os << "Data{";
642         _aidl_os << "values: " << ::android::internal::ToString(values);
643         _aidl_os << "}";
644         return _aidl_os.str();
645       }
646     };
647     static_assert(offsetof(Data, values) == 0);
648     static_assert(sizeof(std::array<float, 16>) == 64);
649     static_assert(alignof(Data) == 4);
650     static_assert(sizeof(Data) == 64);
651     enum class Tag : int8_t {
652       vec3 = 0,
653       vec4 = 1,
654       uncal = 2,
655       meta = 3,
656       scalar = 4,
657       stepCount = 5,
658       heartRate = 6,
659       pose6DOF = 7,
660       dynamic = 8,
661       additional = 9,
662       data = 10,
663       headTracker = 11,
664       limitedAxesImu = 12,
665       limitedAxesImuUncal = 13,
666       heading = 14,
667     };
668 
669     // Expose tag symbols for legacy code
670     static const inline Tag vec3 = Tag::vec3;
671     static const inline Tag vec4 = Tag::vec4;
672     static const inline Tag uncal = Tag::uncal;
673     static const inline Tag meta = Tag::meta;
674     static const inline Tag scalar = Tag::scalar;
675     static const inline Tag stepCount = Tag::stepCount;
676     static const inline Tag heartRate = Tag::heartRate;
677     static const inline Tag pose6DOF = Tag::pose6DOF;
678     static const inline Tag dynamic = Tag::dynamic;
679     static const inline Tag additional = Tag::additional;
680     static const inline Tag data = Tag::data;
681     static const inline Tag headTracker = Tag::headTracker;
682     static const inline Tag limitedAxesImu = Tag::limitedAxesImu;
683     static const inline Tag limitedAxesImuUncal = Tag::limitedAxesImuUncal;
684     static const inline Tag heading = Tag::heading;
685 
686     template <Tag _Tag>
687     using _at = typename std::tuple_element<static_cast<size_t>(_Tag), std::tuple<::aidl::android::hardware::sensors::Event::EventPayload::Vec3, ::aidl::android::hardware::sensors::Event::EventPayload::Vec4, ::aidl::android::hardware::sensors::Event::EventPayload::Uncal, ::aidl::android::hardware::sensors::Event::EventPayload::MetaData, float, int64_t, ::aidl::android::hardware::sensors::Event::EventPayload::HeartRate, ::aidl::android::hardware::sensors::Event::EventPayload::Pose6Dof, ::aidl::android::hardware::sensors::DynamicSensorInfo, ::aidl::android::hardware::sensors::AdditionalInfo, ::aidl::android::hardware::sensors::Event::EventPayload::Data, ::aidl::android::hardware::sensors::Event::EventPayload::HeadTracker, ::aidl::android::hardware::sensors::Event::EventPayload::LimitedAxesImu, ::aidl::android::hardware::sensors::Event::EventPayload::LimitedAxesImuUncal, ::aidl::android::hardware::sensors::Event::EventPayload::Heading>>::type;
688     template <Tag _Tag, typename _Type>
make(_Type && _arg)689     static EventPayload make(_Type&& _arg) {
690       EventPayload _inst;
691       _inst.set<_Tag>(std::forward<_Type>(_arg));
692       return _inst;
693     }
getTag()694     constexpr Tag getTag() const {
695       return _tag;
696     }
697     template <Tag _Tag>
get()698     const _at<_Tag>& get() const {
699       if (_Tag != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); }
700       return *(_at<_Tag>*)(&_value);
701     }
702     template <Tag _Tag>
get()703     _at<_Tag>& get() {
704       if (_Tag != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); }
705       return *(_at<_Tag>*)(&_value);
706     }
707     template <Tag _Tag, typename _Type>
set(_Type && _arg)708     void set(_Type&& _arg) {
709       _tag = _Tag;
710       get<_Tag>() = std::forward<_Type>(_arg);
711     }
712     binder_status_t readFromParcel(const AParcel* _parcel);
713     binder_status_t writeToParcel(AParcel* _parcel) const;
714 
_cmp(const EventPayload & _lhs,const EventPayload & _rhs)715     static int _cmp(const EventPayload& _lhs, const EventPayload& _rhs) {
716       return _cmp_value(_lhs.getTag(), _rhs.getTag()) || _cmp_value_at<heading>(_lhs, _rhs);
717     }
718     template <Tag _Tag>
_cmp_value_at(const EventPayload & _lhs,const EventPayload & _rhs)719     static int _cmp_value_at(const EventPayload& _lhs, const EventPayload& _rhs) {
720       if constexpr (_Tag == vec3) {
721         return _cmp_value(_lhs.get<_Tag>(), _rhs.get<_Tag>());
722       } else {
723         return (_lhs.getTag() == _Tag)
724           ? _cmp_value(_lhs.get<_Tag>(), _rhs.get<_Tag>())
725           : _cmp_value_at<static_cast<Tag>(static_cast<size_t>(_Tag)-1)>(_lhs, _rhs);
726       }
727     }
728     template <typename _Type>
_cmp_value(const _Type & _lhs,const _Type & _rhs)729     static int _cmp_value(const _Type& _lhs, const _Type& _rhs) {
730       return (_lhs == _rhs) ? 0 : (_lhs < _rhs) ? -1 : 1;
731     }
732     inline bool operator!=(const EventPayload&_rhs) const {
733       return _cmp(*this, _rhs) != 0;
734     }
735     inline bool operator<(const EventPayload&_rhs) const {
736       return _cmp(*this, _rhs) < 0;
737     }
738     inline bool operator<=(const EventPayload&_rhs) const {
739       return _cmp(*this, _rhs) <= 0;
740     }
741     inline bool operator==(const EventPayload&_rhs) const {
742       return _cmp(*this, _rhs) == 0;
743     }
744     inline bool operator>(const EventPayload&_rhs) const {
745       return _cmp(*this, _rhs) > 0;
746     }
747     inline bool operator>=(const EventPayload&_rhs) const {
748       return _cmp(*this, _rhs) >= 0;
749     }
750     static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
toString()751     inline std::string toString() const {
752       std::ostringstream os;
753       os << "EventPayload{";
754       switch (getTag()) {
755       case vec3: os << "vec3: " << ::android::internal::ToString(get<vec3>()); break;
756       case vec4: os << "vec4: " << ::android::internal::ToString(get<vec4>()); break;
757       case uncal: os << "uncal: " << ::android::internal::ToString(get<uncal>()); break;
758       case meta: os << "meta: " << ::android::internal::ToString(get<meta>()); break;
759       case scalar: os << "scalar: " << ::android::internal::ToString(get<scalar>()); break;
760       case stepCount: os << "stepCount: " << ::android::internal::ToString(get<stepCount>()); break;
761       case heartRate: os << "heartRate: " << ::android::internal::ToString(get<heartRate>()); break;
762       case pose6DOF: os << "pose6DOF: " << ::android::internal::ToString(get<pose6DOF>()); break;
763       case dynamic: os << "dynamic: " << ::android::internal::ToString(get<dynamic>()); break;
764       case additional: os << "additional: " << ::android::internal::ToString(get<additional>()); break;
765       case data: os << "data: " << ::android::internal::ToString(get<data>()); break;
766       case headTracker: os << "headTracker: " << ::android::internal::ToString(get<headTracker>()); break;
767       case limitedAxesImu: os << "limitedAxesImu: " << ::android::internal::ToString(get<limitedAxesImu>()); break;
768       case limitedAxesImuUncal: os << "limitedAxesImuUncal: " << ::android::internal::ToString(get<limitedAxesImuUncal>()); break;
769       case heading: os << "heading: " << ::android::internal::ToString(get<heading>()); break;
770       }
771       os << "}";
772       return os.str();
773     }
774   private:
775     Tag _tag = vec3;
776     union _value_t {
_value_t()777       _value_t() {}
~_value_t()778       ~_value_t() {}
779       ::aidl::android::hardware::sensors::Event::EventPayload::Vec3 vec3 __attribute__((aligned (4))) = ::aidl::android::hardware::sensors::Event::EventPayload::Vec3();
780       ::aidl::android::hardware::sensors::Event::EventPayload::Vec4 vec4 __attribute__((aligned (4)));
781       ::aidl::android::hardware::sensors::Event::EventPayload::Uncal uncal __attribute__((aligned (4)));
782       ::aidl::android::hardware::sensors::Event::EventPayload::MetaData meta __attribute__((aligned (4)));
783       float scalar __attribute__((aligned (4)));
784       int64_t stepCount __attribute__((aligned (8)));
785       ::aidl::android::hardware::sensors::Event::EventPayload::HeartRate heartRate __attribute__((aligned (4)));
786       ::aidl::android::hardware::sensors::Event::EventPayload::Pose6Dof pose6DOF __attribute__((aligned (4)));
787       ::aidl::android::hardware::sensors::DynamicSensorInfo dynamic __attribute__((aligned (4)));
788       ::aidl::android::hardware::sensors::AdditionalInfo additional __attribute__((aligned (4)));
789       ::aidl::android::hardware::sensors::Event::EventPayload::Data data __attribute__((aligned (4)));
790       ::aidl::android::hardware::sensors::Event::EventPayload::HeadTracker headTracker __attribute__((aligned (4)));
791       ::aidl::android::hardware::sensors::Event::EventPayload::LimitedAxesImu limitedAxesImu __attribute__((aligned (4)));
792       ::aidl::android::hardware::sensors::Event::EventPayload::LimitedAxesImuUncal limitedAxesImuUncal __attribute__((aligned (4)));
793       ::aidl::android::hardware::sensors::Event::EventPayload::Heading heading __attribute__((aligned (4)));
794     } _value;
795   };
796   static_assert(sizeof(::aidl::android::hardware::sensors::Event::EventPayload::Vec3) == 16);
797   static_assert(sizeof(::aidl::android::hardware::sensors::Event::EventPayload::Vec4) == 16);
798   static_assert(sizeof(::aidl::android::hardware::sensors::Event::EventPayload::Uncal) == 24);
799   static_assert(sizeof(::aidl::android::hardware::sensors::Event::EventPayload::MetaData) == 4);
800   static_assert(sizeof(float) == 4);
801   static_assert(sizeof(int64_t) == 8);
802   static_assert(sizeof(::aidl::android::hardware::sensors::Event::EventPayload::HeartRate) == 8);
803   static_assert(sizeof(::aidl::android::hardware::sensors::Event::EventPayload::Pose6Dof) == 60);
804   static_assert(sizeof(::aidl::android::hardware::sensors::DynamicSensorInfo) == 24);
805   static_assert(sizeof(::aidl::android::hardware::sensors::AdditionalInfo) == 68);
806   static_assert(sizeof(::aidl::android::hardware::sensors::Event::EventPayload::Data) == 64);
807   static_assert(sizeof(::aidl::android::hardware::sensors::Event::EventPayload::HeadTracker) == 28);
808   static_assert(sizeof(::aidl::android::hardware::sensors::Event::EventPayload::LimitedAxesImu) == 24);
809   static_assert(sizeof(::aidl::android::hardware::sensors::Event::EventPayload::LimitedAxesImuUncal) == 36);
810   static_assert(sizeof(::aidl::android::hardware::sensors::Event::EventPayload::Heading) == 8);
811   static_assert(alignof(EventPayload) == 8);
812   static_assert(sizeof(EventPayload) == 80);
813   int64_t timestamp __attribute__((aligned (8))) = 0L;
814   int32_t sensorHandle __attribute__((aligned (4))) = 0;
815   ::aidl::android::hardware::sensors::SensorType sensorType __attribute__((aligned (4))) = ::aidl::android::hardware::sensors::SensorType(0);
816   ::aidl::android::hardware::sensors::Event::EventPayload payload __attribute__((aligned (8)));
817 
818   binder_status_t readFromParcel(const AParcel* parcel);
819   binder_status_t writeToParcel(AParcel* parcel) const;
820 
821   inline bool operator==(const Event& _rhs) const {
822     return std::tie(timestamp, sensorHandle, sensorType, payload) == std::tie(_rhs.timestamp, _rhs.sensorHandle, _rhs.sensorType, _rhs.payload);
823   }
824   inline bool operator<(const Event& _rhs) const {
825     return std::tie(timestamp, sensorHandle, sensorType, payload) < std::tie(_rhs.timestamp, _rhs.sensorHandle, _rhs.sensorType, _rhs.payload);
826   }
827   inline bool operator!=(const Event& _rhs) const {
828     return !(*this == _rhs);
829   }
830   inline bool operator>(const Event& _rhs) const {
831     return _rhs < *this;
832   }
833   inline bool operator>=(const Event& _rhs) const {
834     return !(*this < _rhs);
835   }
836   inline bool operator<=(const Event& _rhs) const {
837     return !(_rhs < *this);
838   }
839 
840   static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
toString()841   inline std::string toString() const {
842     std::ostringstream _aidl_os;
843     _aidl_os << "Event{";
844     _aidl_os << "timestamp: " << ::android::internal::ToString(timestamp);
845     _aidl_os << ", sensorHandle: " << ::android::internal::ToString(sensorHandle);
846     _aidl_os << ", sensorType: " << ::android::internal::ToString(sensorType);
847     _aidl_os << ", payload: " << ::android::internal::ToString(payload);
848     _aidl_os << "}";
849     return _aidl_os.str();
850   }
851 };
852 static_assert(offsetof(Event, timestamp) == 0);
853 static_assert(sizeof(int64_t) == 8);
854 static_assert(offsetof(Event, sensorHandle) == 8);
855 static_assert(sizeof(int32_t) == 4);
856 static_assert(offsetof(Event, sensorType) == 12);
857 static_assert(sizeof(::aidl::android::hardware::sensors::SensorType) == 4);
858 static_assert(offsetof(Event, payload) == 16);
859 static_assert(sizeof(::aidl::android::hardware::sensors::Event::EventPayload) == 80);
860 static_assert(alignof(Event) == 8);
861 static_assert(sizeof(Event) == 96);
862 }  // namespace sensors
863 }  // namespace hardware
864 }  // namespace android
865 }  // namespace aidl
866 namespace aidl {
867 namespace android {
868 namespace hardware {
869 namespace sensors {
toString(Event::EventPayload::MetaData::MetaDataEventType val)870 [[nodiscard]] static inline std::string toString(Event::EventPayload::MetaData::MetaDataEventType val) {
871   switch(val) {
872   case Event::EventPayload::MetaData::MetaDataEventType::META_DATA_FLUSH_COMPLETE:
873     return "META_DATA_FLUSH_COMPLETE";
874   default:
875     return std::to_string(static_cast<int32_t>(val));
876   }
877 }
878 }  // namespace sensors
879 }  // namespace hardware
880 }  // namespace android
881 }  // namespace aidl
882 namespace ndk {
883 namespace internal {
884 #pragma clang diagnostic push
885 #pragma clang diagnostic ignored "-Wc++17-extensions"
886 template <>
887 constexpr inline std::array<aidl::android::hardware::sensors::Event::EventPayload::MetaData::MetaDataEventType, 1> enum_values<aidl::android::hardware::sensors::Event::EventPayload::MetaData::MetaDataEventType> = {
888   aidl::android::hardware::sensors::Event::EventPayload::MetaData::MetaDataEventType::META_DATA_FLUSH_COMPLETE,
889 };
890 #pragma clang diagnostic pop
891 }  // namespace internal
892 }  // namespace ndk
893 namespace aidl {
894 namespace android {
895 namespace hardware {
896 namespace sensors {
toString(Event::EventPayload::Tag val)897 [[nodiscard]] static inline std::string toString(Event::EventPayload::Tag val) {
898   switch(val) {
899   case Event::EventPayload::Tag::vec3:
900     return "vec3";
901   case Event::EventPayload::Tag::vec4:
902     return "vec4";
903   case Event::EventPayload::Tag::uncal:
904     return "uncal";
905   case Event::EventPayload::Tag::meta:
906     return "meta";
907   case Event::EventPayload::Tag::scalar:
908     return "scalar";
909   case Event::EventPayload::Tag::stepCount:
910     return "stepCount";
911   case Event::EventPayload::Tag::heartRate:
912     return "heartRate";
913   case Event::EventPayload::Tag::pose6DOF:
914     return "pose6DOF";
915   case Event::EventPayload::Tag::dynamic:
916     return "dynamic";
917   case Event::EventPayload::Tag::additional:
918     return "additional";
919   case Event::EventPayload::Tag::data:
920     return "data";
921   case Event::EventPayload::Tag::headTracker:
922     return "headTracker";
923   case Event::EventPayload::Tag::limitedAxesImu:
924     return "limitedAxesImu";
925   case Event::EventPayload::Tag::limitedAxesImuUncal:
926     return "limitedAxesImuUncal";
927   case Event::EventPayload::Tag::heading:
928     return "heading";
929   default:
930     return std::to_string(static_cast<int8_t>(val));
931   }
932 }
933 }  // namespace sensors
934 }  // namespace hardware
935 }  // namespace android
936 }  // namespace aidl
937 namespace ndk {
938 namespace internal {
939 #pragma clang diagnostic push
940 #pragma clang diagnostic ignored "-Wc++17-extensions"
941 template <>
942 constexpr inline std::array<aidl::android::hardware::sensors::Event::EventPayload::Tag, 15> enum_values<aidl::android::hardware::sensors::Event::EventPayload::Tag> = {
943   aidl::android::hardware::sensors::Event::EventPayload::Tag::vec3,
944   aidl::android::hardware::sensors::Event::EventPayload::Tag::vec4,
945   aidl::android::hardware::sensors::Event::EventPayload::Tag::uncal,
946   aidl::android::hardware::sensors::Event::EventPayload::Tag::meta,
947   aidl::android::hardware::sensors::Event::EventPayload::Tag::scalar,
948   aidl::android::hardware::sensors::Event::EventPayload::Tag::stepCount,
949   aidl::android::hardware::sensors::Event::EventPayload::Tag::heartRate,
950   aidl::android::hardware::sensors::Event::EventPayload::Tag::pose6DOF,
951   aidl::android::hardware::sensors::Event::EventPayload::Tag::dynamic,
952   aidl::android::hardware::sensors::Event::EventPayload::Tag::additional,
953   aidl::android::hardware::sensors::Event::EventPayload::Tag::data,
954   aidl::android::hardware::sensors::Event::EventPayload::Tag::headTracker,
955   aidl::android::hardware::sensors::Event::EventPayload::Tag::limitedAxesImu,
956   aidl::android::hardware::sensors::Event::EventPayload::Tag::limitedAxesImuUncal,
957   aidl::android::hardware::sensors::Event::EventPayload::Tag::heading,
958 };
959 #pragma clang diagnostic pop
960 }  // namespace internal
961 }  // namespace ndk
962