tequilaOS/platform_hardware_interfaces
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
platform_hardware_interfaces/gnss/1.0/default/Gnss.cpp
Yipeng Cao a36f51a127 Fixed the hasCarrierFrequency flag in GnssStatus(part 2) 
Bug: 37757180
Fixes: 37757180
Test: cts-tradefed run cts -m CtsLocationTestCases --test
android.location.cts.GnssStatusTest

Change-Id: I817931ee2c19d0a770c4d7cedfbd69bc85db6978
Chang-Id: Icf4240ccad7ff367d96001973c0be36308ffd9b3
2017-04-28 21:35:58 +00:00

762 lines
25 KiB
C++
Raw Blame History

/*
* 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 %zd. 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 %zd. 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) {
ALOGE("%s GnssRil interface not implemented by GNSS 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 GNSS 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 GNSS 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 GNSS 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) {
ALOGE("%s GnssNi interface not implemented by GNSS 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 GNSS 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) {
ALOGE("%s GnssNavigationMessage interface not implemented by GNSS 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) {
ALOGE("%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) {
ALOGE("%s: GnssDebug interface is 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
Reference in a new issue View git blame Copy permalink