| /* |
| * Copyright (C) 2020 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 <log/log.h> |
| |
| #include "gnss.h" |
| #include "gnss_configuration.h" |
| #include "gnss_measurement.h" |
| #include "agnss.h" |
| |
| namespace { |
| constexpr char kGnssDeviceName[] = "Android Studio Emulator GPS"; |
| }; |
| |
| namespace goldfish { |
| |
| Return<sp<ahg20::IGnssConfiguration>> Gnss20::getExtensionGnssConfiguration_2_0() { |
| return new GnssConfiguration20(); |
| } |
| |
| Return<sp<ahg20::IGnssDebug>> Gnss20::getExtensionGnssDebug_2_0() { |
| return nullptr; |
| } |
| |
| Return<sp<ahg20::IAGnss>> Gnss20::getExtensionAGnss_2_0() { |
| return new AGnss20(); |
| } |
| |
| Return<sp<ahg20::IAGnssRil>> Gnss20::getExtensionAGnssRil_2_0() { |
| return nullptr; |
| } |
| |
| Return<sp<ahg20::IGnssMeasurement>> Gnss20::getExtensionGnssMeasurement_2_0() { |
| return new GnssMeasurement20(); |
| } |
| |
| Return<bool> Gnss20::setCallback_2_0(const sp<ahg20::IGnssCallback>& callback) { |
| if (callback == nullptr) { |
| return false; |
| } else if (open()) { |
| using Caps = ahg20::IGnssCallback::Capabilities; |
| callback->gnssSetCapabilitiesCb_2_0(Caps::MEASUREMENTS | 0); |
| callback->gnssNameCb(kGnssDeviceName); |
| callback->gnssSetSystemInfoCb({.yearOfHw = 2020}); |
| |
| m_dataSink.setCallback20(callback); |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| Return<sp<ahgmc10::IMeasurementCorrections>> Gnss20::getExtensionMeasurementCorrections() { |
| return nullptr; |
| } |
| |
| Return<sp<ahgvc10::IGnssVisibilityControl>> Gnss20::getExtensionVisibilityControl() { |
| return nullptr; |
| } |
| |
| Return<sp<ahg20::IGnssBatching>> Gnss20::getExtensionGnssBatching_2_0() { |
| return nullptr; |
| } |
| |
| Return<bool> Gnss20::injectBestLocation_2_0(const ahg20::GnssLocation& location) { |
| (void)location; |
| return true; |
| } |
| |
| Return<bool> Gnss20::setPositionMode_1_1(ahg10::IGnss::GnssPositionMode mode, |
| ahg10::IGnss::GnssPositionRecurrence recurrence, |
| uint32_t minIntervalMs, uint32_t preferredAccuracyMeters, |
| uint32_t preferredTimeMs, bool lowPowerMode) { |
| (void)mode; |
| (void)recurrence; |
| (void)minIntervalMs; |
| (void)preferredAccuracyMeters; |
| (void)preferredTimeMs; |
| (void)lowPowerMode; |
| return true; |
| } |
| |
| Return<bool> Gnss20::start() { |
| std::unique_lock<std::mutex> lock(m_gnssHwConnMtx); |
| if (m_gnssHwConn) { |
| m_dataSink.start(); |
| return m_gnssHwConn->start(); |
| } else { |
| return false; |
| } |
| } |
| |
| Return<bool> Gnss20::stop() { |
| std::unique_lock<std::mutex> lock(m_gnssHwConnMtx); |
| if (m_gnssHwConn) { |
| return m_gnssHwConn->stop(); |
| } else { |
| return false; |
| } |
| } |
| |
| Return<void> Gnss20::cleanup() { |
| { |
| std::unique_lock<std::mutex> lock(m_gnssHwConnMtx); |
| m_gnssHwConn.reset(); |
| } |
| |
| m_dataSink.cleanup(); |
| |
| return {}; |
| } |
| |
| Return<bool> Gnss20::injectTime(int64_t timeMs, int64_t timeReferenceMs, |
| int32_t uncertaintyMs) { |
| (void)timeMs; |
| (void)timeReferenceMs; |
| (void)uncertaintyMs; |
| return true; |
| } |
| |
| Return<bool> Gnss20::injectLocation(double latitudeDegrees, double longitudeDegrees, |
| float accuracyMeters) { |
| (void)latitudeDegrees; |
| (void)longitudeDegrees; |
| (void)accuracyMeters; |
| return false; |
| } |
| |
| Return<void> Gnss20::deleteAidingData(ahg10::IGnss::GnssAidingData aidingDataFlags) { |
| (void)aidingDataFlags; |
| return {}; |
| } |
| |
| Return<sp<ahg10::IGnssGeofencing>> Gnss20::getExtensionGnssGeofencing() { |
| return nullptr; |
| } |
| |
| Return<sp<ahg10::IGnssNavigationMessage>> Gnss20::getExtensionGnssNavigationMessage() { |
| return nullptr; |
| } |
| |
| Return<sp<ahg10::IGnssXtra>> Gnss20::getExtensionXtra() { |
| return nullptr; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| bool Gnss20::open() { |
| std::unique_lock<std::mutex> lock(m_gnssHwConnMtx); |
| if (m_gnssHwConn) { |
| return true; |
| } else { |
| auto conn = std::make_unique<GnssHwConn>(&m_dataSink); |
| if (conn->ok()) { |
| m_gnssHwConn = std::move(conn); |
| return true; |
| } else { |
| return false; |
| } |
| } |
| } |
| |
| //// deprecated and old versions /////////////////////////////////////////////// |
| Return<bool> Gnss20::setCallback_1_1(const sp<ahg11::IGnssCallback>&) { |
| return false; |
| } |
| |
| Return<sp<ahg11::IGnssMeasurement>> Gnss20::getExtensionGnssMeasurement_1_1() { |
| return nullptr; |
| } |
| |
| Return<sp<ahg11::IGnssConfiguration>> Gnss20::getExtensionGnssConfiguration_1_1() { |
| return nullptr; |
| } |
| |
| Return<bool> Gnss20::setCallback(const sp<ahg10::IGnssCallback>&) { |
| return false; |
| } |
| |
| Return<sp<ahg10::IGnssMeasurement>> Gnss20::getExtensionGnssMeasurement() { |
| return nullptr; |
| } |
| |
| Return<sp<ahg10::IAGnss>> Gnss20::getExtensionAGnss() { |
| return nullptr; |
| } |
| |
| Return<sp<ahg10::IGnssNi>> Gnss20::getExtensionGnssNi() { |
| return nullptr; |
| } |
| |
| Return<sp<ahg10::IGnssDebug>> Gnss20::getExtensionGnssDebug() { |
| return nullptr; |
| } |
| |
| Return<sp<ahg10::IGnssBatching>> Gnss20::getExtensionGnssBatching() { |
| return nullptr; |
| } |
| |
| Return<bool> Gnss20::injectBestLocation(const ahg10::GnssLocation&) { |
| return false; |
| } |
| |
| Return<bool> Gnss20::setPositionMode(ahg10::IGnss::GnssPositionMode, |
| ahg10::IGnss::GnssPositionRecurrence, |
| uint32_t, uint32_t, uint32_t) { |
| return false; |
| } |
| |
| Return<sp<ahg10::IGnssConfiguration>> Gnss20::getExtensionGnssConfiguration() { |
| return nullptr; |
| } |
| |
| Return<sp<ahg10::IAGnssRil>> Gnss20::getExtensionAGnssRil() { |
| return nullptr; |
| } |
| |
| } // namespace goldfish |