diff options
Diffstat (limited to 'gnss/1.0-legacy/Gnss.cpp')
-rw-r--r-- | gnss/1.0-legacy/Gnss.cpp | 761 |
1 files changed, 761 insertions, 0 deletions
diff --git a/gnss/1.0-legacy/Gnss.cpp b/gnss/1.0-legacy/Gnss.cpp new file mode 100644 index 0000000..32c131c --- /dev/null +++ b/gnss/1.0-legacy/Gnss.cpp @@ -0,0 +1,761 @@ +/* + * Copyright (C) 2016 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. + */ + +#define LOG_TAG "GnssHAL_GnssInterface" + +#include "Gnss.h" +#include <GnssUtils.h> + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +std::vector<std::unique_ptr<ThreadFuncArgs>> Gnss::sThreadFuncArgsList; +sp<IGnssCallback> Gnss::sGnssCbIface = nullptr; +bool Gnss::sInterfaceExists = false; +bool Gnss::sWakelockHeldGnss = false; +bool Gnss::sWakelockHeldFused = false; + +GpsCallbacks Gnss::sGnssCb = { + .size = sizeof(GpsCallbacks), + .location_cb = locationCb, + .status_cb = statusCb, + .sv_status_cb = gpsSvStatusCb, + .nmea_cb = nmeaCb, + .set_capabilities_cb = setCapabilitiesCb, + .acquire_wakelock_cb = acquireWakelockCb, + .release_wakelock_cb = releaseWakelockCb, + .create_thread_cb = createThreadCb, + .request_utc_time_cb = requestUtcTimeCb, + .set_system_info_cb = setSystemInfoCb, + .gnss_sv_status_cb = gnssSvStatusCb, +}; + +uint32_t Gnss::sCapabilitiesCached = 0; +uint16_t Gnss::sYearOfHwCached = 0; + +Gnss::Gnss(gps_device_t* gnssDevice) : + mDeathRecipient(new GnssHidlDeathRecipient(this)) { + /* Error out if an instance of the interface already exists. */ + LOG_ALWAYS_FATAL_IF(sInterfaceExists); + sInterfaceExists = true; + + if (gnssDevice == nullptr) { + ALOGE("%s: Invalid device_t handle", __func__); + return; + } + + mGnssIface = gnssDevice->get_gps_interface(gnssDevice); +} + +Gnss::~Gnss() { + sInterfaceExists = false; + sThreadFuncArgsList.clear(); +} + +void Gnss::locationCb(GpsLocation* location) { + if (sGnssCbIface == nullptr) { + ALOGE("%s: GNSS Callback Interface configured incorrectly", __func__); + return; + } + + if (location == nullptr) { + ALOGE("%s: Invalid location from GNSS HAL", __func__); + return; + } + + android::hardware::gnss::V1_0::GnssLocation gnssLocation = convertToGnssLocation(location); + auto ret = sGnssCbIface->gnssLocationCb(gnssLocation); + if (!ret.isOk()) { + ALOGE("%s: Unable to invoke callback", __func__); + } +} + +void Gnss::statusCb(GpsStatus* gnssStatus) { + if (sGnssCbIface == nullptr) { + ALOGE("%s: GNSS Callback Interface configured incorrectly", __func__); + return; + } + + if (gnssStatus == nullptr) { + ALOGE("%s: Invalid GpsStatus from GNSS HAL", __func__); + return; + } + + IGnssCallback::GnssStatusValue status = + static_cast<IGnssCallback::GnssStatusValue>(gnssStatus->status); + + auto ret = sGnssCbIface->gnssStatusCb(status); + if (!ret.isOk()) { + ALOGE("%s: Unable to invoke callback", __func__); + } +} + +void Gnss::gnssSvStatusCb(GnssSvStatus* status) { + if (sGnssCbIface == nullptr) { + ALOGE("%s: GNSS Callback Interface configured incorrectly", __func__); + return; + } + + if (status == nullptr) { + ALOGE("Invalid status from GNSS HAL %s", __func__); + return; + } + + IGnssCallback::GnssSvStatus svStatus; + svStatus.numSvs = status->num_svs; + + if (svStatus.numSvs > static_cast<uint32_t>(GnssMax::SVS_COUNT)) { + ALOGW("Too many satellites %u. Clamps to %d.", svStatus.numSvs, GnssMax::SVS_COUNT); + svStatus.numSvs = static_cast<uint32_t>(GnssMax::SVS_COUNT); + } + + for (size_t i = 0; i < svStatus.numSvs; i++) { + auto svInfo = status->gnss_sv_list[i]; + IGnssCallback::GnssSvInfo gnssSvInfo = { + .svid = svInfo.svid, + .constellation = static_cast< + android::hardware::gnss::V1_0::GnssConstellationType>( + svInfo.constellation), + .cN0Dbhz = svInfo.c_n0_dbhz, + .elevationDegrees = svInfo.elevation, + .azimuthDegrees = svInfo.azimuth, + // Older chipsets do not provide carrier frequency, hence + // HAS_CARRIER_FREQUENCY flag and the carrierFrequencyHz fields + // are not set. So we are resetting both fields here. + .svFlag = static_cast<uint8_t>( + svInfo.flags &= ~(static_cast<uint8_t>( + IGnssCallback::GnssSvFlags::HAS_CARRIER_FREQUENCY))), + .carrierFrequencyHz = 0}; + svStatus.gnssSvList[i] = gnssSvInfo; + } + + auto ret = sGnssCbIface->gnssSvStatusCb(svStatus); + if (!ret.isOk()) { + ALOGE("%s: Unable to invoke callback", __func__); + } +} + +/* + * This enum is used by gpsSvStatusCb() method below to convert GpsSvStatus + * to GnssSvStatus for backward compatibility. It is only used by the default + * implementation and is not part of the GNSS interface. + */ +enum SvidValues : uint16_t { + GLONASS_SVID_OFFSET = 64, + GLONASS_SVID_COUNT = 24, + BEIDOU_SVID_OFFSET = 200, + BEIDOU_SVID_COUNT = 35, + SBAS_SVID_MIN = 33, + SBAS_SVID_MAX = 64, + SBAS_SVID_ADD = 87, + QZSS_SVID_MIN = 193, + QZSS_SVID_MAX = 200 +}; + +/* + * The following code that converts GpsSvStatus to GnssSvStatus is moved here from + * GnssLocationProvider. GnssLocationProvider does not require it anymore since GpsSvStatus is + * being deprecated and is no longer part of the GNSS interface. + */ +void Gnss::gpsSvStatusCb(GpsSvStatus* svInfo) { + if (sGnssCbIface == nullptr) { + ALOGE("%s: GNSS Callback Interface configured incorrectly", __func__); + return; + } + + if (svInfo == nullptr) { + ALOGE("Invalid status from GNSS HAL %s", __func__); + return; + } + + IGnssCallback::GnssSvStatus svStatus; + svStatus.numSvs = svInfo->num_svs; + /* + * Clamp the list size since GnssSvStatus can support a maximum of + * GnssMax::SVS_COUNT entries. + */ + if (svStatus.numSvs > static_cast<uint32_t>(GnssMax::SVS_COUNT)) { + ALOGW("Too many satellites %u. Clamps to %d.", svStatus.numSvs, GnssMax::SVS_COUNT); + svStatus.numSvs = static_cast<uint32_t>(GnssMax::SVS_COUNT); + } + + uint32_t ephemerisMask = svInfo->ephemeris_mask; + uint32_t almanacMask = svInfo->almanac_mask; + uint32_t usedInFixMask = svInfo->used_in_fix_mask; + /* + * Conversion from GpsSvInfo to IGnssCallback::GnssSvInfo happens below. + */ + for (size_t i = 0; i < svStatus.numSvs; i++) { + IGnssCallback::GnssSvInfo& info = svStatus.gnssSvList[i]; + info.svid = svInfo->sv_list[i].prn; + if (info.svid >= 1 && info.svid <= 32) { + info.constellation = GnssConstellationType::GPS; + } else if (info.svid > GLONASS_SVID_OFFSET && + info.svid <= GLONASS_SVID_OFFSET + GLONASS_SVID_COUNT) { + info.constellation = GnssConstellationType::GLONASS; + info.svid -= GLONASS_SVID_OFFSET; + } else if (info.svid > BEIDOU_SVID_OFFSET && + info.svid <= BEIDOU_SVID_OFFSET + BEIDOU_SVID_COUNT) { + info.constellation = GnssConstellationType::BEIDOU; + info.svid -= BEIDOU_SVID_OFFSET; + } else if (info.svid >= SBAS_SVID_MIN && info.svid <= SBAS_SVID_MAX) { + info.constellation = GnssConstellationType::SBAS; + info.svid += SBAS_SVID_ADD; + } else if (info.svid >= QZSS_SVID_MIN && info.svid <= QZSS_SVID_MAX) { + info.constellation = GnssConstellationType::QZSS; + } else { + ALOGD("Unknown constellation type with Svid = %d.", info.svid); + info.constellation = GnssConstellationType::UNKNOWN; + } + + info.cN0Dbhz = svInfo->sv_list[i].snr; + info.elevationDegrees = svInfo->sv_list[i].elevation; + info.azimuthDegrees = svInfo->sv_list[i].azimuth; + // TODO: b/31702236 + info.svFlag = static_cast<uint8_t>(IGnssCallback::GnssSvFlags::NONE); + + /* + * Only GPS info is valid for these fields, as these masks are just 32 + * bits, by GPS prn. + */ + if (info.constellation == GnssConstellationType::GPS) { + int32_t svidMask = (1 << (info.svid - 1)); + if ((ephemerisMask & svidMask) != 0) { + info.svFlag |= IGnssCallback::GnssSvFlags::HAS_EPHEMERIS_DATA; + } + if ((almanacMask & svidMask) != 0) { + info.svFlag |= IGnssCallback::GnssSvFlags::HAS_ALMANAC_DATA; + } + if ((usedInFixMask & svidMask) != 0) { + info.svFlag |= IGnssCallback::GnssSvFlags::USED_IN_FIX; + } + } + } + + auto ret = sGnssCbIface->gnssSvStatusCb(svStatus); + if (!ret.isOk()) { + ALOGE("%s: Unable to invoke callback", __func__); + } +} + +void Gnss::nmeaCb(GpsUtcTime timestamp, const char* nmea, int length) { + if (sGnssCbIface == nullptr) { + ALOGE("%s: GNSS Callback Interface configured incorrectly", __func__); + return; + } + + android::hardware::hidl_string nmeaString; + nmeaString.setToExternal(nmea, length); + auto ret = sGnssCbIface->gnssNmeaCb(timestamp, nmeaString); + if (!ret.isOk()) { + ALOGE("%s: Unable to invoke callback", __func__); + } +} + +void Gnss::setCapabilitiesCb(uint32_t capabilities) { + if (sGnssCbIface == nullptr) { + ALOGE("%s: GNSS Callback Interface configured incorrectly", __func__); + return; + } + + auto ret = sGnssCbIface->gnssSetCapabilitesCb(capabilities); + if (!ret.isOk()) { + ALOGE("%s: Unable to invoke callback", __func__); + } + + // Save for reconnection when some legacy hal's don't resend this info + sCapabilitiesCached = capabilities; +} + +void Gnss::acquireWakelockCb() { + acquireWakelockGnss(); +} + +void Gnss::releaseWakelockCb() { + releaseWakelockGnss(); +} + + +void Gnss::acquireWakelockGnss() { + sWakelockHeldGnss = true; + updateWakelock(); +} + +void Gnss::releaseWakelockGnss() { + sWakelockHeldGnss = false; + updateWakelock(); +} + +void Gnss::acquireWakelockFused() { + sWakelockHeldFused = true; + updateWakelock(); +} + +void Gnss::releaseWakelockFused() { + sWakelockHeldFused = false; + updateWakelock(); +} + +void Gnss::updateWakelock() { + // Track the state of the last request - in case the wake lock in the layer above is reference + // counted. + static bool sWakelockHeld = false; + + if (sGnssCbIface == nullptr) { + ALOGE("%s: GNSS Callback Interface configured incorrectly", __func__); + return; + } + + if (sWakelockHeldGnss || sWakelockHeldFused) { + if (!sWakelockHeld) { + ALOGI("%s: GNSS HAL Wakelock acquired due to gps: %d, fused: %d", __func__, + sWakelockHeldGnss, sWakelockHeldFused); + sWakelockHeld = true; + auto ret = sGnssCbIface->gnssAcquireWakelockCb(); + if (!ret.isOk()) { + ALOGE("%s: Unable to invoke callback", __func__); + } + } + } else { + if (sWakelockHeld) { + ALOGI("%s: GNSS HAL Wakelock released", __func__); + } else { + // To avoid burning power, always release, even if logic got here with sWakelock false + // which it shouldn't, unless underlying *.h implementation makes duplicate requests. + ALOGW("%s: GNSS HAL Wakelock released, duplicate request", __func__); + } + sWakelockHeld = false; + auto ret = sGnssCbIface->gnssReleaseWakelockCb(); + if (!ret.isOk()) { + ALOGE("%s: Unable to invoke callback", __func__); + } + } +} + +void Gnss::requestUtcTimeCb() { + if (sGnssCbIface == nullptr) { + ALOGE("%s: GNSS Callback Interface configured incorrectly", __func__); + return; + } + + auto ret = sGnssCbIface->gnssRequestTimeCb(); + if (!ret.isOk()) { + ALOGE("%s: Unable to invoke callback", __func__); + } +} + +pthread_t Gnss::createThreadCb(const char* name, void (*start)(void*), void* arg) { + return createPthread(name, start, arg, &sThreadFuncArgsList); +} + +void Gnss::setSystemInfoCb(const LegacyGnssSystemInfo* info) { + if (sGnssCbIface == nullptr) { + ALOGE("%s: GNSS Callback Interface configured incorrectly", __func__); + return; + } + + if (info == nullptr) { + ALOGE("Invalid GnssSystemInfo from GNSS HAL %s", __func__); + return; + } + + IGnssCallback::GnssSystemInfo gnssInfo = { + .yearOfHw = info->year_of_hw + }; + + auto ret = sGnssCbIface->gnssSetSystemInfoCb(gnssInfo); + if (!ret.isOk()) { + ALOGE("%s: Unable to invoke callback", __func__); + } + + // Save for reconnection when some legacy hal's don't resend this info + sYearOfHwCached = info->year_of_hw; +} + + +// Methods from ::android::hardware::gnss::V1_0::IGnss follow. +Return<bool> Gnss::setCallback(const sp<IGnssCallback>& callback) { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return false; + } + + if (callback == nullptr) { + ALOGE("%s: Null callback ignored", __func__); + return false; + } + + if (sGnssCbIface != NULL) { + ALOGW("%s called more than once. Unexpected unless test.", __func__); + sGnssCbIface->unlinkToDeath(mDeathRecipient); + } + + sGnssCbIface = callback; + callback->linkToDeath(mDeathRecipient, 0 /*cookie*/); + + // If this was received in the past, send it up again to refresh caller. + // mGnssIface will override after init() is called below, if needed + // (though it's unlikely the gps.h capabilities or system info will change.) + if (sCapabilitiesCached != 0) { + setCapabilitiesCb(sCapabilitiesCached); + } + if (sYearOfHwCached != 0) { + LegacyGnssSystemInfo info; + info.year_of_hw = sYearOfHwCached; + setSystemInfoCb(&info); + } + + return (mGnssIface->init(&sGnssCb) == 0); +} + +Return<bool> Gnss::start() { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return false; + } + + return (mGnssIface->start() == 0); +} + +Return<bool> Gnss::stop() { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return false; + } + + return (mGnssIface->stop() == 0); +} + +Return<void> Gnss::cleanup() { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + } else { + mGnssIface->cleanup(); + } + return Void(); +} + +Return<bool> Gnss::injectLocation(double latitudeDegrees, + double longitudeDegrees, + float accuracyMeters) { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return false; + } + + return (mGnssIface->inject_location(latitudeDegrees, longitudeDegrees, accuracyMeters) == 0); +} + +Return<bool> Gnss::injectTime(int64_t timeMs, int64_t timeReferenceMs, + int32_t uncertaintyMs) { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return false; + } + + return (mGnssIface->inject_time(timeMs, timeReferenceMs, uncertaintyMs) == 0); +} + +Return<void> Gnss::deleteAidingData(IGnss::GnssAidingData aidingDataFlags) { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + } else { + mGnssIface->delete_aiding_data(static_cast<GpsAidingData>(aidingDataFlags)); + } + return Void(); +} + +Return<bool> Gnss::setPositionMode(IGnss::GnssPositionMode mode, + IGnss::GnssPositionRecurrence recurrence, + uint32_t minIntervalMs, + uint32_t preferredAccuracyMeters, + uint32_t preferredTimeMs) { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return false; + } + + return (mGnssIface->set_position_mode(static_cast<GpsPositionMode>(mode), + static_cast<GpsPositionRecurrence>(recurrence), + minIntervalMs, + preferredAccuracyMeters, + preferredTimeMs) == 0); +} + +Return<sp<IAGnssRil>> Gnss::getExtensionAGnssRil() { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return nullptr; + } + + if (mGnssRil == nullptr) { + const AGpsRilInterface* agpsRilIface = static_cast<const AGpsRilInterface*>( + mGnssIface->get_extension(AGPS_RIL_INTERFACE)); + if (agpsRilIface == nullptr) { + ALOGI("%s: GnssRil interface not implemented by HAL", __func__); + } else { + mGnssRil = new AGnssRil(agpsRilIface); + } + } + return mGnssRil; +} + +Return<sp<IGnssConfiguration>> Gnss::getExtensionGnssConfiguration() { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return nullptr; + } + + if (mGnssConfig == nullptr) { + const GnssConfigurationInterface* gnssConfigIface = + static_cast<const GnssConfigurationInterface*>( + mGnssIface->get_extension(GNSS_CONFIGURATION_INTERFACE)); + + if (gnssConfigIface == nullptr) { + ALOGE("%s: GnssConfiguration interface not implemented by HAL", __func__); + } else { + mGnssConfig = new GnssConfiguration(gnssConfigIface); + } + } + return mGnssConfig; +} + +Return<sp<IGnssGeofencing>> Gnss::getExtensionGnssGeofencing() { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return nullptr; + } + + if (mGnssGeofencingIface == nullptr) { + const GpsGeofencingInterface* gpsGeofencingIface = + static_cast<const GpsGeofencingInterface*>( + mGnssIface->get_extension(GPS_GEOFENCING_INTERFACE)); + + if (gpsGeofencingIface == nullptr) { + ALOGE("%s: GnssGeofencing interface not implemented by HAL", __func__); + } else { + mGnssGeofencingIface = new GnssGeofencing(gpsGeofencingIface); + } + } + + return mGnssGeofencingIface; +} + +Return<sp<IAGnss>> Gnss::getExtensionAGnss() { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return nullptr; + } + + if (mAGnssIface == nullptr) { + const AGpsInterface* agpsIface = static_cast<const AGpsInterface*>( + mGnssIface->get_extension(AGPS_INTERFACE)); + if (agpsIface == nullptr) { + ALOGE("%s: AGnss interface not implemented by HAL", __func__); + } else { + mAGnssIface = new AGnss(agpsIface); + } + } + return mAGnssIface; +} + +Return<sp<IGnssNi>> Gnss::getExtensionGnssNi() { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return nullptr; + } + + if (mGnssNi == nullptr) { + const GpsNiInterface* gpsNiIface = static_cast<const GpsNiInterface*>( + mGnssIface->get_extension(GPS_NI_INTERFACE)); + if (gpsNiIface == nullptr) { + ALOGI("%s: GnssNi interface not implemented by HAL", __func__); + } else { + mGnssNi = new GnssNi(gpsNiIface); + } + } + return mGnssNi; +} + +Return<sp<IGnssMeasurement>> Gnss::getExtensionGnssMeasurement() { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return nullptr; + } + + if (mGnssMeasurement == nullptr) { + const GpsMeasurementInterface* gpsMeasurementIface = + static_cast<const GpsMeasurementInterface*>( + mGnssIface->get_extension(GPS_MEASUREMENT_INTERFACE)); + + if (gpsMeasurementIface == nullptr) { + ALOGE("%s: GnssMeasurement interface not implemented by HAL", __func__); + } else { + mGnssMeasurement = new GnssMeasurement(gpsMeasurementIface); + } + } + return mGnssMeasurement; +} + +Return<sp<IGnssNavigationMessage>> Gnss::getExtensionGnssNavigationMessage() { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return nullptr; + } + + if (mGnssNavigationMessage == nullptr) { + const GpsNavigationMessageInterface* gpsNavigationMessageIface = + static_cast<const GpsNavigationMessageInterface*>( + mGnssIface->get_extension(GPS_NAVIGATION_MESSAGE_INTERFACE)); + + if (gpsNavigationMessageIface == nullptr) { + ALOGI("%s: GnssNavigationMessage interface not implemented by HAL", __func__); + } else { + mGnssNavigationMessage = new GnssNavigationMessage(gpsNavigationMessageIface); + } + } + + return mGnssNavigationMessage; +} + +Return<sp<IGnssXtra>> Gnss::getExtensionXtra() { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return nullptr; + } + + if (mGnssXtraIface == nullptr) { + const GpsXtraInterface* gpsXtraIface = static_cast<const GpsXtraInterface*>( + mGnssIface->get_extension(GPS_XTRA_INTERFACE)); + + if (gpsXtraIface == nullptr) { + ALOGI("%s: GnssXtra interface not implemented by HAL", __func__); + } else { + mGnssXtraIface = new GnssXtra(gpsXtraIface); + } + } + + return mGnssXtraIface; +} + +Return<sp<IGnssDebug>> Gnss::getExtensionGnssDebug() { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return nullptr; + } + + if (mGnssDebug == nullptr) { + const GpsDebugInterface* gpsDebugIface = static_cast<const GpsDebugInterface*>( + mGnssIface->get_extension(GPS_DEBUG_INTERFACE)); + + if (gpsDebugIface == nullptr) { + ALOGI("%s: GnssDebug interface not implemented by HAL", __func__); + } else { + mGnssDebug = new GnssDebug(gpsDebugIface); + } + } + + return mGnssDebug; +} + +Return<sp<IGnssBatching>> Gnss::getExtensionGnssBatching() { + if (mGnssIface == nullptr) { + ALOGE("%s: Gnss interface is unavailable", __func__); + return nullptr; + } + + if (mGnssBatching == nullptr) { + hw_module_t* module; + const FlpLocationInterface* flpLocationIface = nullptr; + int err = hw_get_module(FUSED_LOCATION_HARDWARE_MODULE_ID, (hw_module_t const**)&module); + + if (err != 0) { + ALOGE("gnss flp hw_get_module failed: %d", err); + } else if (module == nullptr) { + ALOGE("Fused Location hw_get_module returned null module"); + } else if (module->methods == nullptr) { + ALOGE("Fused Location hw_get_module returned null methods"); + } else { + hw_device_t* device; + err = module->methods->open(module, FUSED_LOCATION_HARDWARE_MODULE_ID, &device); + if (err != 0) { + ALOGE("flpDevice open failed: %d", err); + } else { + flp_device_t * flpDevice = reinterpret_cast<flp_device_t*>(device); + flpLocationIface = flpDevice->get_flp_interface(flpDevice); + } + } + + if (flpLocationIface == nullptr) { + ALOGE("%s: GnssBatching interface is not implemented by HAL", __func__); + } else { + mGnssBatching = new GnssBatching(flpLocationIface); + } + } + return mGnssBatching; +} + +void Gnss::handleHidlDeath() { + ALOGW("GNSS service noticed HIDL death. Stopping all GNSS operations."); + + // commands down to the HAL implementation + stop(); // stop ongoing GPS tracking + if (mGnssMeasurement != nullptr) { + mGnssMeasurement->close(); + } + if (mGnssNavigationMessage != nullptr) { + mGnssNavigationMessage->close(); + } + if (mGnssBatching != nullptr) { + mGnssBatching->stop(); + mGnssBatching->cleanup(); + } + cleanup(); + + /* + * This has died, so close it off in case (race condition) callbacks happen + * before HAL processes above messages. + */ + sGnssCbIface = nullptr; +} + +IGnss* HIDL_FETCH_IGnss(const char* /* hal */) { + hw_module_t* module; + IGnss* iface = nullptr; + int err = hw_get_module(GPS_HARDWARE_MODULE_ID, (hw_module_t const**)&module); + + if (err == 0) { + hw_device_t* device; + err = module->methods->open(module, GPS_HARDWARE_MODULE_ID, &device); + if (err == 0) { + iface = new Gnss(reinterpret_cast<gps_device_t*>(device)); + } else { + ALOGE("gnssDevice open %s failed: %d", GPS_HARDWARE_MODULE_ID, err); + } + } else { + ALOGE("gnss hw_get_module %s failed: %d", GPS_HARDWARE_MODULE_ID, err); + } + return iface; +} + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android |