| /* |
| * Copyright (C) 2019 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <Utils.h> |
| #include <android/hardware/gnss/BnGnss.h> |
| #include <android/hardware/gnss/IGnss.h> |
| #include "gtest/gtest.h" |
| |
| #include <cutils/properties.h> |
| #include <math.h> |
| #include <utils/SystemClock.h> |
| |
| namespace android { |
| namespace hardware { |
| namespace gnss { |
| namespace common { |
| |
| using android::hardware::gnss::ElapsedRealtime; |
| using android::hardware::gnss::GnssLocation; |
| |
| using namespace measurement_corrections::V1_0; |
| using V1_0::GnssLocationFlags; |
| |
| using MeasurementCorrectionsAidl = |
| android::hardware::gnss::measurement_corrections::MeasurementCorrections; |
| using ReflectingPlaneAidl = android::hardware::gnss::measurement_corrections::ReflectingPlane; |
| using SingleSatCorrectionAidl = |
| android::hardware::gnss::measurement_corrections::SingleSatCorrection; |
| using ExcessPathInfo = SingleSatCorrectionAidl::ExcessPathInfo; |
| |
| template <> |
| int64_t Utils::getLocationTimestampMillis(const android::hardware::gnss::GnssLocation& location) { |
| return location.timestampMillis; |
| } |
| |
| template <> |
| int64_t Utils::getLocationTimestampMillis(const V1_0::GnssLocation& location) { |
| return location.timestamp; |
| } |
| |
| template <> |
| void Utils::checkLocationElapsedRealtime(const V1_0::GnssLocation&) {} |
| |
| template <> |
| void Utils::checkLocationElapsedRealtime(const android::hardware::gnss::GnssLocation& location) { |
| checkElapsedRealtime(location.elapsedRealtime); |
| } |
| |
| void Utils::checkPositionDebug(android::hardware::gnss::IGnssDebug::DebugData data) { |
| if (data.position.valid) { |
| ASSERT_TRUE(data.position.latitudeDegrees >= -90 && data.position.latitudeDegrees <= 90); |
| ASSERT_TRUE(data.position.longitudeDegrees >= -180 && |
| data.position.longitudeDegrees <= 180); |
| ASSERT_TRUE(data.position.altitudeMeters >= -1000 && // Dead Sea: -414m |
| data.position.altitudeMeters <= 20000); // Mount Everest: 8850m |
| ASSERT_TRUE(data.position.speedMetersPerSec >= 0 && data.position.speedMetersPerSec <= 600); |
| ASSERT_TRUE(data.position.bearingDegrees >= -360 && data.position.bearingDegrees <= 360); |
| ASSERT_TRUE(data.position.horizontalAccuracyMeters > 0 && |
| data.position.horizontalAccuracyMeters <= 20000000); |
| ASSERT_TRUE(data.position.verticalAccuracyMeters > 0 && |
| data.position.verticalAccuracyMeters <= 20000); |
| ASSERT_TRUE(data.position.speedAccuracyMetersPerSecond > 0 && |
| data.position.speedAccuracyMetersPerSecond <= 500); |
| ASSERT_TRUE(data.position.bearingAccuracyDegrees > 0 && |
| data.position.bearingAccuracyDegrees <= 180); |
| ASSERT_TRUE(data.position.ageSeconds >= 0); |
| } |
| ASSERT_TRUE(data.time.timeEstimateMs >= 1483228800000); // Jan 01 2017 00:00:00 GMT. |
| ASSERT_TRUE(data.time.timeUncertaintyNs > 0); |
| ASSERT_TRUE(data.time.frequencyUncertaintyNsPerSec > 0 && |
| data.time.frequencyUncertaintyNsPerSec <= 2.0e5); // 200 ppm |
| } |
| |
| void Utils::checkElapsedRealtime(const ElapsedRealtime& elapsedRealtime) { |
| ASSERT_TRUE(elapsedRealtime.flags >= 0 && |
| elapsedRealtime.flags <= (ElapsedRealtime::HAS_TIMESTAMP_NS | |
| ElapsedRealtime::HAS_TIME_UNCERTAINTY_NS)); |
| if (elapsedRealtime.flags & ElapsedRealtime::HAS_TIMESTAMP_NS) { |
| ASSERT_TRUE(elapsedRealtime.timestampNs > 0); |
| } |
| if (elapsedRealtime.flags & ElapsedRealtime::HAS_TIME_UNCERTAINTY_NS) { |
| ASSERT_TRUE(elapsedRealtime.timeUncertaintyNs > 0); |
| } |
| } |
| |
| const GnssLocation Utils::getMockLocation(double latitudeDegrees, double longitudeDegrees, |
| double horizontalAccuracyMeters) { |
| ElapsedRealtime elapsedRealtime; |
| elapsedRealtime.flags = |
| ElapsedRealtime::HAS_TIMESTAMP_NS | ElapsedRealtime::HAS_TIME_UNCERTAINTY_NS; |
| elapsedRealtime.timestampNs = ::android::elapsedRealtimeNano(); |
| elapsedRealtime.timeUncertaintyNs = 1000; |
| GnssLocation location; |
| location.gnssLocationFlags = 0xFF; |
| location.latitudeDegrees = latitudeDegrees; |
| location.longitudeDegrees = longitudeDegrees; |
| location.altitudeMeters = 500.0; |
| location.speedMetersPerSec = 0.0; |
| location.bearingDegrees = 0.0; |
| location.horizontalAccuracyMeters = horizontalAccuracyMeters; |
| location.verticalAccuracyMeters = 1000.0; |
| location.speedAccuracyMetersPerSecond = 1000.0; |
| location.bearingAccuracyDegrees = 90.0; |
| location.timestampMillis = |
| static_cast<int64_t>(kMockTimestamp + ::android::elapsedRealtimeNano() * 1e-6); |
| location.elapsedRealtime = elapsedRealtime; |
| return location; |
| } |
| |
| const MeasurementCorrections Utils::getMockMeasurementCorrections() { |
| ReflectingPlane reflectingPlane = { |
| .latitudeDegrees = 37.4220039, |
| .longitudeDegrees = -122.0840991, |
| .altitudeMeters = 250.35, |
| .azimuthDegrees = 203.0, |
| }; |
| |
| SingleSatCorrection singleSatCorrection1 = { |
| .singleSatCorrectionFlags = GnssSingleSatCorrectionFlags::HAS_SAT_IS_LOS_PROBABILITY | |
| GnssSingleSatCorrectionFlags::HAS_EXCESS_PATH_LENGTH | |
| GnssSingleSatCorrectionFlags::HAS_EXCESS_PATH_LENGTH_UNC | |
| GnssSingleSatCorrectionFlags::HAS_REFLECTING_PLANE, |
| .constellation = V1_0::GnssConstellationType::GPS, |
| .svid = 12, |
| .carrierFrequencyHz = 1.59975e+09, |
| .probSatIsLos = 0.50001, |
| .excessPathLengthMeters = 137.4802, |
| .excessPathLengthUncertaintyMeters = 25.5, |
| .reflectingPlane = reflectingPlane, |
| }; |
| SingleSatCorrection singleSatCorrection2 = { |
| .singleSatCorrectionFlags = GnssSingleSatCorrectionFlags::HAS_SAT_IS_LOS_PROBABILITY | |
| GnssSingleSatCorrectionFlags::HAS_EXCESS_PATH_LENGTH | |
| GnssSingleSatCorrectionFlags::HAS_EXCESS_PATH_LENGTH_UNC, |
| |
| .constellation = V1_0::GnssConstellationType::GPS, |
| .svid = 9, |
| .carrierFrequencyHz = 1.59975e+09, |
| .probSatIsLos = 0.873, |
| .excessPathLengthMeters = 26.294, |
| .excessPathLengthUncertaintyMeters = 10.0, |
| }; |
| |
| hidl_vec<SingleSatCorrection> singleSatCorrections = {singleSatCorrection1, |
| singleSatCorrection2}; |
| MeasurementCorrections mockCorrections = { |
| .latitudeDegrees = 37.4219999, |
| .longitudeDegrees = -122.0840575, |
| .altitudeMeters = 30.60062531, |
| .horizontalPositionUncertaintyMeters = 9.23542, |
| .verticalPositionUncertaintyMeters = 15.02341, |
| .toaGpsNanosecondsOfWeek = 2935633453L, |
| .satCorrections = singleSatCorrections, |
| }; |
| return mockCorrections; |
| } |
| |
| const measurement_corrections::V1_1::MeasurementCorrections |
| Utils::getMockMeasurementCorrections_1_1() { |
| MeasurementCorrections mockCorrections_1_0 = getMockMeasurementCorrections(); |
| |
| measurement_corrections::V1_1::SingleSatCorrection singleSatCorrection1 = { |
| .v1_0 = mockCorrections_1_0.satCorrections[0], |
| .constellation = V2_0::GnssConstellationType::IRNSS, |
| }; |
| measurement_corrections::V1_1::SingleSatCorrection singleSatCorrection2 = { |
| .v1_0 = mockCorrections_1_0.satCorrections[1], |
| .constellation = V2_0::GnssConstellationType::IRNSS, |
| }; |
| |
| mockCorrections_1_0.satCorrections[0].constellation = V1_0::GnssConstellationType::UNKNOWN; |
| mockCorrections_1_0.satCorrections[1].constellation = V1_0::GnssConstellationType::UNKNOWN; |
| |
| hidl_vec<measurement_corrections::V1_1::SingleSatCorrection> singleSatCorrections = { |
| singleSatCorrection1, singleSatCorrection2}; |
| |
| measurement_corrections::V1_1::MeasurementCorrections mockCorrections_1_1 = { |
| .v1_0 = mockCorrections_1_0, |
| .hasEnvironmentBearing = true, |
| .environmentBearingDegrees = 45.0, |
| .environmentBearingUncertaintyDegrees = 4.0, |
| .satCorrections = singleSatCorrections, |
| }; |
| return mockCorrections_1_1; |
| } |
| |
| namespace { |
| const ExcessPathInfo createExcessPathInfo(float excessPathLengthMeters, |
| float excessPathLengthUncertaintyMeters, |
| const ReflectingPlaneAidl* reflectingPlane, |
| float attenuationDb) { |
| ExcessPathInfo excessPathInfo; |
| excessPathInfo.excessPathInfoFlags = |
| ExcessPathInfo::EXCESS_PATH_INFO_HAS_EXCESS_PATH_LENGTH | |
| ExcessPathInfo::EXCESS_PATH_INFO_HAS_EXCESS_PATH_LENGTH_UNC | |
| ExcessPathInfo::EXCESS_PATH_INFO_HAS_ATTENUATION | |
| (reflectingPlane == nullptr ? 0 |
| : ExcessPathInfo::EXCESS_PATH_INFO_HAS_REFLECTING_PLANE); |
| excessPathInfo.excessPathLengthMeters = excessPathLengthMeters; |
| excessPathInfo.excessPathLengthUncertaintyMeters = excessPathLengthUncertaintyMeters; |
| if (reflectingPlane != nullptr) { |
| excessPathInfo.reflectingPlane = *reflectingPlane; |
| } |
| excessPathInfo.attenuationDb = attenuationDb; |
| return excessPathInfo; |
| } |
| } // anonymous namespace |
| |
| const MeasurementCorrectionsAidl Utils::getMockMeasurementCorrections_aidl() { |
| ReflectingPlaneAidl reflectingPlane; |
| reflectingPlane.latitudeDegrees = 37.4220039; |
| reflectingPlane.longitudeDegrees = -122.0840991; |
| reflectingPlane.altitudeMeters = 250.35; |
| reflectingPlane.reflectingPlaneAzimuthDegrees = 203.0; |
| |
| SingleSatCorrectionAidl singleSatCorrection1; |
| singleSatCorrection1.singleSatCorrectionFlags = |
| SingleSatCorrectionAidl::SINGLE_SAT_CORRECTION_HAS_SAT_IS_LOS_PROBABILITY | |
| SingleSatCorrectionAidl::SINGLE_SAT_CORRECTION_HAS_COMBINED_EXCESS_PATH_LENGTH | |
| SingleSatCorrectionAidl::SINGLE_SAT_CORRECTION_HAS_COMBINED_EXCESS_PATH_LENGTH_UNC | |
| SingleSatCorrectionAidl::SINGLE_SAT_CORRECTION_HAS_COMBINED_ATTENUATION; |
| singleSatCorrection1.constellation = android::hardware::gnss::GnssConstellationType::GPS; |
| singleSatCorrection1.svid = 12; |
| singleSatCorrection1.carrierFrequencyHz = 1.59975e+09; |
| singleSatCorrection1.probSatIsLos = 0.50001; |
| singleSatCorrection1.combinedExcessPathLengthMeters = 203.5; |
| singleSatCorrection1.combinedExcessPathLengthUncertaintyMeters = 59.1; |
| singleSatCorrection1.combinedAttenuationDb = -4.3; |
| singleSatCorrection1.excessPathInfos.push_back( |
| createExcessPathInfo(137.4, 25.5, &reflectingPlane, -3.5)); |
| singleSatCorrection1.excessPathInfos.push_back( |
| createExcessPathInfo(296.3, 87.2, &reflectingPlane, -5.1)); |
| |
| SingleSatCorrectionAidl singleSatCorrection2; |
| singleSatCorrection2.singleSatCorrectionFlags = |
| SingleSatCorrectionAidl::SINGLE_SAT_CORRECTION_HAS_SAT_IS_LOS_PROBABILITY | |
| SingleSatCorrectionAidl::SINGLE_SAT_CORRECTION_HAS_COMBINED_EXCESS_PATH_LENGTH | |
| SingleSatCorrectionAidl::SINGLE_SAT_CORRECTION_HAS_COMBINED_EXCESS_PATH_LENGTH_UNC | |
| SingleSatCorrectionAidl::SINGLE_SAT_CORRECTION_HAS_COMBINED_ATTENUATION; |
| singleSatCorrection2.constellation = GnssConstellationType::GPS; |
| singleSatCorrection2.svid = 9; |
| singleSatCorrection2.carrierFrequencyHz = 1.59975e+09; |
| singleSatCorrection2.probSatIsLos = 0.873; |
| singleSatCorrection2.combinedExcessPathLengthMeters = 26.294; |
| singleSatCorrection2.combinedExcessPathLengthUncertaintyMeters = 10.0; |
| singleSatCorrection2.combinedAttenuationDb = -0.5; |
| singleSatCorrection2.excessPathInfos.push_back( |
| createExcessPathInfo(26.294, 10.0, nullptr, -0.5)); |
| |
| std::vector<SingleSatCorrectionAidl> singleSatCorrections = {singleSatCorrection1, |
| singleSatCorrection2}; |
| MeasurementCorrectionsAidl mockCorrections; |
| mockCorrections.latitudeDegrees = 37.4219999; |
| mockCorrections.longitudeDegrees = -122.0840575; |
| mockCorrections.altitudeMeters = 30.60062531; |
| mockCorrections.horizontalPositionUncertaintyMeters = 9.23542; |
| mockCorrections.verticalPositionUncertaintyMeters = 15.02341; |
| mockCorrections.toaGpsNanosecondsOfWeek = 2935633453L; |
| mockCorrections.hasEnvironmentBearing = true; |
| mockCorrections.environmentBearingDegrees = 45.0; |
| mockCorrections.environmentBearingUncertaintyDegrees = 4.0; |
| mockCorrections.satCorrections = singleSatCorrections; |
| |
| return mockCorrections; |
| } |
| |
| /* |
| * MapConstellationType: |
| * Given a GnssConstellationType_2_0 type constellation, maps to its equivalent |
| * GnssConstellationType_1_0 type constellation. For constellations that do not have |
| * an equivalent value, maps to GnssConstellationType_1_0::UNKNOWN |
| */ |
| V1_0::GnssConstellationType Utils::mapConstellationType(V2_0::GnssConstellationType constellation) { |
| switch (constellation) { |
| case V2_0::GnssConstellationType::GPS: |
| return V1_0::GnssConstellationType::GPS; |
| case V2_0::GnssConstellationType::SBAS: |
| return V1_0::GnssConstellationType::SBAS; |
| case V2_0::GnssConstellationType::GLONASS: |
| return V1_0::GnssConstellationType::GLONASS; |
| case V2_0::GnssConstellationType::QZSS: |
| return V1_0::GnssConstellationType::QZSS; |
| case V2_0::GnssConstellationType::BEIDOU: |
| return V1_0::GnssConstellationType::BEIDOU; |
| case V2_0::GnssConstellationType::GALILEO: |
| return V1_0::GnssConstellationType::GALILEO; |
| default: |
| return V1_0::GnssConstellationType::UNKNOWN; |
| } |
| } |
| |
| bool Utils::isAutomotiveDevice() { |
| char buffer[PROPERTY_VALUE_MAX] = {0}; |
| property_get("ro.hardware.type", buffer, ""); |
| return strncmp(buffer, "automotive", PROPERTY_VALUE_MAX) == 0; |
| } |
| |
| double Utils::distanceMeters(double lat1, double lon1, double lat2, double lon2) { |
| double R = 6378.137; // Radius of earth in KM |
| double dLat = lat2 * M_PI / 180 - lat1 * M_PI / 180; |
| double dLon = lon2 * M_PI / 180 - lon1 * M_PI / 180; |
| double a = sin(dLat / 2) * sin(dLat / 2) + |
| cos(lat1 * M_PI / 180) * cos(lat2 * M_PI / 180) * sin(dLon / 2) * sin(dLon / 2); |
| double c = 2 * atan2(sqrt(a), sqrt(1 - a)); |
| double d = R * c; |
| return d * 1000; // meters |
| } |
| |
| // Returns true iff the device has the specified feature. |
| bool Utils::deviceSupportsFeature(const char* feature) { |
| bool device_supports_feature = false; |
| FILE* p = popen("/system/bin/pm list features", "re"); |
| if (p) { |
| char* line = NULL; |
| size_t len = 0; |
| while (getline(&line, &len, p) > 0) { |
| if (strstr(line, feature)) { |
| device_supports_feature = true; |
| break; |
| } |
| } |
| pclose(p); |
| } |
| return device_supports_feature; |
| } |
| |
| } // namespace common |
| } // namespace gnss |
| } // namespace hardware |
| } // namespace android |